diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b38d01f2a..c8e3c8b4a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -66,11 +66,11 @@ jobs: - name: Test Ix CLI if: github.event_name != 'push' run: lake test --wfail -- cli - - name: Test Ixon v3 contracts and consumers + - name: Test Ixon v4 contracts and consumers if: github.event_name != 'push' run: | - lake exe ixon-v3-primitives - lake exe ixon-v3-tests --primitives + lake exe ixon-v4-primitives + lake exe ixon-v4-tests --primitives rust-test: runs-on: runs-on=${{ github.run_id }}-rust-test-${{ github.run_attempt }}/cpu=8/family=r7i+r8i+r7a+r8a/image=ubuntu26-full-x64/volume=100gb/sticky=ci-rust-test-x86-64-v4:50gb/extras=s3-cache @@ -108,9 +108,9 @@ 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,ixon/sharing-profile -- -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,ixon/sharing-profile - name: Tests run: cargo nextest run --release --profile ci --workspace ${{ github.event_name == 'push' && '--no-run' || '' }} - name: Get Rust version diff --git a/.gitignore b/.gitignore index 22003795f..9387cfe12 100644 --- a/.gitignore +++ b/.gitignore @@ -10,7 +10,7 @@ result* #Ix *.ixe -!Tests/Fixtures/ixon-v3/handoff/*.ixe +!Tests/Fixtures/ixon-v4/handoff/*.ixe plans refs diff --git a/Benchmarks/LeanSharingProf.lean b/Benchmarks/LeanSharingProf.lean new file mode 100644 index 000000000..154ab2931 --- /dev/null +++ b/Benchmarks/LeanSharingProf.lean @@ -0,0 +1,207 @@ +import Ix.Ixon +import Ix.Sharing.Exact + +/-! +# Phase profiler for the Lean tiered sharing construction + +``` +lake exe lean-sharing-prof full [select-file] +lake exe lean-sharing-prof split [select-file] +lake exe lean-sharing-prof hash [select-file] +``` + +Every mode runs `normalizeConstantSharingTiered .tagN` under the default +limits on each constant of the corpus (or those whose hex addresses are +listed, one per line, in the select file), checks that the output serializes +to the stored bytes (the corpus must have been compiled on the canonical +route), and prints the total time and the slowest constants. It exits with 1 +when a constant does not decode, the construction fails, or an output differs +from the stored bytes. +`split` first replays each width's phases separately (`profWidth`, a copy of +`tieredAtWidth` and the uniform optimizer's stages) and prints the time per +phase, summed over the constants and the three widths, plus component +statistics (`cstat.*`) and phase-3 statistics (`stat.*`), counts scaled by +10^6 in the ms column. `hash` also prints each output's address. +A development tool: `profWidth` replicates internal stages and must follow +them. +-/ + +open Ixon Ix.Sharing.Exact + +namespace Benchmarks.LeanSharingProf + +abbrev Acc := IO.Ref (Std.HashMap String Nat) + +@[noinline] def timeIt {α} (acc : Acc) (key : String) (f : Unit → α) : IO α := do + let t0 ← IO.monoNanosNow + let r ← IO.lazyPure f + let t1 ← IO.monoNanosNow + acc.modify fun m => m.insert key (m.getD key 0 + (t1 - t0)) + return r + +def must {α} [Inhabited α] (key : String) : Except SharingError α → IO α + | .ok a => pure a + | .error e => throw (IO.userError s!"{key}: {reprStr e}") + +/-- Phase-split replica of `tieredAtWidth`. -/ +def profWidth (acc : Acc) (limits : Limits) (ex : Expanded) (w : Nat) : + IO TieredSharingResult := do + let layout := ShareLayout.tagN + let p ← timeIt acc "u0.prep" fun _ => Prep.ofDag ex.dag + let _ ← timeIt acc "u0.checks" fun _ => + childrenPrecede ex.dag.nodes && ex.dag.nodes.all (fun node => node.children.size == node.head.arity) && + ex.roots.all (· < ex.dag.size) && (reachMarks ex.dag.nodes ex.roots).all id && + (List.range ex.dag.size).all (fun t => p.spineLen[t]! < teleSubaddEnd) + -- stage, split + let f ← timeIt acc "u1.facts" fun _ => graphFacts ex.dag ex.roots + let cand ← timeIt acc "u1.cand" fun _ => searchCandidates p f w + let _ ← timeIt acc "u1.bounds" fun _ => uniformBounds p w cand + let _ ← timeIt acc "u1.vis" fun _ => visibleCounts ex.dag ex.roots cand + let sg ← timeIt acc "u1.stage" fun _ => uniformStage w ex p + let _ ← timeIt acc "u1.upmk" fun _ => UPrep.mk' p w sg.opaq + let _ ← timeIt acc "u1.baseEv" fun _ => p.eval sg.widthCs sg.allTrue + let _ ← timeIt acc "u1.comps" fun _ => uncertainComponents ex.dag sg.cls + let ok ← timeIt acc "u2.compCheck" fun _ => + componentsChecked ex.dag sg.cls sg.opaq sg.comps (componentLabels ex.dag.size sg.comps) + unless ok do throw (IO.userError "components") + -- the component search as production runs it (`searchComponents`, which + -- compiled code replaces by the area- and closure-local search) + let (results, states, costEvals) ← must "search" + (← timeIt acc "u3.search" fun _ => searchComponents limits ex sg) + -- component statistics (untimed): the specification context of each + -- component, for its closure and area sizes + for members in sg.comps do + let cx := mkSCtx ex sg.f sg.up sg.cand sg.b0 sg.vis0 sg.rootCount sg.slack sg.theta + sg.baseEv sg.widthCs sg.allTrue sg.unc members + acc.modify fun mm => ((((mm.insert "cstat.n" (mm.getD "cstat.n" 0 + ex.dag.size * 1000000)).insert + "cstat.closure" (mm.getD "cstat.closure" 0 + cx.closure.size * 1000000)).insert + "cstat.area" (mm.getD "cstat.area" 0 + cx.area.size * 1000000)).insert + "cstat.members" (mm.getD "cstat.members" 0 + cx.members.size * 1000000)).insert + "cstat.comps" (mm.getD "cstat.comps" 0 + 1000000) + let (chosenDelta, chosenX, lowerBracket) ← must "knap" + (← timeIt acc "u4.knap" fun _ => uniformKnapsack limits sg.cs.size results) + let csb ← timeIt acc "u4.csBase" fun _ => csBase ex p sg + let modelInt : _root_.Int := (csb : Nat) + chosenDelta + (tag0Size (sg.cs.size + chosenX.size) : _root_.Int) + let model := modelInt.toNat + let c : UniformChoice := + { facts := sg.f, certainStored := sg.cs, certainExcluded := sg.ce, uncertain := sg.unc, + lowDegree := sg.low, components := sg.comps, stored := mergeSorted sg.cs chosenX, model := model, + states := states, costEvals := costEvals, lowerBracket := lowerBracket } + -- finish, split + let _ ← timeIt acc "u5.inClass" fun _ => inClassCheck ex.dag ex.roots c.stored + let order ← timeIt acc "u5.pinned" fun _ => pinnedOrder ex.dag c.facts.deg c.stored + let n := ex.dag.size + let width := c.stored.foldl (fun acc t => acc.set! t (some w)) (Array.replicate n none) + let (entries, roots, _, _) ← must "matdep" + (← timeIt acc "u5.matDep" fun _ => p.materializeDependent order ex.roots width limits) + let _ ← must "reexp1" (← timeIt acc "u5.reexpand" fun _ => reexpand limits ex.dag entries roots) + let _ ← timeIt acc "u5.measure" fun _ => tag0Size entries.size + exprsSize entries + exprsSize roots + let u ← must "finish" (← timeIt acc "u5.finishAll" fun _ => + uniformFinishF w limits ex p sg.f.deg c) + -- phase 2 + let deg ← timeIt acc "p2.facts" fun _ => (graphFacts ex.dag ex.roots).deg + let wm ← timeIt acc "p2.weights" fun _ => tierWeights u.result.tableTerms u.result.sharing u.result.roots + let dm ← timeIt acc "p2.deps" fun _ => tierDeps u.result.tableTerms u.result.sharing + let weight := fun t => wm.getD t 0 + let deps := fun t => dm.getD t [] + let order1 := u.result.tableTerms + let (tier, _) ← must "tier" (← timeIt acc "p2.firstTier" fun _ => + firstTier order1 weight deps (min 8 order1.size) limits) + let stored := (order1.toList.mergeSort (· ≤ ·)).toArray + let rest := stored.filter (!tier.contains ·) + let _ ← timeIt acc "p2.kahn" fun _ => kahnOrder weight deps rest + let a ← must "alloc" (← timeIt acc "p2.allocAll" fun _ => + allocate layout limits ex.dag deg u.result.tableTerms u.result.sharing u.result.roots) + -- phase 3 + let phase1Layout ← timeIt acc "p3.layout1" fun _ => layoutBytes layout u.result.sharing u.result.roots + let (es, rs, _, _) ← must "mat" (← timeIt acc "p3.matTable" fun _ => + materializeTable (Prep.ofDag ex.dag) a.order ex.roots limits layout.widthAt) + let _ ← timeIt acc "p3.layout" fun _ => layoutBytes layout es rs + let _ ← must "reexp3" (← timeIt acc "p3.reexpand" fun _ => reexpand limits ex.dag es rs) + let _ ← timeIt acc "p3.measure" fun _ => tag0Size es.size + (es ++ rs).foldl (fun acc e => acc + (serExpr e).size) 0 + let _ ← timeIt acc "p3.wire" fun _ => (es ++ rs).all fun e => (wireCounts e).isSome + let m ← must "remat" (← timeIt acc "p3.rematAll" fun _ => rematerialize layout limits ex a.order phase1Layout) + -- statistics: ancestors per entry vs the scanned range + let nn := ex.dag.size + let (ancSum, scanSum) := a.order.foldl (fun (acc : Nat × Nat) t => + let mk := ancestorMarks ex.dag t + (acc.1 + (mk.filter id).size, acc.2 + (nn - t))) (0, 0) + acc.modify fun mm => (((mm.insert "stat.anc" (mm.getD "stat.anc" 0 + ancSum * 1000000)).insert + "stat.scan" (mm.getD "stat.scan" 0 + scanSum * 1000000)).insert "stat.work" (mm.getD "stat.work" 0 + m.work * 1000000)).insert + "stat.kn" (mm.getD "stat.kn" 0 + a.order.size * nn * 1000000) + timeIt acc "z.result" fun _ => tieredResult layout ex w u a m + +def usage : String := + "usage: lake exe lean-sharing-prof (full | split | hash) [select-file]" + +def main (args : List String) : IO UInt32 := do + unless (args.length == 2 || args.length == 3) && + ["full", "split", "hash"].contains (args[1]?.getD "") do + IO.eprintln usage + return 2 + let path : String := args[0]! + let mode : String := args[1]! + let selPath : Option String := args[2]? + let bytes ← IO.FS.readBinFile path + let env ← IO.ofExcept (Ixon.deEnvAnon bytes) + let entries := env.consts.toArray.qsort fun a b => Address.cmpBytes a.1 b.1 == .lt + let entries ← match selPath with + | some p => do + let lines := (← IO.FS.readFile p).splitOn "\n" |>.map (String.trimAscii · |>.toString) |>.filter (· != "") + let s := lines.foldl (fun (s : Std.HashSet String) l => s.insert l) {} + pure (entries.filter fun e => s.contains (toString e.1)) + | none => pure entries + let acc ← IO.mkRef ({} : Std.HashMap String Nat) + let mut total := 0 + let mut same := 0 + let mut differ := 0 + let mut failed := 0 + let mut perConst : Array (Nat × String × Nat) := #[] + for (addr, lc) in entries do + let c ← match lc.get with + | .ok c => pure c + | .error e => + failed := failed + 1 + IO.println s!"DECODE {addr}: {e}" + continue + let raw := lc.rawBytes + let label := match env.addrToName.get? addr with + | some n => s!"{n}" + | none => s!"{addr}" + let t0 ← IO.monoNanosNow + if mode == "split" then + let limits : Limits := {} + let roots := constantInfoRoots c.info + let ex ← must "expand" (← timeIt acc "a.expand" fun _ => expand limits c.sharing roots true) + for w in [1, 2, 3] do + try + let _ ← profWidth acc limits ex w + catch e => IO.eprintln s!"{label} w{w}: {e}" + let r ← timeIt acc "TOTAL.normalize" fun _ => normalizeConstantSharingTiered .tagN c {} + let t1 ← IO.monoNanosNow + total := total + (t1 - t0) + perConst := perConst.push (t1 - t0, label, c.sharing.size) + match r with + | .ok n => + let out := serConstant n + if out == raw then same := same + 1 else + differ := differ + 1 + IO.println s!"DIFFER {label} ({addr})" + if mode == "hash" then + IO.println s!"H {addr} {(Address.blake3 out)}" + | .error e => + failed := failed + 1 + IO.println s!"FAIL {label}: {reprStr e}" + IO.println s!"constants {entries.size}: same {same}, differ {differ}, failed {failed}; total {total / 1000000} ms" + let m ← acc.get + let keys := m.toArray.qsort fun a b => a.1 < b.1 + for (k, v) in keys do + IO.println s!" {k}: {v / 1000000} ms" + let slow := (perConst.qsort fun a b => a.1 > b.1).extract 0 15 + for (t, l, k) in slow do + IO.println s!" slow {t / 1000000} ms {l} (k {k})" + return if differ == 0 && failed == 0 then 0 else 1 + +end Benchmarks.LeanSharingProf + +def main (args : List String) : IO UInt32 := Benchmarks.LeanSharingProf.main args diff --git a/Benchmarks/SharingStudy.lean b/Benchmarks/SharingStudy.lean new file mode 100644 index 000000000..4809e5851 --- /dev/null +++ b/Benchmarks/SharingStudy.lean @@ -0,0 +1,994 @@ +import Ix.CompileM + +/-! +# Sharing corpus study + +Loads a serialized `Ixon.Env` (`.ixe`) and, for every stored constant: + +1. Expands the stored sharing table left to right. Entry `i` may reference + only entries `j < i`; each `Share j` is replaced by the *same* in-memory + expansion of entry `j`, so repeated indices share one subtree and the + expanded roots form a DAG whose size is linear in the stored bytes. + The ordered roots come from `Ix.Sharing.Exact.constantInfoRoots`. +2. Rebuilds the constant with the production route + (`Ix.CompileM.buildConstantWithSharing` under `compilerSharingLimits` on the + expanded roots, i.e. the canonical tiered construction) and checks that + `Ixon.serConstant` reproduces the stored bytes exactly. It also checks the + plain decode/encode roundtrip. This is the Lean side's whole-corpus rebuild + check; the harness exits 1 on any mismatch. +3. Hash-conses the expanded roots (`analyzeBlock`: blake3 Merkle hashes; hash + equality is treated as structural equality) and computes, per constant, the + distinct subterm count `N`, the longest App/Lam/All telescope and the + standalone unshared `putExpr` length of every subterm, compositionally on + the DAG with the App/Lam/All telescope rules. The unshared complete-Constant + size is checked against `serConstant` of the actual unshared constant + whenever the unshared root bytes are at most `--validate-max` (so no + exponential tree is ever serialized). +4. Builds the "maximal structural sharing" (MSS) baseline encoding (see + `mssBuild`), serializes it with `serConstant`, decodes and expands it again + and checks the expanded roots equal the original ones exactly, and compares + it with the canonical encoding. The `docs/sharing-minimum.md` §2 witnesses + are run through the same path at startup. + +``` +lake exe sharing-study [--md ] [--csv ] + [--limit ] [--validate-max ] [--progress ] +``` +-/ + +namespace Benchmarks.SharingStudy + +open Ixon (Expr Constant ConstantInfo MutConst) + +/-! ## Hash-consing analysis + +Harness-local structural analysis: blake3 Merkle hashes over the canonical node +headers, a pointer-to-hash cache and a leaves-first traversal order. Production +sharing is the canonical tiered construction (`Ix.Sharing.Exact`); nothing here +is on the compiler route. -/ + +/-- Canonical scalar/contract bytes of one node, without its children. -/ +def putNodeHeader : Expr → Ixon.PutM Unit + | e@(.sort _) | e@(.var _) | e@(.ref ..) | e@(.recur ..) | + e@(.str _) | e@(.nat _) | e@(.share _) => Ixon.putExpr e + | .prj idx field _ => do + Ixon.putTagN 4 Ixon.Expr.FLAG_PRJ field + Ixon.putTagN 0 0 idx + | .app .. => Ixon.putTagN 4 Ixon.Expr.FLAG_APP 1 + | .lam contract .. => do + Ixon.putTagN 4 Ixon.Expr.FLAG_LAM 1 + Ixon.putBinderContract contract + | .all contract result .. => do + Ixon.putTagN 4 Ixon.Expr.FLAG_ALL 1 + Ixon.putU8 (Ixon.packAllContract contract result) + | .letE contract .. => do + Ixon.putTagN 4 Ixon.Expr.FLAG_LET contract.flags + Ixon.putBinderContract contract.binder + +def computeNodeHash (e : Expr) (childHashes : Array Address) : Address := + Address.blake3 <| childHashes.foldl (fun bytes h => bytes ++ h.hash) + (Ixon.runPut (putNodeHeader e)) + +/-- One hash-consed subterm. -/ +structure SubtermInfo where + /-- Node header bytes (`putNodeHeader`), children excluded. -/ + baseSize : Nat + /-- First representative seen. -/ + expr : Expr + children : Array Address + deriving Inhabited + +@[inline] def exprPtr (e : Expr) : USize := Ix.Sharing.Exact.exprPtr e + +structure AnalyzeState where + infoMap : Std.HashMap Address SubtermInfo := {} + ptrToHash : Std.HashMap USize Address := {} + /-- Leaves-first traversal order of the distinct subterms. -/ + topoOrder : Array Address := #[] + deriving Inhabited + +abbrev AnalyzeM := StateM AnalyzeState + +def recordAnalyzedNode (e : Expr) (childHashes : Array Address) : AnalyzeM Address := do + let hash := computeNodeHash e childHashes + modify fun st => { st with ptrToHash := st.ptrToHash.insert (exprPtr e) hash } + let st ← get + if !st.infoMap.contains hash then + set { st with + infoMap := st.infoMap.insert hash + { baseSize := (Ixon.runPut (putNodeHeader e)).size, expr := e, + children := childHashes } + topoOrder := st.topoOrder.push hash } + return hash + +partial def hashAndAnalyze (e : Expr) : AnalyzeM Address := do + if let some hash := (← get).ptrToHash.get? (exprPtr e) then return hash + let childHashes ← match e with + | .sort _ | .var _ | .ref _ _ | .recur _ _ | .str _ | .nat _ | .share _ => pure #[] + | .prj _ _ val => do pure #[← hashAndAnalyze val] + | .app f a => do pure #[← hashAndAnalyze f, ← hashAndAnalyze a] + | .lam _ ty body | .all _ _ ty body => do + pure #[← hashAndAnalyze ty, ← hashAndAnalyze body] + | .letE _ ty val body => do + pure #[← hashAndAnalyze ty, ← hashAndAnalyze val, ← hashAndAnalyze body] + recordAnalyzedNode e childHashes + +structure AnalyzeResult where + infoMap : Std.HashMap Address SubtermInfo + ptrToHash : Std.HashMap USize Address + topoOrder : Array Address + +/-- Hash-cons `exprs`, left to right. -/ +def analyzeBlock (exprs : Array Expr) : AnalyzeResult := + let st := exprs.foldl (init := ({} : AnalyzeState)) fun st e => ((hashAndAnalyze e).run st).2 + { infoMap := st.infoMap, ptrToHash := st.ptrToHash, topoOrder := st.topoOrder } + +/-- Replace every occurrence of a stored subterm by its `Share`. -/ +partial def rewriteWithSharing (e : Expr) (hashToIdx : Std.HashMap Address Nat) + (ptrToHash : Std.HashMap USize Address) : Expr := + match (ptrToHash.get? (exprPtr e)).bind (hashToIdx.get? ·) with + | some idx => .share idx.toUInt64 + | none => + let go x := rewriteWithSharing x hashToIdx ptrToHash + match e with + | .prj t f v => .prj t f (go v) + | .app f a => .app (go f) (go a) + | .lam c t b => .lam c (go t) (go b) + | .all c r t b => .all c r (go t) (go b) + | .letE c t v b => .letE c (go t) (go v) (go b) + | _ => e + +structure SharingBuildState where + sharingVec : Array Expr := #[] + hashToIdx : Std.HashMap Address Nat := {} + +/-- Emit the entries for `hashes` in order, each rewritten against the entries +before it. -/ +def buildSharingEntries (hashes : Array Address) (infoMap : Std.HashMap Address SubtermInfo) + (ptrToHash : Std.HashMap USize Address) : SharingBuildState := + hashes.foldl (init := {}) fun st hash => + match infoMap.get? hash with + | some info => + { sharingVec := st.sharingVec.push (rewriteWithSharing info.expr st.hashToIdx ptrToHash) + hashToIdx := st.hashToIdx.insert hash st.sharingVec.size } + | none => st + +def rewriteExprs (exprs : Array Expr) (hashToIdx : Std.HashMap Address Nat) + (ptrToHash : Std.HashMap USize Address) : Array Expr := + exprs.map fun e => rewriteWithSharing e hashToIdx ptrToHash + +/-! ## Stored-table expansion -/ + +/-- Replace every `Share i` with `i < limit` by `tbl[i]` (itself already +expanded), reusing that object so repeated indices share memory. -/ +partial def expandExpr (tbl : Array Expr) (limit : Nat) : Expr → Except String Expr + | .share i => + if i.toNat < limit then .ok tbl[i.toNat]! + else .error s!"Share {i} is not below {limit}" + | .prj t f v => return .prj t f (← expandExpr tbl limit v) + | .app f a => return .app (← expandExpr tbl limit f) (← expandExpr tbl limit a) + | .lam c t b => return .lam c (← expandExpr tbl limit t) (← expandExpr tbl limit b) + | .all c r t b => + return .all c r (← expandExpr tbl limit t) (← expandExpr tbl limit b) + | .letE c t v b => + return .letE c (← expandExpr tbl limit t) (← expandExpr tbl limit v) + (← expandExpr tbl limit b) + | e => .ok e + +/-- Expand a stored table. Entry `i` may only reference entries `j < i` +(the backward-reference class of §3.1); anything else is an error. -/ +def expandTable (sharing : Array Expr) : Except String (Array Expr) := do + let mut out : Array Expr := Array.mkEmpty sharing.size + for i in [0:sharing.size] do + let e ← (expandExpr out i sharing[i]!).mapError (s!"table entry {i}: " ++ ·) + out := out.push e + return out + +/-- First differing byte offset, or `none` when the arrays are equal. -/ +def firstDiff (a b : ByteArray) : Option Nat := Id.run do + let n := min a.size b.size + for i in [0:n] do + if a[i]! != b[i]! then return some i + if a.size == b.size then none else some n + +/-- Put `roots` back into `info` in `Ix.Sharing.Exact.constantInfoRoots` order +(`Ix.Sharing.Exact.withRoots`, which checks the root count). -/ +def replaceRoots (info : ConstantInfo) (roots : Array Expr) : Except String ConstantInfo := + (Ix.Sharing.Exact.withRoots info roots).mapError toString + +/-! ## Compositional unshared sizes on the hash-consed DAG -/ + +/-- Telescope family of a node: 0 other, 1 App, 2 Lam, 3 All. -/ +structure NodeSz where + /-- Standalone unshared `putExpr` length. -/ + sz : Nat + fam : UInt8 := 0 + /-- Number of nodes in the maximal same-family telescope headed here. -/ + tele : Nat := 0 + /-- `sz` minus this telescope's TagN (`f = 4`) header. -/ + payload : Nat := 0 + deriving Inhabited + +/-- Width of a TagN integer with a 4-bit flag (an expression header). -/ +def tagN4Size (n : Nat) : Nat := Ixon.tagNByteWidth 4 n +/-- Width of a flagless TagN integer (counts and indices). -/ +def tagN0Size (n : Nat) : Nat := Ixon.tagNByteWidth 0 n + +structure DagStats where + n : Nat := 0 + maxApp : Nat := 0 + maxLam : Nat := 0 + maxAll : Nat := 0 + rootSizes : Array Nat := #[] + deriving Inhabited + +/-- Hash-cons the roots and compute `N`, telescope maxima and root unshared +sizes. Mirrors `putExpr`: an App telescope writes `TagN4(#args)`, its head, +then its arguments; Lam/All telescopes write `TagN4(#binders)`, then one +contract byte and the type per binder, then the body. Prj/Let/leaves are the +node header (`SubtermInfo.baseSize`, which is `putNodeHeader`, i.e. the full +`putExpr` for leaves) plus the children. -/ +def dagStats (res : AnalyzeResult) (roots : Array Expr) : + DagStats × Std.HashMap Address NodeSz := Id.run do + let mut sizes : Std.HashMap Address NodeSz := Std.HashMap.emptyWithCapacity res.infoMap.size + let mut st : DagStats := { n := res.infoMap.size } + for h in res.topoOrder do + let some info := res.infoMap.get? h | continue + let child (i : Nat) : NodeSz := sizes.getD info.children[i]! default + let node : NodeSz := match info.expr with + | .app .. => + let f := child 0 + let a := child 1 + let tele := if f.fam == 1 then f.tele + 1 else 1 + let payload := (if f.fam == 1 then f.payload else f.sz) + a.sz + { sz := tagN4Size tele + payload, fam := 1, tele, payload } + | .lam .. => + let t := child 0 + let b := child 1 + let tele := if b.fam == 2 then b.tele + 1 else 1 + let payload := 1 + t.sz + (if b.fam == 2 then b.payload else b.sz) + { sz := tagN4Size tele + payload, fam := 2, tele, payload } + | .all .. => + let t := child 0 + let b := child 1 + let tele := if b.fam == 3 then b.tele + 1 else 1 + let payload := 1 + t.sz + (if b.fam == 3 then b.payload else b.sz) + { sz := tagN4Size tele + payload, fam := 3, tele, payload } + | _ => + { sz := info.children.foldl (init := info.baseSize) fun acc c => + acc + (sizes.getD c default).sz } + if node.fam == 1 then st := { st with maxApp := max st.maxApp node.tele } + else if node.fam == 2 then st := { st with maxLam := max st.maxLam node.tele } + else if node.fam == 3 then st := { st with maxAll := max st.maxAll node.tele } + sizes := sizes.insert h node + let rootSizes := roots.map fun r => + match res.ptrToHash.get? (exprPtr r) with + | some h => (sizes.getD h default).sz + | none => 0 + return ({ st with rootSizes }, sizes) + +/-- Share references in an unexpanded expression, bucketed by index: `< lo`, +`lo..hi-1`, `≥ hi`. -/ +partial def countShareRefsBy (lo hi : UInt64) (e : Expr) (acc : Nat × Nat × Nat) : + Nat × Nat × Nat := + match e with + | .share i => + if i < lo then (acc.1 + 1, acc.2) + else if i < hi then (acc.1, acc.2.1 + 1, acc.2.2) + else (acc.1, acc.2.1, acc.2.2 + 1) + | .prj _ _ v => countShareRefsBy lo hi v acc + | .app f a => countShareRefsBy lo hi a (countShareRefsBy lo hi f acc) + | .lam _ t b | .all _ _ t b => countShareRefsBy lo hi b (countShareRefsBy lo hi t acc) + | .letE _ t v b => + countShareRefsBy lo hi b (countShareRefsBy lo hi v (countShareRefsBy lo hi t acc)) + | _ => acc + +def countShareRefs (e : Expr) (acc : Nat × Nat × Nat) : Nat × Nat × Nat := + countShareRefsBy 8 1032 e acc + +/-! ## Maximal structural sharing (MSS) + +The in-degree rule measured against the canonical encoding: + +1. `deg(t)`: incoming edges of `t` in the compact hash-consed DAG, counted with + multiplicity (`App(x,x)` contributes 2 to `x`), plus the number of roots + equal to `t`. This is the compact indegree, not the number of occurrences + in the expanded roots. +2. Store exactly the terms with `deg ≥ 2` and standalone unshared size > 1; + every occurrence of a stored term (in roots and in other entries) is a Share. +3. Order: priority topological order. Among stored terms whose stored body + dependencies (stored terms reachable through unstored nodes) are already + emitted, emit the one with the largest `deg`, ties by smaller blake3 hash + bytes. By induction the emitted set stays closed under stored proper + subterms, so this is the same order as requiring all stored proper + subterms first. +4. Materialize with `buildSharingEntries` and `rewriteExprs` (above), then + serialize with `serConstant`. -/ + +structure MssResult where + /-- Rewritten table in emission order. -/ + table : Array Expr := #[] + /-- Rewritten roots. -/ + roots : Array Expr := #[] + /-- Stored terms that never occur as a root and whose every DAG occurrence + is a same-family telescope continuation: the function child of an App when + the term is an App, or the body of a Lam (All) when the term is a Lam (All). -/ + cont : Nat := 0 + /-- Continuation-only entries whose MSS entry body, minus its TagN header, is + at most 2 bytes. -/ + contP2 : Nat := 0 + /-- Continuation-only entries whose unshared payload (`NodeSz.payload`) is at + most 2 bytes. -/ + contP2u : Nat := 0 + /-- Share nodes in the MSS table and roots by TagN index width (`< 8`: 1 byte, + `8..1031`: 2 bytes, `≥ 1032`), counted on the materialized encoding. -/ + refs : Nat × Nat × Nat := (0, 0, 0) + /-- `Σ deg(t)` over the stored terms (expected to equal the Share count). -/ + degSum : Nat := 0 + deriving Inhabited + +/-- Telescope count `putExpr` writes for an expression. -/ +def teleCount : Expr → Nat + | e@(.app ..) => e.collectAppArgs.1.length + | e@(.lam ..) => e.collectLamBinders.1.length + | e@(.all ..) => e.collectAllBinders.1.length + | _ => 0 + +def mssBuild (res : AnalyzeResult) (sizes : Std.HashMap Address NodeSz) + (roots : Array Expr) : Except String MssResult := do + -- 1. Compact-DAG indegree with multiplicity plus root occurrences, and whether + -- every occurrence is a same-family telescope continuation. + let mut deg : Std.HashMap Address Nat := Std.HashMap.emptyWithCapacity res.infoMap.size + let mut nonCont : Std.HashSet Address := {} + for r in roots do + let some h := res.ptrToHash.get? (exprPtr r) | throw "root not analyzed" + deg := deg.insert h (deg.getD h 0 + 1) + nonCont := nonCont.insert h + for (_, info) in res.infoMap do + let pf : UInt8 := match info.expr with + | .app .. => 1 | .lam .. => 2 | .all .. => 3 | _ => 0 + for i in [0:info.children.size] do + let c := info.children[i]! + deg := deg.insert c (deg.getD c 0 + 1) + let cf := (sizes.getD c default).fam + unless pf != 0 && cf == pf && i == (if pf == 1 then 0 else 1) do + nonCont := nonCont.insert c + -- 2. Stored set, indexed in traversal order. + let mut stored : Array Address := #[] + let mut idxOf : Std.HashMap Address Nat := {} + for h in res.topoOrder do + if deg.getD h 0 ≥ 2 && (sizes.getD h default).sz > 1 then + idxOf := idxOf.insert h stored.size + stored := stored.push h + let n := stored.size + -- 3. Body dependencies (stored terms reachable through unstored nodes), + -- with multiplicity on both sides. + let mut dependents : Array (Array Nat) := Array.replicate n #[] + let mut pending : Array Nat := Array.replicate n 0 + for k in [0:n] do + let some info := res.infoMap.get? stored[k]! | throw "stored term not analyzed" + let mut stack : Array Address := info.children + while !stack.isEmpty do + let c := stack.back! + stack := stack.pop + match idxOf.get? c with + | some j => + dependents := dependents.modify j (·.push k) + pending := pending.modify k (· + 1) + | none => + if let some ci := res.infoMap.get? c then stack := stack ++ ci.children + -- 4. Priority topological order: largest `deg`, then smaller hash bytes. + let byRank := (Array.range n).qsort fun a b => + let da := deg.getD stored[a]! 0 + let db := deg.getD stored[b]! 0 + da > db || (da == db && Address.cmpBytes stored[a]! stored[b]! == .lt) + let mut rank : Array Nat := Array.replicate n 0 + for r in [0:n] do + rank := rank.set! byRank[r]! r + let mut ready : Std.TreeSet Nat := {} + for k in [0:n] do + if pending[k]! == 0 then ready := ready.insert rank[k]! + let mut order : Array Address := Array.mkEmpty n + while true do + match ready.min? with + | none => break + | some r => + ready := ready.erase r + let k := byRank[r]! + order := order.push stored[k]! + for j in dependents[k]! do + pending := pending.modify j (· - 1) + if pending[j]! == 0 then ready := ready.insert rank[j]! + if order.size != n then throw s!"MSS order incomplete ({order.size}/{n})" + -- 5. Materialize with the harness-local rewrite helpers. + let st := buildSharingEntries order res.infoMap res.ptrToHash + let newRoots := rewriteExprs roots st.hashToIdx res.ptrToHash + -- 6. Continuation-only entries. + let refs := newRoots.foldl (fun acc e => countShareRefs e acc) + (st.sharingVec.foldl (fun acc e => countShareRefs e acc) (0, 0, 0)) + let degSum := stored.foldl (fun a h => a + deg.getD h 0) 0 + let mut out : MssResult := + { table := st.sharingVec, roots := newRoots, refs, degSum } + for h in stored do + unless nonCont.contains h do + let entry := st.sharingVec[st.hashToIdx.getD h 0]! + let payload := (Ixon.serExpr entry).size - tagN4Size (teleCount entry) + out := { out with + cont := out.cont + 1 + contP2 := out.contP2 + (if payload ≤ 2 then 1 else 0) + contP2u := out.contP2u + (if (sizes.getD h default).payload ≤ 2 then 1 else 0) } + return out + +/-- Exact structural equality of two expression DAGs, memoized on pointer +pairs (both DAGs stay alive for the whole comparison). -/ +partial def eqDag (a b : Expr) : StateM (Std.HashSet (USize × USize)) Bool := do + let pa := exprPtr a + let pb := exprPtr b + if pa == pb then return true + if (← get).contains (pa, pb) then return true + let r ← match a, b with + | .prj t1 f1 v1, .prj t2 f2 v2 => do + if t1 != t2 || f1 != f2 then return false + eqDag v1 v2 + | .app f1 x1, .app f2 x2 => do + if !(← eqDag f1 f2) then return false + eqDag x1 x2 + | .lam c1 t1 b1, .lam c2 t2 b2 => do + if c1 != c2 then return false + if !(← eqDag t1 t2) then return false + eqDag b1 b2 + | .all c1 r1 t1 b1, .all c2 r2 t2 b2 => do + if c1 != c2 || r1 != r2 then return false + if !(← eqDag t1 t2) then return false + eqDag b1 b2 + | .letE c1 t1 v1 b1, .letE c2 t2 v2 b2 => do + if c1 != c2 then return false + if !(← eqDag t1 t2) then return false + if !(← eqDag v1 v2) then return false + eqDag b1 b2 + | .share _, _ | _, .share _ => pure false + | x, y => pure (x == y) + if r then modify (·.insert (pa, pb)) + return r + +/-- Decode MSS bytes, check they re-encode identically, expand the table and +compare the expanded roots with the original roots exactly. -/ +def mssCheck (bytes : ByteArray) (roots : Array Expr) : Except String Unit := do + let c ← Ixon.deConstant bytes + if (firstDiff (Ixon.serConstant c) bytes).isSome then throw "re-encode differs" + let tbl ← expandTable c.sharing + let rs ← (Ix.Sharing.Exact.constantInfoRoots c.info).mapM (expandExpr tbl tbl.size) + if rs.size != roots.size then throw s!"root count {rs.size} vs {roots.size}" + let cmp : StateM (Std.HashSet (USize × USize)) Bool := do + for (x, y) in rs.zip roots do + if !(← eqDag x y) then return false + return true + let ok : Bool := Id.run (cmp.run' {}) + unless ok do throw "expanded MSS roots differ from the original roots" + +/-! ## Per-constant row -/ + +def kindOf : ConstantInfo → String + | .defn _ => "defn" | .recr _ => "recr" | .axio _ => "axio" | .quot _ => "quot" + | .cPrj _ => "cPrj" | .rPrj _ => "rPrj" | .iPrj _ => "iPrj" | .dPrj _ => "dPrj" + | .muts _ => "muts" + +/-- Member composition of a mutual block, e.g. `1i+3c+1r+0d`. -/ +def mutsDetail : ConstantInfo → String + | .muts ms => Id.run do + let mut i := 0; let mut c := 0; let mut r := 0; let mut d := 0 + for m in ms do + match m with + | .indc ind => i := i + 1; c := c + ind.ctors.size + | .recr _ => r := r + 1 + | .defn _ => d := d + 1 + return s!"{i}i+{c}c+{r}r+{d}d" + | _ => "" + +structure Row where + addr : Address + name : String + kind : String + detail : String + roots : Nat + n : Nat + /-- Stored table entries and bytes. -/ + table : Nat + raw : Nat + unshared : Nat + /-- Canonical (production route) complete-Constant bytes and table entries. -/ + canonical : Nat + canonicalTable : Nat + /-- Canonical bytes equal the stored bytes. -/ + rebuildOk : Bool + firstDiff : Option Nat + roundtripOk : Bool + maxApp : Nat + maxLam : Nat + maxAll : Nat + /-- `none`: unshared roots larger than `--validate-max`, not serialized. -/ + validated : Option Bool + serUnsharedSize : Nat + /-- MSS complete-Constant bytes, table size and continuation counts. -/ + mss : Nat := 0 + mssTable : Nat := 0 + /-- `some e`: MSS construction or its decode/expand check failed. -/ + mssErr : Option String := none + cont : Nat := 0 + contP2 : Nat := 0 + contP2u : Nat := 0 + /-- Share nodes in the MSS encoding by TagN index width, and `Σ deg`. -/ + mssRefs : Nat × Nat × Nat := (0, 0, 0) + mssDegSum : Nat := 0 + ns : Nat := 0 + deriving Inhabited + +/-- Everything measured for one constant. Pure; errors are skips. -/ +def measure (addr : Address) (name : String) (raw : ByteArray) (c : Constant) + (validateMax : Nat) : Except String Row := do + let roundtrip := Ixon.serConstant c + let tbl ← expandTable c.sharing + let stored := Ix.Sharing.Exact.constantInfoRoots c.info + let roots ← stored.mapM (expandExpr tbl tbl.size) |>.mapError (s!"root: " ++ ·) + let expanded ← replaceRoots c.info roots + -- 1. Canonical rebuild from the expanded roots (the production route). + let rebuilt ← (Ix.CompileM.buildConstantWithSharing Ix.CompileM.compilerSharingLimits + expanded c.refs c.univs).mapError (s!"canonical: " ++ toString ·) + let rebuiltBytes := Ixon.serConstant rebuilt + let diff := firstDiff rebuiltBytes raw + -- 2. DAG statistics. + let res := analyzeBlock roots + let (ds, sizes) := dagStats res roots + -- 3. Unshared complete-Constant size: bytes outside expressions are fixed. + let storedExprBytes := + c.sharing.foldl (fun acc e => acc + (Ixon.serExpr e).size) 0 + + stored.foldl (fun acc e => acc + (Ixon.serExpr e).size) 0 + let overhead := tagN0Size c.sharing.size + storedExprBytes + if overhead > raw.size then + throw s!"stored expression bytes {overhead} exceed constant bytes {raw.size}" + let fixed := raw.size - overhead + let rootTotal := ds.rootSizes.foldl (· + ·) 0 + let unshared := fixed + tagN0Size 0 + rootTotal + let (validated, serUnsharedSize) := + if rootTotal ≤ validateMax then + let u : Constant := + { info := expanded, sharing := #[], refs := c.refs, univs := c.univs } + let s := (Ixon.serConstant u).size + (some (s == unshared), s) + else (none, 0) + -- 4. Maximal structural sharing, serialized and checked. + let (mss, mssTable, mssErr, mssCounts, mssRefs, mssDegSum) := + match mssBuild res sizes roots with + | .error e => (0, 0, some s!"build: {e}", (0, 0, 0), (0, 0, 0), 0) + | .ok m => + match replaceRoots c.info m.roots with + | .error e => (0, 0, some s!"roots: {e}", (0, 0, 0), (0, 0, 0), 0) + | .ok info => + let mc : Constant := + { info, sharing := m.table, refs := c.refs, univs := c.univs } + let b := Ixon.serConstant mc + let err := match mssCheck b roots with + | .ok () => none + | .error e => some s!"check: {e}" + (b.size, m.table.size, err, (m.cont, m.contP2, m.contP2u), m.refs, m.degSum) + return { + mss, mssTable, mssErr, mssRefs, mssDegSum + cont := mssCounts.1, contP2 := mssCounts.2.1, contP2u := mssCounts.2.2 + addr, name, kind := kindOf c.info, detail := mutsDetail c.info + roots := roots.size, n := ds.n, table := c.sharing.size + raw := raw.size, unshared, canonical := rebuiltBytes.size + canonicalTable := rebuilt.sharing.size, rebuildOk := diff.isNone + firstDiff := diff, roundtripOk := (firstDiff roundtrip raw).isNone + maxApp := ds.maxApp, maxLam := ds.maxLam, maxAll := ds.maxAll + validated, serUnsharedSize } + +/-! ## Plan §2 witnesses -/ + +structure Witness where + label : String + unshared : Nat + canonical : Nat + mss : Nat + mssHex : String + canonicalHex : String + check : Option String + expectedMss : String + +/-- `P = Sort 0`, `T0 = P`, `T(k+1) = All(P, Tk)`, default contracts. -/ +def witnessT (n : Nat) : Expr := + let p : Expr := .sort 0 + (List.range n).foldl (fun acc _ => Expr.all .many .shared p acc) p + +/-- `Axio(false, 0, root)` with empty refs and the given univs. -/ +def witnessAxiom (root : Expr) (univs : Array Ixon.Univ) : Constant := + { info := .axio { isUnsafe := false, lvls := 0, typ := root }, + sharing := #[], refs := #[], univs } + +/-- The MSS encoding of an unshared constant: its bytes and its roots. -/ +def mssBytes (c : Constant) : Except String (ByteArray × Array Expr) := do + let roots := Ix.Sharing.Exact.constantInfoRoots c.info + let res := analyzeBlock roots + let (_, sizes) := dagStats res roots + let m ← mssBuild res sizes roots + let info ← replaceRoots c.info m.roots + return (Ixon.serConstant { c with info, sharing := m.table }, roots) + +def runWitness (label expected : String) (c : Constant) : Except String Witness := do + let (mb, roots) ← mssBytes c + let canon ← (Ix.CompileM.buildConstantWithSharing Ix.CompileM.compilerSharingLimits + c.info c.refs c.univs).mapError (s!"canonical: " ++ toString ·) + let cb := Ixon.serConstant canon + let check := match mssCheck mb roots with | .ok () => none | .error e => some e + return { label, unshared := (Ixon.serConstant c).size, canonical := cb.size, mss := mb.size, + mssHex := hexOfBytes mb, canonicalHex := hexOfBytes cb, check, + expectedMss := expected } + +def witnesses : Array (Except String Witness) := + let t2 := witnessT 2 + let t16 := witnessT 16 + let p : Expr := .sort 0 + let a : Expr := .all .many .shared p p + let b : Expr := .all .many .shared p (.sort 1) + #[runWitness "`T2 → T2`" "17 (plan: exact minimum `d200009117b0b001921700170000000100`)" + (witnessAxiom (.all .many .shared t2 t2) #[.zero]), + runWitness "`T16 → T16`" "46 (plan: feasible improvement)" + (witnessAxiom (.all .many .shared t16 t16) #[.zero]), + runWitness "`A → A → B → B`, `A = Prop → Prop`, `B = Prop → Type`" "25 (plan: minimum, two tied orders)" + (witnessAxiom (.all .many .shared a (.all .many .shared a (.all .many .shared b b))) + #[.zero, .succ .zero])] + +/-- Negative controls for `mssCheck`: the `T2 → T2` MSS bytes must be rejected +against roots that differ in one leaf, and against the `T16 → T16` roots. -/ +def negativeControls : Array (String × Bool) := + let p : Expr := .sort 0 + let t2 := witnessT 2 + let t2' : Expr := .all .many .shared p (.all .many .shared p (.sort 1)) + match mssBytes (witnessAxiom (.all .many .shared t2 t2) #[.zero]) with + | .error e => #[(s!"MSS build failed: {e}", false)] + | .ok (mb, roots) => + let rejects (rs : Array Expr) : Bool := + match mssCheck mb rs with | .ok () => false | .error _ => true + #[("`T2 → T2` MSS bytes vs roots `T2 → T2'` (one leaf `Sort 0` replaced by `Sort 1`)", + rejects #[.all .many .shared t2 t2']), + ("`T2 → T2` MSS bytes vs roots `T16 → T16`", + rejects #[.all .many .shared (witnessT 16) (witnessT 16)]), + ("`T2 → T2` MSS bytes vs its own roots (must be accepted)", !rejects roots)] + +/-! ## Statistics -/ + +/-- Nearest-rank percentile of a sorted array (`p` in percent). -/ +def pct (s : Array Nat) (p : Nat) : Nat := + if s.isEmpty then 0 else s[(max 1 ((p * s.size + 99) / 100)) - 1]! + +def fmtMean (sum count : Nat) : String := + if count == 0 then "0" else + let q := (sum * 100 + count / 2) / count + let frac := q % 100 + s!"{q / 100}.{if frac < 10 then "0" else ""}{frac}" + +def fmtPct (part whole : Nat) : String := + if whole == 0 then "0" else + let q := (part * 1000 + whole / 2) / whole + s!"{q / 10}.{q % 10}%" + +def distRow (label : String) (xs : Array Nat) : String := + let s := xs.qsort (· < ·) + let sum := s.foldl (· + ·) 0 + s!"| {label} | {s[0]?.getD 0} | {pct s 50} | {pct s 90} | {pct s 99} | {s.back?.getD 0} | {fmtMean sum s.size} |" + +def distTable (rows : Array Row) : String := + let hdr := "| Metric | min | median | p90 | p99 | max | mean |\n|---|---:|---:|---:|---:|---:|---:|" + let lines := #[ + distRow "`N` (distinct subterms)" (rows.map (·.n)), + distRow "stored table size" (rows.map (·.table)), + distRow "canonical table size" (rows.map (·.canonicalTable)), + distRow "`rawBytes.size`" (rows.map (·.raw)), + distRow "canonical Constant bytes" (rows.map (·.canonical)), + distRow "unshared Constant bytes" (rows.map (·.unshared)), + distRow "max telescope length" (rows.map fun r => max r.maxApp (max r.maxLam r.maxAll)), + distRow "roots" (rows.map (·.roots))] + hdr ++ "\n" ++ "\n".intercalate lines.toList + +def csvEscape (s : String) : String := "\"" ++ s.replace "\"" "\"\"" ++ "\"" + +def csvHeader : String := + "addr,name,kind,members,roots,N,table,raw_bytes," ++ + "unshared_bytes,canonical_bytes,canonical_table,rebuild_ok,roundtrip_ok,unshared_validated," ++ + "max_app,max_lam,max_all,us," ++ + "mss_bytes,mss_table,mss_ok,mss_cont,mss_cont_p2,mss_cont_p2u," ++ + "mss_refs_lt8,mss_refs_8_1031,mss_refs_ge1032,mss_deg_sum" + +def csvLine (r : Row) : String := + let v := match r.validated with | some true => "1" | some false => "0" | none => "" + s!"{(toString r.addr).take 16},{csvEscape r.name},{r.kind},{r.detail},{r.roots},{r.n}," ++ + s!"{r.table},{r.raw},{r.unshared}," ++ + s!"{r.canonical},{r.canonicalTable}," ++ + s!"{if r.rebuildOk then 1 else 0},{if r.roundtripOk then 1 else 0},{v}," ++ + s!"{r.maxApp},{r.maxLam},{r.maxAll},{r.ns / 1000}," ++ + s!"{r.mss},{r.mssTable},{if r.mssErr.isNone then 1 else 0},{r.cont},{r.contP2},{r.contP2u}," ++ + s!"{r.mssRefs.1},{r.mssRefs.2.1},{r.mssRefs.2.2},{r.mssDegSum}" + +def kindOrder : Array String := + #["defn", "recr", "axio", "quot", "muts", "iPrj", "cPrj", "rPrj", "dPrj"] + +/-- Nearest-rank percentile of a sorted `Int` array. -/ +def pctInt (s : Array Int) (p : Nat) : Int := + if s.isEmpty then 0 else s[(max 1 ((p * s.size + 99) / 100)) - 1]! + +def fmtSignedPct (num : Int) (den : Nat) : String := + if den == 0 then "0" else + let q := (num.natAbs * 1000 + den / 2) / den + s!"{if num < 0 then "−" else "+"}{q / 10}.{q % 10}%" + +def fmtSignedPct2 (num : Int) (den : Nat) : String := + if den == 0 then "0" else + let q := (num.natAbs * 10000 + den / 2) / den + let frac := q % 100 + s!"{if num < 0 then "−" else "+"}{q / 100}.{if frac < 10 then "0" else ""}{frac}%" + +/-- Share nodes of the MSS encoding over all index widths. -/ +def mssRefTotal (r : Row) : Nat := r.mssRefs.1 + r.mssRefs.2.1 + r.mssRefs.2.2 + +/-- The MSS section of the generated report. -/ +def mssReport (rows : Array Row) (ws : Array (Except String Witness)) : String := Id.run do + let wr := rows.filter (·.roots > 0) + let mut md := "## Maximal structural sharing (MSS)\n\n" + md := md ++ "Rule: store exactly the subterms with compact-DAG indegree `deg ≥ 2` (edges with multiplicity plus root occurrences) and unshared size > 1; every occurrence of a stored term is a Share; order by priority topological order (largest `deg`, then smaller blake3 hash bytes). Built with the harness-local `buildSharingEntries`/`rewriteExprs`, placed with `Ix.Sharing.Exact.withRoots`, serialized with `serConstant`.\n\n" + md := md ++ "### Witnesses from the plan (§2)\n\n| fixture | unshared B | canonical B | MSS B | expected MSS | MSS decode/expand check | MSS bytes | canonical bytes |\n|---|---:|---:|---:|---|---|---|---|\n" + for w in ws do + match w with + | .ok w => + md := md ++ s!"| {w.label} | {w.unshared} | {w.canonical} | {w.mss} | {w.expectedMss} | {w.check.getD "ok"} | `{w.mssHex}` | `{w.canonicalHex}` |\n" + | .error e => md := md ++ s!"| (witness failed) | | | | | {e} | | |\n" + md := md ++ "\nNegative controls for the MSS decode/expand/equality check:\n\n" + for (label, ok) in negativeControls do + md := md ++ s!"- {label}: {if ok then "behaves as expected" else "**UNEXPECTED**"}\n" + let errs := rows.filter (·.mssErr.isSome) + md := md ++ s!"\n### Corpus verification\n\n- MSS built for {rows.size} constants; decode, re-encode (byte-identical), table expansion and exact pointer-memoized structural equality of the expanded roots with the original expanded roots: {rows.size - errs.size} ok, **{errs.size}** failed.\n" + for r in errs.extract 0 10 do + md := md ++ s!" - `{r.name}`: {r.mssErr.getD ""}\n" + let sRaw : Nat := wr.foldl (· + ·.canonical) 0 + let sMss : Nat := wr.foldl (· + ·.mss) 0 + let sUn : Nat := wr.foldl (· + ·.unshared) 0 + let dTot : Int := (sMss : Int) - sRaw + md := md ++ s!"\n### Totals over the {wr.size} constants with at least one root\n\n| encoding | total bytes | vs canonical |\n|---|---:|---:|\n" + md := md ++ s!"| canonical (production route) | {sRaw} | |\n| MSS | {sMss} | {dTot} ({fmtSignedPct dTot sRaw}) |\n| unshared | {sUn} | {(sUn : Int) - sRaw} |\n\n" + let better := wr.filter fun r => r.mss < r.canonical + let equal := wr.filter fun r => r.mss == r.canonical + let worse := wr.filter fun r => r.mss > r.canonical + let savings := (better.map fun r => r.canonical - r.mss).qsort (· < ·) + let losses := (worse.map fun r => r.mss - r.canonical).qsort (· < ·) + let sSav := savings.foldl (· + ·) 0 + let sLoss := losses.foldl (· + ·) 0 + md := md ++ "### MSS − canonical per constant\n\n| outcome | constants | share | bytes |\n|---|---:|---:|---:|\n" + md := md ++ s!"| MSS smaller | {better.size} | {fmtPct better.size wr.size} | −{sSav} |\n" + md := md ++ s!"| equal | {equal.size} | {fmtPct equal.size wr.size} | 0 |\n" + md := md ++ s!"| MSS larger | {worse.size} | {fmtPct worse.size wr.size} | +{sLoss} |\n\n" + md := md ++ s!"- Losses (MSS − canonical) over the {worse.size} larger constants: p50 {pct losses 50}, p90 {pct losses 90}, p99 {pct losses 99}, max {losses.back?.getD 0}, mean {fmtMean sLoss losses.size}.\n" + md := md ++ s!"- Savings (canonical − MSS) over the {better.size} smaller constants: p50 {pct savings 50}, p90 {pct savings 90}, p99 {pct savings 99}, max {savings.back?.getD 0}, mean {fmtMean sSav savings.size}.\n" + let deltas : Array Int := (wr.map fun r => (r.mss : Int) - r.canonical).qsort (· < ·) + md := md ++ s!"- Signed Δ = MSS − canonical over all {wr.size} rooted constants: min {deltas[0]?.getD 0}, p1 {pctInt deltas 1}, p10 {pctInt deltas 10}, p50 {pctInt deltas 50}, p90 {pctInt deltas 90}, p99 {pctInt deltas 99}, max {deltas.back?.getD 0}.\n" + let overUn := wr.filter fun r => r.mss > r.unshared + let excess := overUn.foldl (fun acc r => acc + (r.mss - r.unshared)) 0 + let maxEx := overUn.foldl (fun acc r => max acc (r.mss - r.unshared)) 0 + md := md ++ s!"- MSS larger than unshared: {overUn.size} constants, total excess {excess} bytes, max {maxEx}. (Canonical larger than unshared: {(wr.filter fun r => r.canonical > r.unshared).size}.)\n\n" + md := md ++ "### Table sizes (rooted constants)\n\n| Metric | min | median | p90 | p99 | max | mean |\n|---|---:|---:|---:|---:|---:|---:|\n" + md := md ++ distRow "MSS table size" (wr.map (·.mssTable)) ++ "\n" + md := md ++ distRow "canonical table size" (wr.map (·.canonicalTable)) ++ "\n" + md := md ++ distRow "MSS continuation-only entries" (wr.map (·.cont)) ++ "\n" + md := md ++ distRow "… with MSS entry payload ≤ 2" (wr.map (·.contP2)) ++ "\n" + md := md ++ distRow "… with unshared payload ≤ 2" (wr.map (·.contP2u)) ++ "\n\n" + md := md ++ s!"- Total MSS entries {wr.foldl (· + ·.mssTable) 0}; canonical entries {wr.foldl (· + ·.canonicalTable) 0}.\n" + let withCont := wr.filter (·.contP2 > 0) + md := md ++ s!"- Continuation-only entries (never a root; every occurrence is the function child of an App for an App term, or the body of a Lam/All for a Lam/All term): {wr.foldl (· + ·.cont) 0} in total; with MSS entry payload ≤ 2: {wr.foldl (· + ·.contP2) 0}; with unshared payload ≤ 2: {wr.foldl (· + ·.contP2u) 0}.\n" + md := md ++ s!"- Constants with at least one continuation-only entry of MSS payload ≤ 2: {withCont.size}; of these, MSS larger than canonical: {(withCont.filter fun r => r.mss > r.canonical).size}, equal: {(withCont.filter fun r => r.mss == r.canonical).size}, smaller: {(withCont.filter fun r => r.mss < r.canonical).size}.\n" + md := md ++ s!"- Of the {worse.size} constants where MSS is larger, {(worse.filter (·.contP2 > 0)).size} have such an entry; of the {better.size} where MSS is smaller, {(better.filter (·.contP2 > 0)).size}.\n\n" + md := md ++ "### MSS by ConstantInfo kind (rooted constants)\n\n| kind | constants | canonical B | MSS B | unshared B | MSS/canonical | MSS smaller | equal | MSS larger |\n|---|---:|---:|---:|---:|---:|---:|---:|---:|\n" + for k in kindOrder do + let ks := wr.filter (·.kind == k) + unless ks.isEmpty do + let r := ks.foldl (· + ·.canonical) 0 + let m := ks.foldl (· + ·.mss) 0 + let u := ks.foldl (· + ·.unshared) 0 + md := md ++ s!"| {k} | {ks.size} | {r} | {m} | {u} | {fmtPct m r} | {(ks.filter fun x => x.mss < x.canonical).size} | {(ks.filter fun x => x.mss == x.canonical).size} | {(ks.filter fun x => x.mss > x.canonical).size} |\n" + let hdr := "| # | constant | kind | canonical B | MSS B | Δ | unshared B | canonical table | MSS table | cont. p≤2 |\n|---:|---|---|---:|---:|---:|---:|---:|---:|---:|\n" + let line (j : Nat) (r : Row) : String := + s!"| {j + 1} | `{r.name}` | {r.kind} | {r.canonical} | {r.mss} | {(r.mss : Int) - r.canonical} | {r.unshared} | {r.canonicalTable} | {r.mssTable} | {r.contP2} |\n" + md := md ++ "\n### Ten largest MSS losses (MSS − canonical)\n\n" ++ hdr + let wl := (worse.qsort fun a b => + let da := a.mss - a.canonical; let db := b.mss - b.canonical + da > db || (da == db && a.name < b.name)).extract 0 10 + for h : j in [0:wl.size] do md := md ++ line j wl[j] + md := md ++ "\n### Ten largest MSS wins (canonical − MSS)\n\n" ++ hdr + let bw := (better.qsort fun a b => + let da := a.canonical - a.mss; let db := b.canonical - b.mss + da > db || (da == db && a.name < b.name)).extract 0 10 + for h : j in [0:bw.size] do md := md ++ line j bw[j] + return md + +/-! ## Driver -/ + +structure Opts where + corpus : String := "" + md : Option String := none + csv : Option String := none + limit : Option Nat := none + validateMax : Nat := 16777216 + progress : Nat := 5000 + +def parseArgs : List String → Opts → Except String Opts + | [], o => if o.corpus.isEmpty then .error "missing corpus path" else .ok o + | "--md" :: p :: rest, o => parseArgs rest { o with md := some p } + | "--csv" :: p :: rest, o => parseArgs rest { o with csv := some p } + | "--limit" :: n :: rest, o => parseArgs rest { o with limit := n.toNat? } + | "--validate-max" :: n :: rest, o => + parseArgs rest { o with validateMax := n.toNat?.getD o.validateMax } + | "--progress" :: n :: rest, o => + parseArgs rest { o with progress := n.toNat?.getD o.progress } + | p :: rest, o => + if p.startsWith "--" then .error s!"unknown flag {p}" + else parseArgs rest { o with corpus := p } + +def projBlock? : ConstantInfo → Option Address + | .iPrj p => some p.block | .cPrj p => some p.block + | .rPrj p => some p.block | .dPrj p => some p.block + | _ => none + +def main (args : List String) : IO UInt32 := do + let opts ← match parseArgs args {} with + | .ok o => pure o + | .error e => + IO.eprintln s!"sharing-study: {e}\nusage: sharing-study [--md p] [--csv p] [--limit n] [--validate-max bytes] [--progress n]" + return 2 + let ws := witnesses + for w in ws do + match w with + | .ok w => IO.println s!"[sharing-study] witness {w.label}: unshared {w.unshared} B, canonical {w.canonical} B, MSS {w.mss} B (expected {w.expectedMss}), check {w.check.getD "ok"}, MSS bytes {w.mssHex}" + | .error e => IO.println s!"[sharing-study] witness FAILED: {e}" + let t0 ← IO.monoMsNow + let bytes ← IO.FS.readBinFile opts.corpus + let env ← IO.ofExcept (Ixon.deEnvAnon bytes) + let tLoad ← IO.monoMsNow + IO.println s!"[sharing-study] loaded {opts.corpus}: {bytes.size} bytes, {env.consts.size} constants, {env.named.size} names in {tLoad - t0} ms" + let entries := env.consts.toArray.qsort fun a b => Address.cmpBytes a.1 b.1 == .lt + -- Names for anonymous mutual blocks: the least projection name pointing at them. + let mut blockNames : Std.HashMap Address String := {} + for (addr, lc) in entries do + match lc.peekTag with + | .ok .iPrj | .ok .cPrj | .ok .rPrj | .ok .dPrj => + if let .ok c := lc.get then + if let some blk := projBlock? c.info then + if let some nm := env.addrToName.get? addr then + let s := toString nm + let s := match blockNames.get? blk with + | some old => if s < old then s else old + | none => s + blockNames := blockNames.insert blk s + | _ => pure () + let nameOf (addr : Address) : String := + match env.addrToName.get? addr with + | some n => toString n + | none => match blockNames.get? addr with + | some s => s!"{s} [block]" + | none => "" + let todo := match opts.limit with + | some n => entries.extract 0 n + | none => entries + let mut rows : Array Row := Array.mkEmpty todo.size + let mut skipped : Array (String × String) := #[] + let mut mismatches := 0 + let mut i := 0 + for (addr, lc) in todo do + i := i + 1 + let name := nameOf addr + let raw := lc.rawBytes + let c ← match lc.get with + | .ok c => pure c + | .error e => + skipped := skipped.push (name, s!"decode: {e}") + continue + let s ← IO.monoNanosNow + match measure addr name raw c opts.validateMax with + | .error e => skipped := skipped.push (name, e) + | .ok row => + let e ← IO.monoNanosNow + let row := { row with ns := e - s } + unless row.rebuildOk do + mismatches := mismatches + 1 + if mismatches ≤ 10 then + IO.println s!"[sharing-study] MISMATCH {name} ({row.kind}): stored {row.raw} B / table {row.table}, canonical {row.canonical} B / table {row.canonicalTable}, first diff at {row.firstDiff}" + if let some e := row.mssErr then + IO.println s!"[sharing-study] MSS FAILURE {name} ({row.kind}): {e}" + if row.ns > 2000000000 then + IO.println s!"[sharing-study] slow: {name} ({row.kind}) {row.ns / 1000000} ms, N={row.n}" + rows := rows.push row + if opts.progress > 0 && i % opts.progress == 0 then + let now ← IO.monoMsNow + IO.println s!"[sharing-study] {i}/{todo.size} constants, {now - tLoad} ms, mismatches {mismatches}, skipped {skipped.size}" + (← IO.getStdout).flush + let tEnd ← IO.monoMsNow + IO.println s!"[sharing-study] processed {rows.size} constants, skipped {skipped.size}, mismatches {mismatches} in {tEnd - tLoad} ms (total {tEnd - t0} ms)" + + -- Summary ---------------------------------------------------------------- + let withRoots := rows.filter (·.roots > 0) + let rtFail := rows.filter (!·.roundtripOk) + let valOk := (rows.filter (·.validated == some true)).size + let valFail := rows.filter (·.validated == some false) + let valSkip := rows.filter (·.validated.isNone) + let worse := withRoots.filter fun r => r.raw > r.unshared + let sumRaw := rows.foldl (· + ·.raw) 0 + let sumUn := rows.foldl (· + ·.unshared) 0 + let mut md := "## Results\n\n" + md := md ++ s!"- Corpus: `{opts.corpus}` ({bytes.size} bytes), {env.consts.size} stored constants (distinct addresses), {env.named.size} names.\n" + md := md ++ s!"- Constants processed: {rows.size}; skipped: {skipped.size}; with at least one expression root: {withRoots.size}.\n" + md := md ++ s!"- Harness wall time: load {tLoad - t0} ms, measurement {tEnd - tLoad} ms, total {tEnd - t0} ms.\n" + md := md ++ s!"- Canonical rebuild (`buildConstantWithSharing compilerSharingLimits` on the expanded roots, then `serConstant`) differs from `rawBytes`: **{mismatches}** constants (0 when the corpus was compiled on the canonical route).\n" + md := md ++ s!"- Decode/encode roundtrip (`serConstant ∘ get`) differs from `rawBytes`: {rtFail.size} constants.\n" + md := md ++ s!"- Compositional unshared size checked against `serConstant` of the real unshared Constant: {valOk} equal, {valFail.size} different, {valSkip.size} not checked (unshared roots > {opts.validateMax} bytes).\n" + md := md ++ s!"- Constants whose stored bytes exceed their unshared bytes: {worse.size}.\n" + md := md ++ s!"- Total `rawBytes.size`: {sumRaw}; total canonical Constant bytes: {rows.foldl (· + ·.canonical) 0}; total unshared Constant bytes: {sumUn}.\n\n" + unless mismatches == 0 do + md := md ++ "### Rebuild mismatches (first 20)\n\n| constant | kind | stored B | stored table | canonical B | canonical table | first diff |\n|---|---|---:|---:|---:|---:|---:|\n" + for r in (rows.filter (!·.rebuildOk)).extract 0 20 do + md := md ++ s!"| `{r.name}` | {r.kind} | {r.raw} | {r.table} | {r.canonical} | {r.canonicalTable} | {r.firstDiff} |\n" + md := md ++ "\n" + unless valFail.isEmpty do + md := md ++ "### Unshared-size validation failures (first 20)\n\n| constant | compositional | serConstant |\n|---|---:|---:|\n" + for r in valFail.extract 0 20 do + md := md ++ s!"| `{r.name}` | {r.unshared} | {r.serUnsharedSize} |\n" + md := md ++ "\n" + unless valSkip.isEmpty do + md := md ++ "### Constants whose unshared size was not validated by serialization\n\n| constant | kind | unshared bytes | stored bytes |\n|---|---|---:|---:|\n" + for r in (valSkip.qsort fun a b => a.unshared > b.unshared).extract 0 20 do + md := md ++ s!"| `{r.name}` | {r.kind} | {r.unshared} | {r.raw} |\n" + md := md ++ "\n" + unless skipped.isEmpty do + md := md ++ "### Skipped constants\n\n| constant | reason |\n|---|---|\n" + for (n, why) in skipped do + md := md ++ s!"| `{n}` | {why} |\n" + md := md ++ "\n" + md := md ++ s!"### Distributions over constants with at least one root ({withRoots.size})\n\n" + md := md ++ distTable withRoots ++ "\n\n" + md := md ++ s!"### Distributions over all processed constants ({rows.size}, projections included)\n\n" + md := md ++ distTable rows ++ "\n\n" + md := md ++ "### Totals by ConstantInfo kind\n\n| kind | constants | `rawBytes.size` | unshared bytes | stored/unshared | table entries | stored > unshared |\n|---|---:|---:|---:|---:|---:|---:|\n" + for k in kindOrder do + let ks := rows.filter (·.kind == k) + unless ks.isEmpty do + let r := ks.foldl (· + ·.raw) 0 + let u := ks.foldl (· + ·.unshared) 0 + let t := ks.foldl (· + ·.table) 0 + let w := (ks.filter fun x => x.raw > x.unshared).size + md := md ++ s!"| {k} | {ks.size} | {r} | {u} | {fmtPct r u} | {t} | {w} |\n" + md := md ++ s!"| **all** | {rows.size} | {sumRaw} | {sumUn} | {fmtPct sumRaw sumUn} | {rows.foldl (· + ·.table) 0} | {worse.size} |\n\n" + md := md ++ "### Longest telescopes\n\n" + let maxBy (f : Row → Nat) : String := + match rows.foldl (init := none) (fun (acc : Option Row) r => + match acc with | some a => if f r > f a then some r else acc | none => some r) with + | some r => s!"{f r} (`{r.name}`)" + | none => "0" + md := md ++ s!"- App spine: {maxBy (·.maxApp)}\n- Lam telescope: {maxBy (·.maxLam)}\n- All telescope: {maxBy (·.maxAll)}\n\n" + md := md ++ "### Slowest constants in this harness (all steps above, per constant)\n\n| constant | kind | ms | `N` | stored B |\n|---|---|---:|---:|---:|\n" + for r in (rows.qsort fun a b => a.ns > b.ns).extract 0 5 do + md := md ++ s!"| `{r.name}` | {r.kind} | {r.ns / 1000000} | {r.n} | {r.raw} |\n" + md := md ++ "\n" ++ mssReport rows ws + IO.println md + if let some p := opts.md then + IO.FS.writeFile p md + IO.println s!"[sharing-study] wrote {p}" + if let some p := opts.csv then + let h ← IO.FS.Handle.mk p .write + h.putStrLn csvHeader + for r in rows do h.putStrLn (csvLine r) + h.flush + IO.println s!"[sharing-study] wrote {p}" + let mssFail := rows.any (·.mssErr.isSome) || ws.any (fun w => match w with + | .ok w => w.check.isSome + | .error _ => true) || negativeControls.any (!·.2) + return (if mismatches == 0 && skipped.isEmpty && valFail.isEmpty && rtFail.isEmpty && + !mssFail && + !rows.any (fun r => mssRefTotal r != r.mssDegSum) then 0 else 1) + +end Benchmarks.SharingStudy + +def main (args : List String) : IO UInt32 := Benchmarks.SharingStudy.main args diff --git a/Benchmarks/TruthMinesSpec/Main.lean b/Benchmarks/TruthMinesSpec/Main.lean index f98df3f1f..32987ee47 100644 --- a/Benchmarks/TruthMinesSpec/Main.lean +++ b/Benchmarks/TruthMinesSpec/Main.lean @@ -40,8 +40,9 @@ the whole deliverable AND the machine-readable record (`ix catalog info`) — no report artifacts are written. Pieces are cached: a member is - recompiled only when its pin closure, toolchain, or - ix version changed (`/.cache/.key`), or + recompiled only when its pin closure, toolchain, ix + version or `.ixe` format version changed + (`/.cache/.key`), or with `--no-cache`. On a full build, `--palomar-ixc` flattens the already-verified standalone Palomar catalog into the final manifest; @@ -239,10 +240,11 @@ private def pinOf (record : PackageSpec) : String := /-- The piece cache key: everything whose change must force a member recompile — the member's transitive pin closure over the records, - the toolchain, the ix version, and the member's roots. Local - fixture sources contribute their path only (content edits need - `--no-cache` or a `gen`-level change); pinned git sources are - exact. -/ + the toolchain, the ix version, the `.ixe` format version + (`Ixon.Env.VERSION`; a piece written under another version is + unreadable), and the member's roots. Local fixture sources + contribute their path only (content edits need `--no-cache` or a + `gen`-level change); pinned git sources are exact. -/ private partial def cacheKeyOf (lib : CatalogSpecLib) : IO String := do let record ← recordOf lib let mut seen : Array String := #[] @@ -263,8 +265,8 @@ private partial def cacheKeyOf (lib : CatalogSpecLib) : IO String := do queue := queue ++ dep.directDeps let pinsSorted := pins.qsort (· < ·) let roots := lib.roots.map (·.toString (escape := false)) - return s!"ix={Ix.versionString};toolchain={expectedToolchain};\ -roots={String.intercalate "," roots.toList};\ + return s!"ix={Ix.versionString};ixe={Ixon.Env.VERSION};\ +toolchain={expectedToolchain};roots={String.intercalate "," roots.toList};\ pins={String.intercalate "," pinsSorted.toList}" private structure MemberOutcome where diff --git a/Benchmarks/UniformHard.lean b/Benchmarks/UniformHard.lean new file mode 100644 index 000000000..58002f3a2 --- /dev/null +++ b/Benchmarks/UniformHard.lean @@ -0,0 +1,274 @@ +import Ix.CompileM +import Ix.Sharing.Exact + +/-! +# Uniform optimizer on the hardest Init constants + +Runs `Ix.Sharing.Exact.optimizeSharingUniformTable` for `w ∈ {1, 2, 3}` on the +named constants of an `.ixe` corpus (default: the slowest Init constants of +an earlier corpus measurement and those that exhausted its `states` limit), with +`maxStates = 2^20`, and prints one line per run: certified or the error, the +wall time, the search states and the largest component. + +``` +lake exe uniform-hard [name ...] +lake exe uniform-hard --compare # every constant, vs the enumeration +lake exe uniform-hard --dump w name # the largest component +lake exe uniform-hard --tiered [name ...] # tiered construction, TagN layout +lake exe uniform-hard --work [name ...] # each width's candidate alone +lake exe uniform-hard --scan-k # constants with more than candidates +``` +The default run's limits can be overridden with `UNIFORM_STATES` / +`UNIFORM_EVALS`. `--tiered` and `--work` run the compiler's construction under +the compiler's limits, which `IX_SHARING_LIMITS` overrides. +-/ + +namespace Benchmarks.UniformHard + +def defaultNames : List String := [ + "Lean.Grind.Config.mk.injEq", + "Lean.Meta.Simp.Config.mk.injEq", + "_private.Init.Data.Array.Extract.«0».Array.mem_extract_iff_getElem._proof_1_3", + "_private.Init.Data.BitVec.Bitblast.«0».BitVec.addRecAux_eq_of._proof_1_21", + "Nat.Internal.Linear.Poly.denote_eq_cancelAux", + "_private.Init.Data.Int.LemmasAux.«0».Int.max_assoc._proof_1_1", + "Int.Internal.Linear.cooper_right", + "_private.Init.Data.BitVec.Lemmas.«0».BitVec.toInt_allOnes._proof_1_2", + "_private.Init.Data.Vector.Extract.«0».Vector.extract_push._proof_1", + "_private.Init.Data.String.Iterate.«0».String.Slice.ByteIterator.finitenessRelation._proof_1", + "_private.Init.Data.BitVec.Bitblast.«0».BitVec.addRecAux_eq_of._proof_1_23", + "_private.Init.Data.Vector.Extract.«0».Vector.extract_append_left._proof_1", + "_private.Init.Data.Nat.Lemmas.«0».Nat.sub_add_sub_cancel._proof_1_1", + "BitVec.srem_zero_of_dvd", + "_private.Init.Data.Range.Polymorphic.IntLemmas.«0».Int.size_rco._proof_1_1", + "_private.Init.Data.Range.Polymorphic.Nat.«0».Std.instLawfulRcoIntersectionNat_4._proof_1", + "_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_4", + "Nat.Internal.Linear.ExprCnstr.denote_toNormPoly", + "List.min_findIdx_findIdx"] + +/-- Short name of a head. -/ +def headName : Ix.Sharing.Exact.Head → String + | .sort i => s!"sort{i}" + | .var i => s!"var{i}" + | .ref i _ => s!"ref{i}" + | .recur i _ => s!"rec{i}" + | .prj _ f => s!"prj{f}" + | .str _ => "str" + | .nat _ => "nat" + | .app => "app" + | .lam _ => "lam" + | .all .. => "all" + | .letE _ => "let" + +/-- The compiler's sharing limits (`Ix.CompileM.compilerSharingLimitsFromEnv`, +honouring `IX_SHARING_LIMITS`), under which the tiered runs measure the +production construction. -/ +def compilerLimits : IO Ix.Sharing.Exact.Limits := do + match ← Ix.CompileM.compilerSharingLimitsFromEnv with + | .ok l => pure l + | .error e => throw (IO.userError e) + +/-- The tiered construction on the named constants under the TagN layout and +the compiler's limits: the three candidate lengths and the winning width. -/ +def tieredAll (corpus : String) (names : List String) : IO UInt32 := do + let bytes ← IO.FS.readBinFile corpus + let env ← IO.ofExcept (Ixon.deEnvAnon bytes) + let limits ← compilerLimits + for name in names do + let found := env.consts.toList.find? fun (addr, _) => + match env.addrToName.get? addr with + | some n => toString n == name + | none => false + let some (_, lc) := found | IO.println s!"{name}: not found" + let .ok c := lc.get | IO.println s!"{name}: decode error" + let l := Ix.Sharing.Exact.ShareLayout.tagN + let t0 ← IO.monoNanosNow + let r ← IO.lazyPure fun _ => Ix.Sharing.Exact.canonicalSharingTieredTable l c.sharing + (Ix.Sharing.Exact.constantInfoRoots c.info) limits + let t1 ← IO.monoNanosNow + let ms := (t1 - t0) / 1000000 + match r with + | .ok r => + IO.println s!"{name} {reprStr l}: final={r.stats.phase3LayoutBytes} w={r.stats.w} candidates={r.stats.candidateLengths} serialized={r.result.variableBytes} entries={r.result.sharing.size} stored={hash r.phase1.stored} {ms} ms" + | .error e => IO.println s!"{name} {reprStr l}: FAILED {repr e} {ms} ms" + (← IO.getStdout).flush + return 0 + +/-- Phase-3 materialization work of every candidate (w = 1, 2, 3, each run alone +with `tieredAtWidth`) under the TagN layout and the compiler's limits, with the +final bytes and the time of the candidate. -/ +def workAll (corpus : String) (names : List String) : IO UInt32 := do + let bytes ← IO.FS.readBinFile corpus + let env ← IO.ofExcept (Ixon.deEnvAnon bytes) + let limits ← compilerLimits + for name in names do + let found := env.consts.toList.find? fun (addr, _) => + match env.addrToName.get? addr with + | some n => toString n == name + | none => false + let some (_, lc) := found | IO.println s!"{name}: not found" + let .ok c := lc.get | IO.println s!"{name}: decode error" + let l := Ix.Sharing.Exact.ShareLayout.tagN + for w in [1, 2, 3] do + let t0 ← IO.monoNanosNow + let r ← IO.lazyPure fun _ => + (Ix.Sharing.Exact.expand limits c.sharing + (Ix.Sharing.Exact.constantInfoRoots c.info) true).bind + fun ex => Ix.Sharing.Exact.tieredAtWidth l limits ex w + let t1 ← IO.monoNanosNow + let ms := (t1 - t0) / 1000000 + match r with + | .ok r => + IO.println s!"{name} {reprStr l} w={w}: bytes={r.stats.phase3LayoutBytes} entries={r.result.sharing.size} dag={r.result.stats.distinctSubterms} work={r.result.stats.materializedNodes} {ms} ms" + | .error e => IO.println s!"{name} {reprStr l} w={w}: FAILED {repr e} {ms} ms" + (← IO.getStdout).flush + return 0 + +open Ix.Sharing.Exact in +/-- The constants with more than `bound` sharing candidates (terms of +in-degree ≥ 2 and unshared length ≥ 2), the only ones whose stored set can +exceed `bound` entries. -/ +def scanCandidates (corpus : String) (bound : Nat) : IO UInt32 := do + let bytes ← IO.FS.readBinFile corpus + let env ← IO.ofExcept (Ixon.deEnvAnon bytes) + let mut total := 0 + for (addr, lc) in env.consts.toList do + let .ok c := lc.get | continue + total := total + 1 + let .ok ex := expand {} c.sharing (constantInfoRoots c.info) true | continue + let p := Prep.ofDag ex.dag + let f := graphFacts ex.dag ex.roots + let k := ((Array.range ex.dag.size).filter fun t => f.deg[t]! ≥ 2 && p.base[t]! ≥ 2).size + if k > bound then + IO.println s!"{(env.addrToName.get? addr).map toString |>.getD "?"} candidates={k}" + (← IO.getStdout).flush + IO.println s!"scanned {total}" + return 0 + +open Ix.Sharing.Exact in +/-- Print the largest uncertain component of a constant at width `w`. -/ +def dumpComponent (w : Nat) (c : Ixon.Constant) : IO Unit := do + let limits : Limits := {} + let ex ← IO.ofExcept ((expand limits c.sharing (constantInfoRoots c.info) true).mapError (reprStr ·)) + let p := Prep.ofDag ex.dag + -- The classes and components of the optimizer (`uniformStage`, with its + -- certain-stored threshold). + let sg := uniformStage w ex p + let f := sg.f + let b := sg.b0 + let vis := sg.vis0 + let cls := sg.cls + let comps := sg.comps + let some comp := comps.foldl (init := none) (fun acc m => + match acc with + | none => some m + | some a => if m.size > a.size then some m else acc) | IO.println "no component" + IO.println s!"N={ex.dag.size} roots={ex.roots.size} comps={comps.map (·.size)}" + let tag (x : Nat) : String := + if comp.contains x then s!"*{x}" else + match cls[x]! with + | .certainStored => s!"S{x}" + | .certainExcluded => s!"x{x}" + | .lowDegree => s!"l{x}" + | .uncertain => s!"u{x}" + for t in comp do + let node := ex.dag.node t + let g := storedGainWith p b w t vis.1[t]! vis.2[t]! + let ps := f.parents[t]!.map tag + IO.println s!"{t} {headName node.head} deg={f.deg[t]!}/{vis.1[t]!} hd={f.headDeg[t]!}/{vis.2[t]!} occ={f.occ[t]!} size={p.base[t]!} spine={p.spineLen[t]!} inl⁻={b.inlineLB[t]!} m⁻={b.mergedLB[t]!} g={g} kids={node.children.map tag} parents={ps}" + +/-- Every constant of the corpus at `w ∈ {1, 2, 3}`: certify with the +branch and bound (`maxStates = 2^20`), compare with the subset enumeration +where it finishes within `2^14` states (same stored set and model). -/ +def compareAll (corpus : String) : IO UInt32 := do + let bytes ← IO.FS.readBinFile corpus + let env ← IO.ofExcept (Ixon.deEnvAnon bytes) + let limits : Ix.Sharing.Exact.Limits := { maxStates := 1048576 } + let refLimits : Ix.Sharing.Exact.Limits := { maxStates := 1 <<< 14, uniformSubsetSearch := true } + let mut total := 0 + let mut certified := #[0, 0, 0] + let mut compared := #[0, 0, 0] + let mut mismatches := 0 + let mut failures : Array String := #[] + for (addr, lc) in env.consts.toList do + let name := (env.addrToName.get? addr).map toString |>.getD "?" + let some c := lc.get.toOption | continue + total := total + 1 + for wi in [0:3] do + let w := wi + 1 + let roots := Ix.Sharing.Exact.constantInfoRoots c.info + let r ← IO.lazyPure fun _ => Ix.Sharing.Exact.optimizeSharingUniformTable w c.sharing roots limits + match r with + | .ok u => + certified := certified.modify wi (· + 1) + let r2 ← IO.lazyPure fun _ => + Ix.Sharing.Exact.optimizeSharingUniformTable w c.sharing roots refLimits + if let .ok v := r2 then + compared := compared.modify wi (· + 1) + unless u.stored == v.stored && u.result.modelBytes == v.result.modelBytes do + mismatches := mismatches + 1 + IO.println s!"MISMATCH {name} w={w}: model {u.result.modelBytes} vs {v.result.modelBytes}" + | .error e => + failures := failures.push s!"{name} w={w}: {repr e}" + IO.println s!"FAILED {name} w={w}: {repr e}" + if total % 5000 == 0 then + IO.println s!"progress {total}: certified {certified} compared {compared} mismatches {mismatches}" + (← IO.getStdout).flush + IO.println s!"constants {total}; certified w=1,2,3: {certified}; compared with the enumeration: {compared}; mismatches {mismatches}; failures {failures.size}" + return if mismatches == 0 then 0 else 1 + +def main (args : List String) : IO UInt32 := do + let some corpus := args.head? | do + IO.eprintln "usage: uniform-hard [name ...]" + return 2 + if let [_, "--compare"] := args then return (← compareAll corpus) + if let [_, "--scan-k", b] := args then return (← scanCandidates corpus b.toNat!) + if let _ :: "--work" :: ns := args then return (← workAll corpus ns) + if let _ :: "--tiered" :: ns := args then + return (← tieredAll corpus (if ns.isEmpty then defaultNames else ns)) + if let [_, "--dump", ws, name] := args then + let bytes ← IO.FS.readBinFile corpus + let env ← IO.ofExcept (Ixon.deEnvAnon bytes) + for (addr, lc) in env.consts.toList do + if (env.addrToName.get? addr).map toString == some name then + match lc.get with + | .ok c => dumpComponent ws.toNat! c + | .error e => IO.println s!"decode error {e}" + return 0 + let names := match args.tail with + | [] => defaultNames + | ns => ns + let bytes ← IO.FS.readBinFile corpus + let env ← IO.ofExcept (Ixon.deEnvAnon bytes) + let evals := ((← IO.getEnv "UNIFORM_EVALS").bind (·.toNat?)).getD (1 <<< 30) + let states := ((← IO.getEnv "UNIFORM_STATES").bind (·.toNat?)).getD 1048576 + let limits : Ix.Sharing.Exact.Limits := { maxStates := states, maxCostEvals := evals } + for name in names do + let found := env.consts.toList.find? fun (addr, _) => + match env.addrToName.get? addr with + | some n => toString n == name + | none => false + match found with + | none => IO.println s!"{name}: not found" + | some (_, lc) => + match lc.get with + | .error e => IO.println s!"{name}: decode error {e}" + | .ok c => + for w in [1, 2, 3] do + let t0 ← IO.monoNanosNow + let r ← IO.lazyPure fun _ => Ix.Sharing.Exact.optimizeSharingUniformTable w c.sharing + (Ix.Sharing.Exact.constantInfoRoots c.info) limits + let t1 ← IO.monoNanosNow + let ms := (t1 - t0) / 1000000 + match r with + | .ok u => + let comp := u.components.foldl (fun acc m => max acc m.size) 0 + IO.println s!"{name} w={w}: certified model={u.result.modelBytes} stored={hash u.stored} cs={u.certainStored.size} unc={u.uncertain.size} states={u.statesVisited} comp={comp} {ms} ms" + | .error e => + IO.println s!"{name} w={w}: FAILED {repr e} {ms} ms" + (← IO.getStdout).flush + return 0 + +end Benchmarks.UniformHard + +def main (args : List String) : IO UInt32 := Benchmarks.UniformHard.main args diff --git a/Cargo.lock b/Cargo.lock index 0bc4cfc52..f3d97945e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1881,6 +1881,7 @@ dependencies = [ "indexmap", "ix-common", "memmap2", + "mimalloc", "nom", "num-bigint 0.4.6", "quickcheck", diff --git a/Ix.lean b/Ix.lean index 9ad43890d..4b76b9400 100644 --- a/Ix.lean +++ b/Ix.lean @@ -5,7 +5,6 @@ public import Ix.Environment public import Ix.CanonM public import Ix.Ixon public import Ix.IxonSyntax -public import Ix.Sharing public import Ix.Meta public import Ix.EnvScope public import Ix.GraphM diff --git a/Ix/Aggr/Circuit.lean b/Ix/Aggr/Circuit.lean index a2f1d5f7c..d1e59ce7e 100644 --- a/Ix/Aggr/Circuit.lean +++ b/Ix/Aggr/Circuit.lean @@ -545,10 +545,11 @@ def circuit := ⟦ -- The fixed sequence (36 or 68 bytes) 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, Option‹Addr›) { + -- TagN4(0xE, 5) is the one byte 0xE5; object format 4 is Ixon v4. 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, 3u8, "aggr: unsupported object format"); + assert_eq!(format, 4u8, "aggr: unsupported object format"); let (validator, s) = aggr_read_byte(s); assert_eq!(validator, 1u8, "aggr: wrong validator identity"); let (root, s2) = aggr_read_address(s); diff --git a/Ix/Aiur/Library/ByteStream.lean b/Ix/Aiur/Library/ByteStream.lean index f72720fa3..331d70f73 100644 --- a/Ix/Aiur/Library/ByteStream.lean +++ b/Ix/Aiur/Library/ByteStream.lean @@ -30,22 +30,6 @@ def byteStream := ⟦ bytes } - -- Count bytes needed to represent a u64. - -- Important: this implementation differs from the Lean and Rust ones, returning - -- 1 for [0; 8] instead of 0. - fn u64_byte_count(x: U64) -> U8 { - match x { - [_, 0, 0, 0, 0, 0, 0, 0] => 1u8, - [_, _, 0, 0, 0, 0, 0, 0] => 2u8, - [_, _, _, 0, 0, 0, 0, 0] => 3u8, - [_, _, _, _, 0, 0, 0, 0] => 4u8, - [_, _, _, _, _, 0, 0, 0] => 5u8, - [_, _, _, _, _, _, 0, 0] => 6u8, - [_, _, _, _, _, _, _, 0] => 7u8, - _ => 8u8, - } - } - fn u64_is_zero(x: U64) -> G { match x { [0, 0, 0, 0, 0, 0, 0, 0] => 1, diff --git a/Ix/AssumptionTree.lean b/Ix/AssumptionTree.lean index da4b1dc07..5913b1c37 100644 --- a/Ix/AssumptionTree.lean +++ b/Ix/AssumptionTree.lean @@ -16,10 +16,10 @@ ## Serialization - Tag4 size 2 under flag 0xE: + TagN (`f = 4`) value 2 under flag 0xE: ```text - [Tag4(0xE, 2) = 0xE2] [body] + [TagN(4, 0xE, 2) = 0xE2] [body] body recursive: leaf(addr): [0x00] [addr:32] @@ -160,7 +160,7 @@ partial def putBody : AssumptionTree → PutM Unit putBody r def put (t : AssumptionTree) : PutM Unit := do - putTag4 ⟨FLAG, VARIANT⟩ + putTagN 4 FLAG VARIANT putBody t partial def getBody : GetM AssumptionTree := do @@ -177,9 +177,9 @@ partial def getBody : GetM AssumptionTree := do throw s!"AssumptionTree.getBody: invalid body tag {tag.toNat}" def get : GetM AssumptionTree := do - let tag ← getTag4 - if tag.flag != FLAG || tag.size != VARIANT then - throw s!"AssumptionTree.get: expected Tag4 0xE/2, got {tag.flag.toNat}/{tag.size}" + let tag ← getTagN 4 + if tag.flag != FLAG || tag.value != VARIANT then + throw s!"AssumptionTree.get: expected header 0xE/2, got {tag.flag.toNat}/{tag.value}" getBody def ser (t : AssumptionTree) : ByteArray := runPut (put t) diff --git a/Ix/AuxGen/CompileAux.lean b/Ix/AuxGen/CompileAux.lean index d321dd1c5..4115e9493 100644 --- a/Ix/AuxGen/CompileAux.lean +++ b/Ix/AuxGen/CompileAux.lean @@ -64,7 +64,7 @@ namespace Ix.AuxGen open Ix.CompileM (CompileM CompileError getBlockState modifyBlockState getCompileEnv compileName withMutCtx preseedExprTables - mutConstPreseedExprs compileMutConsts sortConsts buildConstantWithSharing) + mutConstPreseedExprs compileMutConsts sortConsts buildBlockConstant) /-! ## State-model helpers (Rust `CompileState` mutations) -/ @@ -187,20 +187,17 @@ private def compileAuxBlockCore (auxConsts : Array MutConst) -- member (collecting metas, incl. ctor metas), push only the first -- representative's data/exprs. Runs under the block's mutCtx like -- Rust's explicit `&mut_ctx` threading. - let (mutConsts, allExprs, allMetas, blockRefs, blockUnivs) ← + let (mutConsts, allMetas, blockRefs, blockUnivs) ← liftM (withMutCtx mutCtx (do preseedExprTables preseedExprs - let (dat, exprs, metas) ← compileMutConsts sortedClasses + let (dat, _, metas) ← compileMutConsts sortedClasses let st ← getBlockState - pure (dat, exprs, metas, st.refs, st.univs)) : CompileM _) + pure (dat, metas, st.refs, st.univs)) : CompileM _) -- `all_metas` name → meta view (Rust FxHashMap; keys are unique). let metaMap : Std.HashMap Name Ixon.ConstantMeta := allMetas.foldl (init := {}) fun m (n, cm) => m.insert n cm - -- `name_str` (mutual.rs:192) feeds Rust's sharing debug stats only — - -- not modeled. - -- Singleton non-inductive aux blocks: standalone `Defn`/`Recr` -- Constant instead of `Muts([one])` (mutual.rs:199-247). if mutConsts.size == 1 && !(mutConsts[0]! matches .indc _) then @@ -209,11 +206,11 @@ private def compileAuxBlockCore (auxConsts : Array MutConst) | .defn d => .defn d | .recr r => .recr r | .indc _ => unreachable! - -- `apply_sharing_to_{definition,recursor}_with_stats` - -- (mutual.rs:208-218): `buildConstantWithSharing` dispatches on the - -- info variant; `allExprs` holds exactly the single representative's - -- root exprs ([typ, value] / [typ, rule rhss…]). - let constant := buildConstantWithSharing info allExprs blockRefs blockUnivs + -- `apply_sharing_to_{definition,recursor}_with_limits` + -- (mutual.rs:208-218): `buildBlockConstant` shares the single + -- representative's roots ([typ, value] / [typ, rule rhss…]). + let constant ← + liftM (buildBlockConstant info blockRefs blockUnivs : CompileM _) let standaloneAddr := contentAddress constant liftM <| show CompileM Unit from do auxStoreConst standaloneAddr constant @@ -235,8 +232,8 @@ private def compileAuxBlockCore (auxConsts : Array MutConst) return () -- Compile the mutual block (mutual.rs:249-256). - let block := buildConstantWithSharing (.muts mutConsts) allExprs - blockRefs blockUnivs + let block ← liftM + (buildBlockConstant (.muts mutConsts) blockRefs blockUnivs : CompileM _) let blockBytes := Ixon.ser block let blockAddr := Address.blake3 blockBytes liftM (auxStoreConst blockAddr block : CompileM _) diff --git a/Ix/Catalog.lean b/Ix/Catalog.lean index 9b02b51bb..ae7cb694d 100644 --- a/Ix/Catalog.lean +++ b/Ix/Catalog.lean @@ -44,7 +44,8 @@ open Ixon (PutM GetM putU8 getU8 putBytes getBytes runPut runGet) /-- Magic bytes at the head of every `.ixc` file. -/ def MAGIC : ByteArray := String.toUTF8 "IXC" ++ ⟨#[0, 0, 0, 0, 0]⟩ -/-- Manifest v2 binds Ixon v3 and erased-lean-v1 catalog claims. -/ +/-- Manifest v2 binds the Ixon object format (`Ixon.Env.OBJECT_FORMAT`) + and erased-lean-v1 catalog claims. -/ def VERSION : UInt32 := 2 /-- Storage-profile flag: bit0 of the header `flags` word. -/ @@ -185,7 +186,7 @@ def ser (c : Catalog) : ByteArray := runPut do putU32LE (match c.storage with | .chunked _ => FLAG_CHUNKED | .fat _ => 0) - putU8 3 + putU8 Ixon.Env.OBJECT_FORMAT putU8 1 putAddr c.membersRoot putAddr c.contentRoot @@ -247,7 +248,10 @@ where let flags ← getU32LE if flags &&& (~~~FLAG_CHUNKED) != 0 then throw s!"unknown .ixc flags {flags}" - unless (← getU8) == 3 do throw "catalog: unsupported object format" + let format ← getU8 + unless format == Ixon.Env.OBJECT_FORMAT do + throw s!"catalog: unsupported object format {format}, expected \ + {Ixon.Env.OBJECT_FORMAT} — regenerate the catalog" unless (← getU8) == 1 do throw "catalog: wrong validator identity" let membersRoot ← getAddr let contentRoot ← getAddr diff --git a/Ix/Claim.lean b/Ix/Claim.lean index f11a54b5d..40ad54b9c 100644 --- a/Ix/Claim.lean +++ b/Ix/Claim.lean @@ -64,7 +64,7 @@ private def getQuotKind : GetM QuotKind := do | 0 => return .type | 1 => return .ctor | 2 => return .lift | 3 => return .ind | v => throw s!"getQuotKind: invalid {v}" -private def getTag0Size : GetM UInt64 := return (← getTag0).size +private def getTagN0Value : GetM UInt64 := return (← getTagN 0).value private def getOpt (mask : UInt64) (bit : UInt64) (read : GetM α) : GetM (Option α) := if mask &&& bit != 0 then some <$> read else pure none @@ -168,21 +168,21 @@ namespace RevealConstructorInfo def put (info : RevealConstructorInfo) : PutM Unit := do let mask := computeMask [info.isUnsafe.isSome, info.lvls.isSome, info.cidx.isSome, info.params.isSome, info.fields.isSome, info.typ.isSome] - putTag0 ⟨mask⟩ + putTagN 0 0 mask match info.isUnsafe with | some b => putBoolField b | none => pure () - match info.lvls with | some n => putTag0 ⟨n⟩ | none => pure () - match info.cidx with | some n => putTag0 ⟨n⟩ | none => pure () - match info.params with | some n => putTag0 ⟨n⟩ | none => pure () - match info.fields with | some n => putTag0 ⟨n⟩ | none => pure () + match info.lvls with | some n => putTagN 0 0 n | none => pure () + match info.cidx with | some n => putTagN 0 0 n | none => pure () + match info.params with | some n => putTagN 0 0 n | none => pure () + match info.fields with | some n => putTagN 0 0 n | none => pure () match info.typ with | some a => Serialize.put a | none => pure () def get : GetM RevealConstructorInfo := do - let mask := (← getTag0).size + let mask := (← getTagN 0).value let isUnsafe ← getOpt mask 1 getBoolField - let lvls ← getOpt mask 2 getTag0Size - let cidx ← getOpt mask 4 getTag0Size - let params ← getOpt mask 8 getTag0Size - let fields ← getOpt mask 16 getTag0Size + let lvls ← getOpt mask 2 getTagN0Value + let cidx ← getOpt mask 4 getTagN0Value + let params ← getOpt mask 8 getTagN0Value + let fields ← getOpt mask 16 getTagN0Value let typ ← getOpt mask 32 Serialize.get return ⟨isUnsafe, lvls, cidx, params, fields, typ⟩ @@ -195,13 +195,13 @@ end RevealConstructorInfo namespace RevealRecursorRule def put (rule : RevealRecursorRule) : PutM Unit := do - putTag0 ⟨rule.ruleIdx⟩ - putTag0 ⟨rule.fields⟩ + putTagN 0 0 rule.ruleIdx + putTagN 0 0 rule.fields Serialize.put rule.rhs def get : GetM RevealRecursorRule := do - let ruleIdx ← getTag0Size - let fields ← getTag0Size + let ruleIdx ← getTagN0Value + let fields ← getTagN0Value let rhs ← Serialize.get return ⟨ruleIdx, fields, rhs⟩ @@ -212,26 +212,26 @@ end RevealRecursorRule -- ============================================================================ private def putRules (rules : Array RevealRecursorRule) : PutM Unit := do - putTag0 ⟨rules.size.toUInt64⟩ + putTagN 0 0 rules.size.toUInt64 for rule in rules do RevealRecursorRule.put rule private def getRules : GetM (Array RevealRecursorRule) := do - let count ← getTag0Size + let count ← getTagN0Value let mut rules := #[] for _ in [:count.toNat] do rules := rules.push (← RevealRecursorRule.get) return rules private def putCtors (ctors : Array (UInt64 × RevealConstructorInfo)) : PutM Unit := do - putTag0 ⟨ctors.size.toUInt64⟩ + putTagN 0 0 ctors.size.toUInt64 for (idx, info) in ctors do - putTag0 ⟨idx⟩ + putTagN 0 0 idx RevealConstructorInfo.put info private def getCtors : GetM (Array (UInt64 × RevealConstructorInfo)) := do - let count ← getTag0Size + let count ← getTagN0Value let mut ctors := #[] for _ in [:count.toNat] do - let idx ← getTag0Size + let idx ← getTagN0Value let info ← RevealConstructorInfo.get ctors := ctors.push (idx, info) return ctors @@ -246,21 +246,21 @@ def put : RevealMutConstInfo → PutM Unit | .defn kind safety lvls typ value => do putU8 0 let mask := computeMask [kind.isSome, safety.isSome, lvls.isSome, typ.isSome, value.isSome] - putTag0 ⟨mask⟩ + putTagN 0 0 mask match kind with | some k => putDefKind k | none => pure () match safety with | some s => putDefSafety s | none => pure () - match lvls with | some n => putTag0 ⟨n⟩ | none => pure () + match lvls with | some n => putTagN 0 0 n | none => pure () match typ with | some a => Serialize.put a | none => pure () match value with | some a => Serialize.put a | none => pure () | .indc isUnsafe lvls params indices typ ctors => do putU8 1 let mask := computeMask [isUnsafe.isSome, lvls.isSome, params.isSome, indices.isSome, typ.isSome, ctors.isSome] - putTag0 ⟨mask⟩ + putTagN 0 0 mask match isUnsafe with | some b => putBoolField b | none => pure () - match lvls with | some n => putTag0 ⟨n⟩ | none => pure () - match params with | some n => putTag0 ⟨n⟩ | none => pure () - match indices with | some n => putTag0 ⟨n⟩ | none => pure () + match lvls with | some n => putTagN 0 0 n | none => pure () + match params with | some n => putTagN 0 0 n | none => pure () + match indices with | some n => putTagN 0 0 n | none => pure () match typ with | some a => Serialize.put a | none => pure () match ctors with | some c => putCtors c | none => pure () | .recr k isUnsafe lvls params indices motives minors typ rules => do @@ -268,44 +268,44 @@ def put : RevealMutConstInfo → PutM Unit let mask := computeMask [k.isSome, isUnsafe.isSome, lvls.isSome, params.isSome, indices.isSome, motives.isSome, minors.isSome, typ.isSome, rules.isSome] - putTag0 ⟨mask⟩ + putTagN 0 0 mask match k with | some b => putBoolField b | none => pure () match isUnsafe with | some b => putBoolField b | none => pure () - match lvls with | some n => putTag0 ⟨n⟩ | none => pure () - match params with | some n => putTag0 ⟨n⟩ | none => pure () - match indices with | some n => putTag0 ⟨n⟩ | none => pure () - match motives with | some n => putTag0 ⟨n⟩ | none => pure () - match minors with | some n => putTag0 ⟨n⟩ | none => pure () + match lvls with | some n => putTagN 0 0 n | none => pure () + match params with | some n => putTagN 0 0 n | none => pure () + match indices with | some n => putTagN 0 0 n | none => pure () + match motives with | some n => putTagN 0 0 n | none => pure () + match minors with | some n => putTagN 0 0 n | none => pure () match typ with | some a => Serialize.put a | none => pure () match rules with | some r => putRules r | none => pure () def get : GetM RevealMutConstInfo := do let variant ← getU8 - let mask ← getTag0Size + let mask ← getTagN0Value match variant with | 0 => do -- Defn let kind ← getOpt mask 1 getDefKind let safety ← getOpt mask 2 getDefSafety - let lvls ← getOpt mask 4 getTag0Size + let lvls ← getOpt mask 4 getTagN0Value let typ ← getOpt mask 8 Serialize.get let value ← getOpt mask 16 Serialize.get return .defn kind safety lvls typ value | 1 => do -- Indc let isUnsafe ← getOpt mask 1 getBoolField - let lvls ← getOpt mask 2 getTag0Size - let params ← getOpt mask 4 getTag0Size - let indices ← getOpt mask 8 getTag0Size + let lvls ← getOpt mask 2 getTagN0Value + let params ← getOpt mask 4 getTagN0Value + let indices ← getOpt mask 8 getTagN0Value let typ ← getOpt mask 16 Serialize.get let ctors ← getOpt mask 32 getCtors return .indc isUnsafe lvls params indices typ ctors | 2 => do -- Recr let k ← getOpt mask 1 getBoolField let isUnsafe ← getOpt mask 2 getBoolField - let lvls ← getOpt mask 4 getTag0Size - let params ← getOpt mask 8 getTag0Size - let indices ← getOpt mask 16 getTag0Size - let motives ← getOpt mask 32 getTag0Size - let minors ← getOpt mask 64 getTag0Size + let lvls ← getOpt mask 4 getTagN0Value + let params ← getOpt mask 8 getTagN0Value + let indices ← getOpt mask 16 getTagN0Value + let motives ← getOpt mask 32 getTagN0Value + let minors ← getOpt mask 64 getTagN0Value let typ ← getOpt mask 128 Serialize.get let rules ← getOpt mask 256 getRules return .recr k isUnsafe lvls params indices motives minors typ rules @@ -323,10 +323,10 @@ def put : RevealConstantInfo → PutM Unit | .defn kind safety lvls typ value => do putU8 0 let mask := computeMask [kind.isSome, safety.isSome, lvls.isSome, typ.isSome, value.isSome] - putTag0 ⟨mask⟩ + putTagN 0 0 mask match kind with | some k => putDefKind k | none => pure () match safety with | some s => putDefSafety s | none => pure () - match lvls with | some n => putTag0 ⟨n⟩ | none => pure () + match lvls with | some n => putTagN 0 0 n | none => pure () match typ with | some a => Serialize.put a | none => pure () match value with | some a => Serialize.put a | none => pure () | .recr k isUnsafe lvls params indices motives minors typ rules => do @@ -334,120 +334,120 @@ def put : RevealConstantInfo → PutM Unit let mask := computeMask [k.isSome, isUnsafe.isSome, lvls.isSome, params.isSome, indices.isSome, motives.isSome, minors.isSome, typ.isSome, rules.isSome] - putTag0 ⟨mask⟩ + putTagN 0 0 mask match k with | some b => putBoolField b | none => pure () match isUnsafe with | some b => putBoolField b | none => pure () - match lvls with | some n => putTag0 ⟨n⟩ | none => pure () - match params with | some n => putTag0 ⟨n⟩ | none => pure () - match indices with | some n => putTag0 ⟨n⟩ | none => pure () - match motives with | some n => putTag0 ⟨n⟩ | none => pure () - match minors with | some n => putTag0 ⟨n⟩ | none => pure () + match lvls with | some n => putTagN 0 0 n | none => pure () + match params with | some n => putTagN 0 0 n | none => pure () + match indices with | some n => putTagN 0 0 n | none => pure () + match motives with | some n => putTagN 0 0 n | none => pure () + match minors with | some n => putTagN 0 0 n | none => pure () match typ with | some a => Serialize.put a | none => pure () match rules with | some r => putRules r | none => pure () | .axio isUnsafe lvls typ => do putU8 2 let mask := computeMask [isUnsafe.isSome, lvls.isSome, typ.isSome] - putTag0 ⟨mask⟩ + putTagN 0 0 mask match isUnsafe with | some b => putBoolField b | none => pure () - match lvls with | some n => putTag0 ⟨n⟩ | none => pure () + match lvls with | some n => putTagN 0 0 n | none => pure () match typ with | some a => Serialize.put a | none => pure () | .quot kind lvls typ => do putU8 3 let mask := computeMask [kind.isSome, lvls.isSome, typ.isSome] - putTag0 ⟨mask⟩ + putTagN 0 0 mask match kind with | some k => putQuotKind k | none => pure () - match lvls with | some n => putTag0 ⟨n⟩ | none => pure () + match lvls with | some n => putTagN 0 0 n | none => pure () match typ with | some a => Serialize.put a | none => pure () | .cPrj idx cidx block => do putU8 4 let mask := computeMask [idx.isSome, cidx.isSome, block.isSome] - putTag0 ⟨mask⟩ - match idx with | some n => putTag0 ⟨n⟩ | none => pure () - match cidx with | some n => putTag0 ⟨n⟩ | none => pure () + putTagN 0 0 mask + match idx with | some n => putTagN 0 0 n | none => pure () + match cidx with | some n => putTagN 0 0 n | none => pure () match block with | some a => Serialize.put a | none => pure () | .rPrj idx block => do putU8 5 let mask := computeMask [idx.isSome, block.isSome] - putTag0 ⟨mask⟩ - match idx with | some n => putTag0 ⟨n⟩ | none => pure () + putTagN 0 0 mask + match idx with | some n => putTagN 0 0 n | none => pure () match block with | some a => Serialize.put a | none => pure () | .iPrj idx block => do putU8 6 let mask := computeMask [idx.isSome, block.isSome] - putTag0 ⟨mask⟩ - match idx with | some n => putTag0 ⟨n⟩ | none => pure () + putTagN 0 0 mask + match idx with | some n => putTagN 0 0 n | none => pure () match block with | some a => Serialize.put a | none => pure () | .dPrj idx block => do putU8 7 let mask := computeMask [idx.isSome, block.isSome] - putTag0 ⟨mask⟩ - match idx with | some n => putTag0 ⟨n⟩ | none => pure () + putTagN 0 0 mask + match idx with | some n => putTagN 0 0 n | none => pure () match block with | some a => Serialize.put a | none => pure () | .muts components => do putU8 8 let mask : UInt64 := if components.isEmpty then 0 else 1 - putTag0 ⟨mask⟩ + putTagN 0 0 mask if !components.isEmpty then - putTag0 ⟨components.size.toUInt64⟩ + putTagN 0 0 components.size.toUInt64 for (idx, info) in components do - putTag0 ⟨idx⟩ + putTagN 0 0 idx RevealMutConstInfo.put info def get : GetM RevealConstantInfo := do let variant ← getU8 - let mask ← getTag0Size + let mask ← getTagN0Value match variant with | 0 => do -- Defn let kind ← getOpt mask 1 getDefKind let safety ← getOpt mask 2 getDefSafety - let lvls ← getOpt mask 4 getTag0Size + let lvls ← getOpt mask 4 getTagN0Value let typ ← getOpt mask 8 Serialize.get let value ← getOpt mask 16 Serialize.get return .defn kind safety lvls typ value | 1 => do -- Recr let k ← getOpt mask 1 getBoolField let isUnsafe ← getOpt mask 2 getBoolField - let lvls ← getOpt mask 4 getTag0Size - let params ← getOpt mask 8 getTag0Size - let indices ← getOpt mask 16 getTag0Size - let motives ← getOpt mask 32 getTag0Size - let minors ← getOpt mask 64 getTag0Size + let lvls ← getOpt mask 4 getTagN0Value + let params ← getOpt mask 8 getTagN0Value + let indices ← getOpt mask 16 getTagN0Value + let motives ← getOpt mask 32 getTagN0Value + let minors ← getOpt mask 64 getTagN0Value let typ ← getOpt mask 128 Serialize.get let rules ← getOpt mask 256 getRules return .recr k isUnsafe lvls params indices motives minors typ rules | 2 => do -- Axio let isUnsafe ← getOpt mask 1 getBoolField - let lvls ← getOpt mask 2 getTag0Size + let lvls ← getOpt mask 2 getTagN0Value let typ ← getOpt mask 4 Serialize.get return .axio isUnsafe lvls typ | 3 => do -- Quot let kind ← getOpt mask 1 getQuotKind - let lvls ← getOpt mask 2 getTag0Size + let lvls ← getOpt mask 2 getTagN0Value let typ ← getOpt mask 4 Serialize.get return .quot kind lvls typ | 4 => do -- CPrj - let idx ← getOpt mask 1 getTag0Size - let cidx ← getOpt mask 2 getTag0Size + let idx ← getOpt mask 1 getTagN0Value + let cidx ← getOpt mask 2 getTagN0Value let block ← getOpt mask 4 Serialize.get return .cPrj idx cidx block | 5 => do -- RPrj - let idx ← getOpt mask 1 getTag0Size + let idx ← getOpt mask 1 getTagN0Value let block ← getOpt mask 2 Serialize.get return .rPrj idx block | 6 => do -- IPrj - let idx ← getOpt mask 1 getTag0Size + let idx ← getOpt mask 1 getTagN0Value let block ← getOpt mask 2 Serialize.get return .iPrj idx block | 7 => do -- DPrj - let idx ← getOpt mask 1 getTag0Size + let idx ← getOpt mask 1 getTagN0Value let block ← getOpt mask 2 Serialize.get return .dPrj idx block | 8 => do -- Muts let components ← if mask &&& 1 != 0 then do - let count ← getTag0Size + let count ← getTagN0Value let mut comps : Array (UInt64 × RevealMutConstInfo) := #[] for _ in [:count.toNat] do - let idx ← getTag0Size + let idx ← getTagN0Value let info ← RevealMutConstInfo.get comps := comps.push (idx, info) pure comps @@ -463,16 +463,17 @@ end RevealConstantInfo namespace Claim --- Tag4 size dispatch (mirrors src/ix/ixon/proof.rs). --- Flag 0xE holds Env, Comm, AssumptionTree, and claims. Variants 0–7 --- are single-byte tags and all taken; variant 8 (catalog) is the --- first multi-byte claim tag, `0xE8 0x08` on the wire. --- Flag 0xF holds proofs (single-byte tags). +-- TagN (`f = 4`) value dispatch (mirrors crates/ixon/src/proof.rs). +-- Flag 0xE holds Comm, AssumptionTree, and claims. Variants 0–7 are in +-- rung 1, the single bytes 0xE0–0xE7; from 8 on the header is two bytes, +-- so catalog is `E8 00` and resource `E8 01` on the wire. The `.ixe` +-- header also uses flag 0xE, with the format version as the value +-- (`0xE4` for version 4, the same byte as the check claim tag). +-- Flag 0xF holds proofs (single-byte tags 0xF0–0xF6). def FLAG_CLAIM : UInt8 := 0xE def FLAG_PROOF : UInt8 := 0xF -def VARIANT_ENV : UInt64 := 0 -- VARIANT 1 = Comm (handled in Ix.Ixon) def VARIANT_ASSUMPTION_TREE : UInt64 := 2 def VARIANT_EVAL_CLAIM : UInt64 := 3 @@ -492,7 +493,7 @@ def VARIANT_CATALOG_PROOF : UInt64 := 5 def VARIANT_RESOURCE_PROOF : UInt64 := 6 /-- Encode an `Option Address` as `[0x00]` (none) or `[0x01][addr:32]` - (some). Mirrors `put_opt_addr` in src/ix/ixon/proof.rs. -/ + (some). Mirrors `put_opt_addr` in crates/ixon/src/proof.rs. -/ def putOptAddr : Option Address → PutM Unit | none => putU8 0x00 | some a => do putU8 0x01; Serialize.put a @@ -503,8 +504,8 @@ def getOptAddr : GetM (Option Address) := do else if b == 0x01 then return some (← Serialize.get) else throw s!"getOptAddr: invalid tag {b}" -/-- Claim and proof payloads bind both the object format and the validator. -0 is structural-v1, 1 is erased-lean-v1, 2 is resource-v1. -/ +/-- Claim and proof payloads bind both the object format (`Ixon.Env.OBJECT_FORMAT`) +and the validator. 0 is structural-v1, 1 is erased-lean-v1, 2 is resource-v1. -/ def validatorForVariant (variant : UInt64) : UInt8 := if variant == VARIANT_REVEAL_CLAIM || variant == VARIANT_CONTAINS_CLAIM then 0 else if variant == VARIANT_RESOURCE_CLAIM then 2 @@ -520,15 +521,18 @@ def variantOf : Claim → UInt64 | .resource .. => VARIANT_RESOURCE_CLAIM def putScope (validator : UInt8) : PutM Unit := do - putU8 3 + putU8 Ixon.Env.OBJECT_FORMAT putU8 validator def getScope (validator : UInt8) : GetM Unit := do - unless (← getU8) == 3 do throw "claim: unsupported object format" + let format ← getU8 + unless format == Ixon.Env.OBJECT_FORMAT do + throw s!"claim: unsupported object format {format}, expected \ + {Ixon.Env.OBJECT_FORMAT} — regenerate the claim" unless (← getU8) == validator do throw "claim: wrong validator identity" def put (claim : Claim) : PutM Unit := do - putTag4 ⟨FLAG_CLAIM, variantOf claim⟩ + putTagN 4 FLAG_CLAIM (variantOf claim) putScope (validatorForVariant (variantOf claim)) match claim with | .eval input output assumptions => do @@ -548,7 +552,7 @@ def put (claim : Claim) : PutM Unit := do Serialize.put tree Serialize.put const | .catalog members content assumptions => do - -- First multi-byte claim tag: 0xE8 0x08 on the wire. + -- A two-byte claim tag: `E8 00` on the wire. Serialize.put members Serialize.put content putOptAddr assumptions @@ -557,36 +561,36 @@ def put (claim : Claim) : PutM Unit := do Serialize.put profile def get : GetM Claim := do - let tag ← getTag4 + let tag ← getTagN 4 if tag.flag != FLAG_CLAIM then throw s!"Claim.get: expected flag 0xE, got {tag.flag}" - getScope (validatorForVariant tag.size) - if tag.size == VARIANT_EVAL_CLAIM then + getScope (validatorForVariant tag.value) + if tag.value == VARIANT_EVAL_CLAIM then let input ← Serialize.get let output ← Serialize.get let asm ← getOptAddr return .eval input output asm - else if tag.size == VARIANT_CHECK_CLAIM then + else if tag.value == VARIANT_CHECK_CLAIM then let const ← Serialize.get let asm ← getOptAddr return .check const asm - else if tag.size == VARIANT_CHECK_ENV_CLAIM then + else if tag.value == VARIANT_CHECK_ENV_CLAIM then let root ← Serialize.get let asm ← getOptAddr return .checkEnv root asm - else if tag.size == VARIANT_REVEAL_CLAIM then + else if tag.value == VARIANT_REVEAL_CLAIM then return .reveal (← Serialize.get) (← RevealConstantInfo.get) - else if tag.size == VARIANT_CONTAINS_CLAIM then + else if tag.value == VARIANT_CONTAINS_CLAIM then return .contains (← Serialize.get) (← Serialize.get) - else if tag.size == VARIANT_CATALOG_CLAIM then + else if tag.value == VARIANT_CATALOG_CLAIM then let members ← Serialize.get let content ← Serialize.get let asm ← getOptAddr return .catalog members content asm - else if tag.size == VARIANT_RESOURCE_CLAIM then + else if tag.value == VARIANT_RESOURCE_CLAIM then return .resource (← Serialize.get) (← Serialize.get) else - throw s!"Claim.get: invalid claim variant {tag.size}" + throw s!"Claim.get: invalid claim variant {tag.value}" def ser (c : Claim) : ByteArray := runPut (put c) def de (bytes : ByteArray) : Except String Claim := runGetExact get bytes @@ -608,7 +612,7 @@ end Ix -- ============================================================================ -- Ixon.Proof — wraps a Claim with its opaque ZK proof bytes. --- Mirrors `src/ix/ixon/proof.rs:173`. Lives under flag 0xF (vs claims +-- Mirrors `Proof` in `crates/ixon/src/proof.rs`. Lives under flag 0xF (vs claims -- under 0xE) so the first serialized byte alone disambiguates kind. -- ============================================================================ @@ -621,7 +625,7 @@ structure Proof where namespace Proof -/-- The proof-variant size matching this claim, used as the Tag4 size +/-- The proof variant matching this claim, used as the TagN (`f = 4`) value field under `FLAG_PROOF = 0xF`. -/ def variantOf : Ix.Claim → UInt64 | .eval _ _ _ => Ix.Claim.VARIANT_EVAL_PROOF @@ -633,7 +637,7 @@ def variantOf : Ix.Claim → UInt64 | .resource _ _ => Ix.Claim.VARIANT_RESOURCE_PROOF def put (p : Proof) : PutM Unit := do - putTag4 ⟨Ix.Claim.FLAG_PROOF, variantOf p.claim⟩ + putTagN 4 Ix.Claim.FLAG_PROOF (variantOf p.claim) Ix.Claim.putScope (Ix.Claim.validatorForVariant (Ix.Claim.variantOf p.claim)) match p.claim with | .eval input output asm => do @@ -659,47 +663,47 @@ def put (p : Proof) : PutM Unit := do | .resource root profile => do Serialize.put root Serialize.put profile - putTag0 ⟨p.proof.size.toUInt64⟩ + putTagN 0 0 p.proof.size.toUInt64 putBytes p.proof def get : GetM Proof := do - let tag ← getTag4 + let tag ← getTagN 4 if tag.flag != Ix.Claim.FLAG_PROOF then throw s!"Ixon.Proof.get: expected flag 0xF, got {tag.flag}" - Ix.Claim.getScope (Ix.Claim.validatorForVariant (tag.size + 3)) + Ix.Claim.getScope (Ix.Claim.validatorForVariant (tag.value + 3)) let claim : Ix.Claim ← - if tag.size == Ix.Claim.VARIANT_EVAL_PROOF then do + if tag.value == Ix.Claim.VARIANT_EVAL_PROOF then do let input ← Serialize.get let output ← Serialize.get let asm ← Ix.Claim.getOptAddr pure (.eval input output asm) - else if tag.size == Ix.Claim.VARIANT_CHECK_PROOF then do + else if tag.value == Ix.Claim.VARIANT_CHECK_PROOF then do let addr ← Serialize.get let asm ← Ix.Claim.getOptAddr pure (.check addr asm) - else if tag.size == Ix.Claim.VARIANT_CHECK_ENV_PROOF then do + else if tag.value == Ix.Claim.VARIANT_CHECK_ENV_PROOF then do let root ← Serialize.get let asm ← Ix.Claim.getOptAddr pure (.checkEnv root asm) - else if tag.size == Ix.Claim.VARIANT_REVEAL_PROOF then do + else if tag.value == Ix.Claim.VARIANT_REVEAL_PROOF then do let comm ← Serialize.get let info ← Ix.RevealConstantInfo.get pure (.reveal comm info) - else if tag.size == Ix.Claim.VARIANT_CONTAINS_PROOF then do + else if tag.value == Ix.Claim.VARIANT_CONTAINS_PROOF then do let tree ← Serialize.get let target ← Serialize.get pure (.contains tree target) - else if tag.size == Ix.Claim.VARIANT_CATALOG_PROOF then do + else if tag.value == Ix.Claim.VARIANT_CATALOG_PROOF then do let members ← Serialize.get let content ← Serialize.get let asm ← Ix.Claim.getOptAddr pure (.catalog members content asm) - else if tag.size == Ix.Claim.VARIANT_RESOURCE_PROOF then do + else if tag.value == Ix.Claim.VARIANT_RESOURCE_PROOF then do pure (.resource (← Serialize.get) (← Serialize.get)) else - throw s!"Ixon.Proof.get: invalid proof variant {tag.size}" - let lenTag ← getTag0 - let bytes ← getBytes lenTag.size.toNat + throw s!"Ixon.Proof.get: invalid proof variant {tag.value}" + let lenTag ← getTagN 0 + let bytes ← getBytes lenTag.value.toNat pure { claim, proof := bytes } def ser (p : Proof) : ByteArray := runPut (put p) diff --git a/Ix/Cli/CompileCmd.lean b/Ix/Cli/CompileCmd.lean index 30c4506ee..d87438be2 100644 --- a/Ix/Cli/CompileCmd.lean +++ b/Ix/Cli/CompileCmd.lean @@ -19,12 +19,28 @@ private def defaultOutPathFor (pathStr : String) : String := let stem := path.fileStem.getD (path.fileName.getD pathStr) stem.toLower ++ ".ixe" +/-- `--sharing-limits SPEC`: validate the override (the format of +`Ix.Sharing.Exact.Limits.withOverrides`, which also accepts the Rust limit +keys) and publish it through `IX_SHARING_LIMITS`, which both compilers read. +Returns the parse error, if any. -/ +def applySharingLimitsFlag (p : Cli.Parsed) : IO (Option String) := do + let some flag := p.flag? "sharing-limits" | return none + let spec := flag.as! String + match Ix.CompileM.compilerSharingLimits.withOverrides spec with + | .error e => return some s!"--sharing-limits: {e}" + | .ok _ => + Std.Internal.UV.System.osSetenv Ix.CompileM.sharingLimitsEnvVar spec + return none + def runCompileCmd (p : Cli.Parsed) : IO UInt32 := do -- Keep the environment-variable interface for scripts, while giving the -- CLI an ordinary discoverable switch. The Rust compiler and serializer -- both consult IX_VERBOSE, so setting it once enables the whole pipeline. if p.hasFlag "verbose" then Std.Internal.UV.System.osSetenv "IX_VERBOSE" "1" + if let some e ← applySharingLimitsFlag p then + p.printError s!"error: {e}" + return 1 let some path := p.positionalArg? "path" | p.printError "error: must specify to a Lean source file" @@ -258,6 +274,7 @@ def compileCmd : Cli.Cmd := `[Cli| "json-name" : String; "Row key for the --json row (default: the input file's stem, e.g. `CompileInitStd`)" "allow-partial" ; "Serialize the grounded subset and exit 0 even when some requested constants fail to compile. Default is fail-closed: any ungrounded constant means a nonzero exit and NO output file." anon ; "Strict-anonymous output: clear §4 names, §5 metadata, and §6 commitments (after hint finalization, so §3 anon hints survive). The env root is unchanged — it covers §2 only. Default keeps names: they are harmless to catalog semantics and valuable for fidelity/debugging." + "sharing-limits" : String; "Override resource limits of the canonical sharing construction: comma-separated key=value items (values: digits, 2^k or max) or `unbounded`. Keys: expr_visits, depth, nodes, states, transitions, cost_evals, output_bytes, materialize, materialize_work, knapsack_cells (Lean); input_nodes, distinct_nodes, height, candidates, states, layer_states, transitions, work, output_bytes, knapsack_cells (Rust). The defaults are far above every corpus maximum; a constant that reaches one fails to compile and names the limit. Sets IX_SHARING_LIMITS." report : String; "Write a machine-readable JSON compile report (versions, seed spec, requested/named/unique-anon/ungrounded counts, full ungrounded list, canonical consts merkle root, bytes, elapsed ms) to this path — written on success, fail-closed abort, and partial publish alike." ARGS: diff --git a/Ix/Cli/CompileLeanCmd.lean b/Ix/Cli/CompileLeanCmd.lean index a08fb4736..2464d4ada 100644 --- a/Ix/Cli/CompileLeanCmd.lean +++ b/Ix/Cli/CompileLeanCmd.lean @@ -25,6 +25,7 @@ public import Ix.Meta public import Ix.CompileM public import Ix.CompileDriver public import Ix.Cli.ValidateCmd +public import Ix.Cli.CompileCmd public section open System (FilePath) @@ -45,6 +46,9 @@ def runCompileLeanCmd (p : Cli.Parsed) : IO UInt32 := do let workers := match p.flag? "workers" with | some f => max 1 (f.as! Nat) | none => 32 + if let some e ← applySharingLimitsFlag p then + p.printError s!"error: {e}" + return 2 IO.println s!"[compile-lean] building {pathStr}..." buildFile pathStr @@ -116,6 +120,7 @@ def compileLeanCmd : Cli.Cmd := `[Cli| workers : Nat; "Worker count for the parallel phases (default 32)" "rust-check" ; "Also compile via the Rust FFI compiler and byte-compare the outputs (the ALIGNED gate); exit 1 on divergence" "allow-partial" ; "Serialize the grounded subset and exit 0 even when some constants fail to compile. Default is fail-closed: any block failure means a nonzero exit and NO output file." + "sharing-limits" : String; "Override resource limits of the canonical sharing construction (same format as `ix compile --sharing-limits`); applies to the Lean compile and to --rust-check. Sets IX_SHARING_LIMITS." ARGS: ...path : String; "Path to the Lean source file to compile." diff --git a/Ix/Compile/Verify/Audit/CompiledCode.lean b/Ix/Compile/Verify/Audit/CompiledCode.lean new file mode 100644 index 000000000..87d216cf0 --- /dev/null +++ b/Ix/Compile/Verify/Audit/CompiledCode.lean @@ -0,0 +1,107 @@ +import Lean.Compiler.CSimpAttr +import Lean.Compiler.ImplementedByAttr +import Lean.Compiler.ExternAttr +import Ix.CompileM +import Ix.Compile.Verify.Audit.Statements + +/-! +# Compiled-code replacements on the compiler's path + +A `@[csimp]` theorem `@f = @g` makes compiled code call `g` wherever it calls +`f`, while every theorem keeps talking about `f`. The compiler (`Ix.CompileM` +and everything it imports) therefore runs a body that only the csimp theorem +ties to its specification, so that theorem must be checked like any other +claim: every csimp theorem declared in an `Ix` module on the compiler's +import path must be a root of the statement manifest +(`Ix.Compile.Verify.Audit.Statements.roots`), whose check fixes its axioms +exactly and rejects `sorryAx`. The theorems are read from the environment's +csimp extension, not from a hand-kept list, so a new unregistered one fails +this module. + +The sharing core (`Ix.Sharing.*`) may replace a compiled body in no other +way: none of its declarations is `unsafe`, `partial`, `@[implemented_by]` or +`@[extern]`, except the items of `acceptedUnsafe`. The `_unsafe_rec` +definitions Lean generates to compile well-founded recursion are the +compiler's own translation of a checked definition, not replacements, and are +skipped. +-/ + +open Lean Lean.Elab.Command + +namespace Ix.Compile.Verify.Audit.CompiledCode + +/-- The accepted unsafe items of `Ix.Sharing.*`, by the declaration they come +from: the interner's pointer-cache key `exprPtr` (`unsafe ptrAddrUnsafe`). +Logically it is an arbitrary function of the expression; no theorem inspects +it, so every theorem holds for the address map of any run. -/ +def acceptedUnsafe : Array Lean.Name := #[``Ix.Sharing.Exact.exprPtr] + +/-- The modules `root` imports, transitively, and `root` itself. -/ +def importClosure (env : Lean.Environment) (root : Lean.Name) : Lean.NameSet := Id.run do + let names := env.header.moduleNames + let mut index : Std.HashMap Lean.Name Nat := {} + for h : i in [0:names.size] do + index := index.insert names[i] i + let mut seen : Lean.NameSet := {} + let mut stack := #[root] + while !stack.isEmpty do + let m := stack.back! + stack := stack.pop + if seen.contains m then continue + seen := seen.insert m + if let some i := index[m]? then + for imp in env.header.moduleData[i]!.imports do + unless seen.contains imp.module do stack := stack.push imp.module + return seen + +def moduleOf? (env : Lean.Environment) (name : Lean.Name) : Option Lean.Name := + (env.getModuleIdxFor? name).map fun idx => env.header.moduleNames[idx.toNat]! + +def checkCSimpRoots : CommandElabM Unit := do + let env ← getEnv + let compiler := importClosure env `Ix.CompileM + let registered : Lean.NameSet := + Statements.roots.foldl (fun s a => s.insert a.root) {} + let thms := ((Lean.Compiler.CSimp.ext.getState env).thmNames.toList.filter fun n => + match moduleOf? env n with + | some mod => (`Ix).isPrefixOf mod && compiler.contains mod + | none => false).toArray.qsort Lean.Name.lt + let missing := thms.filter (!registered.contains ·) + unless missing.isEmpty do + throwError m!"{missing.size} @[csimp] theorem(s) on the compiler's import path are not \ + roots of Ix.Compile.Verify.Audit.Statements:\n\ + {String.intercalate "\n" (missing.toList.map (s!" {·}"))}" + logInfo m!"compiled-code audit: all {thms.size} @[csimp] theorems of Ix modules on the \ + compiler's import path are audit roots" + +def checkSharingReplacements : CommandElabM Unit := do + let env ← getEnv + let accepted (n : Lean.Name) : Bool := + acceptedUnsafe.any fun a => a.isPrefixOf (privateToUserName n) + let mut flagged : Array String := #[] + let mut acceptedItems : Array Lean.Name := #[] + for (name, info) in env.constants.toList do + let some mod := moduleOf? env name | continue + unless (`Ix.Sharing).isPrefixOf mod do continue + let generatedRec := name.isStr && name.getString! == "_unsafe_rec" && + match env.find? name.getPrefix with + | some (.defnInfo _) => + (Lean.Compiler.implementedByAttr.getParam? env name.getPrefix).isNone + | _ => false + let impl := (Lean.Compiler.implementedByAttr.getParam? env name).isSome + let ext := Lean.isExtern env name + let replaces := impl || ext || info.isUnsafe || (info.isPartial && !generatedRec) + if replaces then + if accepted name then acceptedItems := acceptedItems.push name + else flagged := flagged.push s!" {mod} :: {name}" + unless flagged.isEmpty do + throwError m!"{flagged.size} unsafe, partial, implemented_by or extern declaration(s) in \ + Ix.Sharing.* outside the accepted list:\n{String.intercalate "\n" flagged.toList}" + let sortedAccepted := acceptedItems.qsort Lean.Name.lt + logInfo m!"compiled-code audit: Ix.Sharing.* replaces no compiled body except the accepted \ + {sortedAccepted.size} item(s) of {acceptedUnsafe}: {sortedAccepted}" + +run_cmd checkCSimpRoots +run_cmd checkSharingReplacements + +end Ix.Compile.Verify.Audit.CompiledCode diff --git a/Ix/Compile/Verify/Audit/SorryFrontier.lean b/Ix/Compile/Verify/Audit/SorryFrontier.lean index db3ee1f65..5b54c01c5 100644 --- a/Ix/Compile/Verify/Audit/SorryFrontier.lean +++ b/Ix/Compile/Verify/Audit/SorryFrontier.lean @@ -1,12 +1,14 @@ import Ix.Compile.Verify.Audit.Statements +import Ix.CompileM /-! -# Compiler-verification source sorry frontier +# Compiler-verification and sharing-core source sorry frontier -Fail the build if any declaration emitted from an `Ix.Compile.Verify` source -module directly references `sorryAx`. Upstream Lean4Lean debt is handled by -per-root transitive manifests rather than being confused with local source -placeholders. +Fail the build if any declaration emitted from an `Ix.Compile.Verify` or an +`Ix.Sharing` source module (the sharing core, whose `@[csimp]` replacements +the compiler runs) directly references `sorryAx`. Upstream Lean4Lean debt is +handled by per-root transitive manifests rather than being confused with local +source placeholders. -/ open Lean Lean.Elab.Command @@ -23,6 +25,9 @@ private def directConstants : Lean.ConstantInfo → Array Lean.Name | .recInfo value => value.type.getUsedConstants | .inductInfo value => value.type.getUsedConstants ++ value.ctors +/-- The module prefixes whose source declarations must not use `sorryAx`. -/ +def sorryFreePrefixes : Array Lean.Name := #[`Ix.Compile.Verify, `Ix.Sharing] + def checkSorryFrontier : CommandElabM Unit := do let env ← getEnv let moduleNames := env.allImportedModuleNames @@ -31,7 +36,7 @@ def checkSorryFrontier : CommandElabM Unit := do | none => none | some idx => let mod := moduleNames[idx.toNat]! - if (`Ix.Compile.Verify).isPrefixOf mod && + if sorryFreePrefixes.any (·.isPrefixOf mod) && (directConstants info).contains ``sorryAx then some (mod, name) else @@ -39,11 +44,11 @@ def checkSorryFrontier : CommandElabM Unit := do let offenders := offenders.toArray.qsort fun left right => Lean.Name.lt left.1 right.1 if offenders.isEmpty then - logInfo m!"Ix.Compile.Verify sorry frontier OK: no source declaration uses sorryAx" + logInfo m!"Ix.Compile.Verify and Ix.Sharing sorry frontier OK: no source declaration uses sorryAx" else let body := String.intercalate "\n" <| offenders.toList.map fun (mod, name) => s!" {mod} :: {name}" - throwError m!"Ix.Compile.Verify sorry frontier changed — \ + throwError m!"Ix.Compile.Verify and Ix.Sharing sorry frontier changed — \ {offenders.size} declaration(s) directly use sorryAx:\n{body}" run_cmd checkSorryFrontier diff --git a/Ix/Compile/Verify/Audit/Statements.lean b/Ix/Compile/Verify/Audit/Statements.lean index 4bee84cf0..8e02e4c8d 100644 --- a/Ix/Compile/Verify/Audit/Statements.lean +++ b/Ix/Compile/Verify/Audit/Statements.lean @@ -5,10 +5,14 @@ import Ix.Compile.Verify.Statements # Trust manifest for the compiler statement frontier These roots cover the first expression-level square, concrete catalog -integrity, and the production compiler's finite-table transitions. The -explicit `KernelSourceWitness` assumption is data supplied to later theorems, -not a global axiom, and no compiler theorem may inherit checker acceptance as -a premise. +integrity, the production compiler's finite-table transitions, the TagN +codec, the sharing construction (the exact core, the uniform optimizer, the +tiered phases, the output format and the compiler's sharing builder), and +every `@[csimp]` theorem by which compiled code runs a fast body in place of +a sharing specification (`Audit.CompiledCode` fails the build if one is +missing). The explicit `KernelSourceWitness` assumption is data supplied to +later theorems, not a global axiom, and no compiler theorem may inherit +checker acceptance as a premise. -/ namespace Ix.Compile.Verify.Audit.Statements @@ -20,6 +24,10 @@ private def standard : Array Lean.Name := private def noChoice : Array Lean.Name := #[``propext, ``Quot.sound] +private def propextOnly : Array Lean.Name := #[``propext] + +private def quotOnly : Array Lean.Name := #[``Quot.sound] + private def blake3Native : Array Lean.Name := #[ nativeAxiom `Blake3 `Blake3.HasherOps.hash._native.native_decide.ax_1 @@ -33,7 +41,10 @@ private def nameNative : Array Lean.Name := #[ private def singletonDriverNative : Array Lean.Name := blake3Native ++ nameNative -private def roots : Array RootAllowance := #[ +/-- The theorem roots of the compiler statement frontier and their exact axiom +sets (`Ix.Tc.Verify.Audit.check`). `Audit.CompiledCode` also requires every +`@[csimp]` theorem on the compiler's import path to be one of them. -/ +def roots : Array RootAllowance := #[ { root := ``Ix.Compile.Verify.IxonExprRel.eraseModes_iff, standardAxioms := standard }, { root := ``Ix.Compile.Verify.compileUnivRef_value, @@ -218,7 +229,7 @@ private def roots : Array RootAllowance := #[ { root := ``Ix.Compile.Verify.BlockResult.mk'_codec_roundtrip, standardAxioms := standard, nativeAxioms := blake3Native }, { root := ``Ix.Compile.Verify.buildConstantWithSharing_wireWF, - standardAxioms := standard, nativeAxioms := blake3Native }, + standardAxioms := standard }, { root := ``Ix.Compile.Verify.BlockResult.constantInfo_codec_roundtrip, standardAxioms := standard, nativeAxioms := blake3Native }, { root := ``Ix.Compile.Verify.constantInfoRootExprs_toList, @@ -322,10 +333,6 @@ private def roots : Array RootAllowance := #[ { root := ``Ix.Compile.Verify.compileConstantInfo_constructor_default_run_ready_codecWF, standardAxioms := standard, nativeAxioms := singletonDriverNative }, - { root := ``Ix.Compile.Verify.rewriteWithSharing_wireWF, - standardAxioms := standard }, - { root := ``Ix.Compile.Verify.applySharing_wireWF, - standardAxioms := standard, nativeAxioms := blake3Native }, { root := ``Ix.Compile.Verify.compileExpr_run_ordinary_axiomBlock_noSharing_roundtrip, standardAxioms := standard, nativeAxioms := blake3Native }, @@ -346,9 +353,245 @@ private def roots : Array RootAllowance := #[ { root := ``Ix.Compile.Verify.compileExpr_run_ordinary_arena_refines, standardAxioms := standard, nativeAxioms := blake3Native }, { root := ``Ix.Compile.Verify.compileExpr_run_ordinary_arena_value, - standardAxioms := standard, nativeAxioms := blake3Native } + standardAxioms := standard, nativeAxioms := blake3Native }, + { root := ``Ix.Compile.Verify.TagN.runGetExact_getTagN_eq, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.TagN.putTagN_inj, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.TagN.getTagN_rejects_code, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.TagN.getTagN_rejects_overflow, + standardAxioms := noChoice }, + -- The TagN bijection (a read succeeds exactly on the written bytes) and the + -- length decomposition of a serialized Constant that the docs cite. + { root := ``Ix.Compile.Verify.TagN.runGetExact_getTagN_iff, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.TagN.runGetExact_getTagN_inj, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.SharingExact.serConstant_size_decomposition, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.SharingExact.materializeWith_correct, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.SharingExact.materializeTable_correct, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.SharingExact.materializeDependent_correct, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.SharingExact.canonicalize_det, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.optimizeUniform_modelBytes, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.optimizeUniform_variableBytes, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.PrepWF.uniformCost_le, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.UniformModel.PrepWF.uniformCost_attained, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.uniformCost_insert_le, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.uniformCost_insert_le_counts, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.stored_in_minimum, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.excluded_of_minimum, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.classify_sound, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.threshold_one_sound, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.tag0Size_succ_le, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.UniformModel.tag4Size_add_le, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.UniformModel.tag4Size_not_subadditive_at_end, + standardAxioms := #[] }, + { root := ``Ix.Compile.Verify.UniformModel.PrepWF.uCost_local, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.PrepWF.uCost_modular, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.uniformCost_modular, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.components_modular, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.certainStored_opaque, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.lower_bound_sound, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.componentsChecked_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.optimizeUniform_reach, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.reachLabelsOn_allows, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.mem_upClosure, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.sepCheck_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.evalFold_rows, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.UniformModel.entry_inl, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.phiE_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.optimizeUniform_minimum, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.uniformChoose_model_le, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.Env.search_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.Env.component_table, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.uniformKnapsack_le, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.compEnv_wf, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.ulen_compParts, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.group_rep, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.group_modular, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.forced_mem, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.revisible_le, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.ulen_split_component, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.minimum_exists, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.optimizeUniform_least, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.uniformChoose_tie, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.uniformKnapsack_tie, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.knapFold_tie, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.conv_tie, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.lexLt_iff, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.UniformModel.precL_union, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.UniformModel.bestSetOf_spec, + standardAxioms := standard }, + -- Compiled component search (`@[csimp]`): the loop of `searchComponents` + -- runs the area- and closure-local search. + { root := ``Ix.Sharing.Exact.searchComponents_eq_via, + standardAxioms := noChoice }, + { root := ``Ix.Sharing.Exact.searchComponentsWith_eq_fast, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.canonicalTieredCore_select, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.tieredAtWidth_parts, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.tierClosures_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.tierDfs_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.firstTier_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.allocate_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.tierWeights_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.tierDeps_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.PrepWF.gValid_cost, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.UniformModel.PrepWF.gExists_opt, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.PrepWF.gBuild_size, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.gCost_local, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.UniformModel.evalUp_ok, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.Tiered.materializeTable_spec, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.materializeTable_min, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.rematerialize_spec, + standardAxioms := standard }, + -- Phase-3 compiled-code replacements (`@[csimp]`): compiled code runs the + -- right-hand side wherever the specification on the left is called. + { root := ``Ix.Sharing.Exact.materializeTable_eq_fast, + standardAxioms := standard }, + { root := ``Ix.Sharing.Exact.build_eq_fast, + standardAxioms := noChoice }, + { root := ``Ix.Sharing.Exact.inlineCost_eq_fast, + standardAxioms := noChoice }, + { root := ``Ix.Sharing.Exact.reexpand_eq_fast, + standardAxioms := standard }, + -- For the wire layout the length the tiered construction reports is the + -- serialized length of its output. + { root := ``Ix.Compile.Verify.Tiered.canonicalSharingTiered_serialized, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.canonicalSharingTieredTable_serialized, + standardAxioms := standard }, + -- Phase 3 materializes the table from one evaluation of the whole + -- dictionary when the order allows it (`rematerialize` changed; equal to + -- `materializeTable` on every input, errors and limits included). + { root := ``Ix.Compile.Verify.Tiered.materializeTableOnePass_eq, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.canonicalTiered_core, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.canonicalTiered_det, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.canonicalTiered_reexpand, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.canonicalSharingTieredTable_idem, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.wireCounts_spec, + standardAxioms := propextOnly }, + { root := ``Ix.Compile.Verify.Tiered.canonicalTiered_format, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.canonicalSharingTiered_format, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.canonicalSharingTieredTable_format, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.PrepWF.gBuild_tree, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.UniformModel.WTree.gcost_eq, + standardAxioms := noChoice }, + { root := ``Ix.Compile.Verify.Tiered.phase3_le_phase1, + standardAxioms := standard }, + { root := ``Ix.Compile.Verify.Tiered.allocate_optimal, + standardAxioms := standard }, + -- Compiled tiered construction (`@[csimp]`, `Ix.Sharing.Exact.TierFast`, + -- `Ix.Sharing.Exact.PinnedDeps`, `Ix.Sharing.Exact.PinnedFast`, + -- `Ix.Sharing.Exact.KnapsackFast` and + -- `Ix.Sharing.Exact.TieredFast`). + { root := ``Ix.Sharing.Exact.firstTier_eq_fast, + standardAxioms := standard }, + { root := ``Ix.Sharing.Exact.pinnedDeps_eq_fast, + standardAxioms := standard }, + { root := ``Ix.Sharing.Exact.pinnedOrder_eq_fast, + standardAxioms := standard }, + { root := ``Ix.Sharing.Exact.uniformKnapsack_eq_fast, + standardAxioms := standard }, + { root := ``Ix.Sharing.Exact.allocate_eq_C, + standardAxioms := standard }, + { root := ``Ix.Sharing.Exact.tieredAtWidth_eq_C, + standardAxioms := standard }, + { root := ``Ix.Sharing.Exact.canonicalTieredCore_eq_C, + standardAxioms := standard }, + { root := ``Ix.Sharing.Exact.optimizeUniformExpanded_eq_C, + standardAxioms := standard }, + { root := ``Ix.Sharing.Exact.canonicalTieredExpanded_eq_C, + standardAxioms := standard }, + -- Compiled-code replacements (`@[csimp]`): compiled code runs the + -- right-hand side wherever the specification on the left is called. + { root := ``Ix.Sharing.Exact.tagNByteWidth_eq_fast, + standardAxioms := quotOnly }, + { root := ``Ix.Sharing.Exact.propagateCounts_eq_fast, + standardAxioms := noChoice }, + { root := ``Ix.Sharing.Exact.SCtx.phiE_eq_fast, + standardAxioms := noChoice }, + { root := ``Ix.Sharing.Exact.csBase_eq_fast, + standardAxioms := noChoice } ] + run_cmd Ix.Tc.Verify.Audit.check roots end Ix.Compile.Verify.Audit.Statements diff --git a/Ix/Compile/Verify/Codec.lean b/Ix/Compile/Verify/Codec.lean index dea03362f..0e71ae373 100644 --- a/Ix/Compile/Verify/Codec.lean +++ b/Ix/Compile/Verify/Codec.lean @@ -2,12 +2,12 @@ import Ix.Ixon import Std.Tactic.BVDecide /-! -# Proof-visible v3 codecs +# Proof-visible Ixon codecs These X1 slices make universe serialization kernel-visible end to end. `Reads` records exact cursor movement in arbitrary surrounding bytes, while `Writes` records append-only writer behavior. The public theorem covers both -the one-byte and trimmed 1–8-byte `Tag2` forms, subject only to the format's +every TagN (`f = 2`) rung, subject only to the format's necessary `UInt64` bound on compressed successor chains. The smaller theorem for `Sort 1` remains as a compatibility corollary. -/ @@ -142,45 +142,6 @@ private theorem uint64_cases32 (size : UInt64) (h : size < 32) : UInt64.toNat_ofNat] at h ⊢ omega -theorem tag2_small_fields (flag : UInt8) (size : UInt64) - (hflag : flag < 4) (hsize : size < 32) : - (((flag <<< 6) ||| size.toUInt8) >>> 6) = flag ∧ - (((flag <<< 6) ||| size.toUInt8) &&& 0x20) = 0 ∧ - ((((flag <<< 6) ||| size.toUInt8) &&& 0x1f).toUInt64) = size := by - rcases uint8_cases4 flag hflag with rfl | rfl | rfl | rfl <;> - rcases uint64_cases32 size hsize 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 <;> - decide - -theorem getTag2_reads_small (flag : UInt8) (size : UInt64) - (hflag : flag < 4) (hsize : size < 32) : - Reads Ixon.getTag2 - [((flag <<< 6) ||| size.toUInt8)].toByteArray - ⟨flag, size⟩ := by - intro before after - unfold Ixon.getTag2 - change (EStateM.bind Ixon.getU8 _) _ = _ - rw [EStateM.bind, getU8_reads _ before after] - obtain ⟨hdecodedFlag, hlarge, hdecodedSize⟩ := - tag2_small_fields flag size hflag hsize - simp only [hdecodedFlag, hlarge] - change (EStateM.bind (EStateM.pure _) _) _ = _ - simp only [EStateM.bind, EStateM.pure] - change (EStateM.pure _) _ = _ - simp [EStateM.pure, hdecodedSize] - -theorem runPut_putTag2_small (flag : UInt8) (size : UInt64) - (hsize : size < 32) : - Ixon.runPut (Ixon.putTag2 ⟨flag, size⟩) = - [((flag <<< 6) ||| size.toUInt8)].toByteArray := by - simp [Ixon.runPut, Ixon.putTag2, hsize, Ixon.putU8, - StateT.run, StateT.modifyGet] - change ByteArray.empty.push _ = _ - rfl - theorem putU8_writes (byte : UInt8) : Writes (Ixon.putU8 byte) [byte].toByteArray := by intro before @@ -190,14 +151,6 @@ theorem putU8_writes (byte : UInt8) : change ((), before.push byte) = _ rfl -theorem putTag2_writes_small (flag : UInt8) (size : UInt64) - (hsize : size < 32) : - Writes (Ixon.putTag2 ⟨flag, size⟩) - [((flag <<< 6) ||| size.toUInt8)].toByteArray := by - unfold Ixon.putTag2 - rw [if_pos hsize] - exact putU8_writes _ - /-- Splitting off the low byte and shifting the remainder back reconstructs the original word. This is the arithmetic core of trimmed decoding. -/ theorem uint64_lowByte_or_shifted (x : UInt64) : @@ -247,47 +200,6 @@ theorem shiftBytes_eq_zero_of_lt (x : UInt64) (len : Nat) simp only [shiftBytes_toNat, UInt64.reduceToNat] exact Nat.shiftRight_eq_zero _ _ h -/-- The production byte count is sufficient to hold the complete word. -/ -theorem u64ByteCount_fits (x : UInt64) : - x.toNat < 2 ^ (8 * (Ixon.u64ByteCount x).toNat) := by - unfold Ixon.u64ByteCount - split <;> rename_i hzero - · simp_all - split <;> rename_i h1 - · simpa [UInt64.lt_iff_toNat_lt] using h1 - split <;> rename_i h2 - · simpa [UInt64.lt_iff_toNat_lt] using h2 - split <;> rename_i h3 - · simpa [UInt64.lt_iff_toNat_lt] using h3 - split <;> rename_i h4 - · simpa [UInt64.lt_iff_toNat_lt] using h4 - split <;> rename_i h5 - · simpa [UInt64.lt_iff_toNat_lt] using h5 - split <;> rename_i h6 - · simpa [UInt64.lt_iff_toNat_lt] using h6 - split <;> rename_i h7 - · simpa [UInt64.lt_iff_toNat_lt] using h7 - simpa using x.toNat_lt - -theorem u64ByteCount_toNat_le (x : UInt64) : - (Ixon.u64ByteCount x).toNat ≤ 8 := by - unfold Ixon.u64ByteCount - split - · decide - split - · decide - split - · decide - split - · decide - split - · decide - split - · decide - split - · decide - split <;> decide - theorem Writes.pure : Writes (pure () : Ixon.PutM Unit) ByteArray.empty := by intro before @@ -304,12 +216,6 @@ theorem putU64TrimmedLEAux_writes (x : UInt64) (len : Nat) : simpa [Ixon.putU64TrimmedLEAux, trimmedBytes] using (putU8_writes x.toUInt8).bind (ih (x >>> 8)) -theorem putU64TrimmedLE_writes (x : UInt64) : - Writes (Ixon.putU64TrimmedLE x) - (trimmedBytes x (Ixon.u64ByteCount x).toNat) := by - simpa [Ixon.putU64TrimmedLE] using - putU64TrimmedLEAux_writes x (Ixon.u64ByteCount x).toNat - theorem getU64TrimmedLEAux_reads (x : UInt64) (len : Nat) (hshift : shiftBytes x len = 0) : Reads (Ixon.getU64TrimmedLEAux len) (trimmedBytes x len) x := by @@ -344,568 +250,290 @@ theorem getU64TrimmedLEAux_reads (x : UInt64) (len : Nat) (getU8_reads x.toUInt8) hafterHigh simpa [Ixon.getU64TrimmedLEAux, trimmedBytes] using hall -theorem getU64TrimmedLE_reads (x : UInt64) : - Reads (Ixon.getU64TrimmedLE (Ixon.u64ByteCount x).toNat) - (trimmedBytes x (Ixon.u64ByteCount x).toNat) x := by - have hlen := u64ByteCount_toNat_le x - have hshift := shiftBytes_eq_zero_of_lt x - (Ixon.u64ByteCount x).toNat (u64ByteCount_fits x) - unfold Ixon.getU64TrimmedLE - rw [if_neg (by omega)] - exact getU64TrimmedLEAux_reads x _ hshift - -private theorem uint8_cases1_8 (count : UInt8) - (hpos : 0 < count.toNat) (hle : count.toNat ≤ 8) : - count = 1 ∨ count = 2 ∨ count = 3 ∨ count = 4 ∨ - count = 5 ∨ count = 6 ∨ count = 7 ∨ count = 8 := by - simp only [← UInt8.toNat_inj, UInt8.toNat_ofNat] at ⊢ - omega +/-! ## Writer -/ + +/-- The bytes written by `putTagN`. -/ +def tagNBytes (f : Nat) (flag : UInt8) (value : UInt64) : ByteArray := + let v := value.toNat + let lead := 2 ^ (8 - f - 1) + let mbit := 2 ^ (8 - f - 2) + if v < Ixon.tagNEnd1 f then + [Ixon.tagNHeader f flag v].toByteArray + else if v < Ixon.tagNEnd2 f then + [Ixon.tagNHeader f flag (lead + (v - Ixon.tagNEnd1 f) / 256)].toByteArray ++ + [((v - Ixon.tagNEnd1 f) % 256).toUInt8].toByteArray + else if v < Ixon.tagNEnd3 f then + [Ixon.tagNHeader f flag (lead + mbit)].toByteArray ++ + trimmedBytes (v - Ixon.tagNEnd2 f).toUInt64 2 + else if v < Ixon.tagNEnd4 f then + [Ixon.tagNHeader f flag (lead + mbit + 1)].toByteArray ++ + trimmedBytes (v - Ixon.tagNEnd3 f).toUInt64 3 + else if v < Ixon.tagNEnd5 f then + [Ixon.tagNHeader f flag (lead + mbit + 2)].toByteArray ++ + trimmedBytes (v - Ixon.tagNEnd4 f).toUInt64 4 + else + [Ixon.tagNHeader f flag (lead + mbit + 3)].toByteArray ++ + trimmedBytes (v - Ixon.tagNEnd5 f).toUInt64 8 + +theorem putTagN_writes (f : Nat) (flag : UInt8) (value : UInt64) : + Writes (Ixon.putTagN f flag value) (tagNBytes f flag value) := by + unfold Ixon.putTagN tagNBytes + simp only + by_cases h1 : value.toNat < Ixon.tagNEnd1 f + · simp only [h1, ↓reduceIte] + exact putU8_writes _ + by_cases h2 : value.toNat < Ixon.tagNEnd2 f + · simp only [h1, h2, ↓reduceIte] + exact (putU8_writes _).bind (putU8_writes _) + by_cases h3 : value.toNat < Ixon.tagNEnd3 f + · simp only [h1, h2, h3, ↓reduceIte] + exact (putU8_writes _).bind (putU64TrimmedLEAux_writes _ _) + by_cases h4 : value.toNat < Ixon.tagNEnd4 f + · simp only [h1, h2, h3, h4, ↓reduceIte] + exact (putU8_writes _).bind (putU64TrimmedLEAux_writes _ _) + by_cases h5 : value.toNat < Ixon.tagNEnd5 f + · simp only [h1, h2, h3, h4, h5, ↓reduceIte] + exact (putU8_writes _).bind (putU64TrimmedLEAux_writes _ _) + · simp only [h1, h2, h3, h4, h5, ↓reduceIte] + exact (putU8_writes _).bind (putU64TrimmedLEAux_writes _ _) + +theorem runPut_putTagN (f : Nat) (flag : UInt8) (value : UInt64) : + Ixon.runPut (Ixon.putTagN f flag value) = tagNBytes f flag value := + (putTagN_writes f flag value).runPut + +theorem trimmedBytes_size (x : UInt64) (len : Nat) : (trimmedBytes x len).size = len := by + induction len generalizing x with + | zero => rfl + | succ len ih => simp [trimmedBytes, ih]; omega + +/-- The encoded length is the TagN width function. -/ +theorem tagNBytes_size (f : Nat) (flag : UInt8) (value : UInt64) : + (tagNBytes f flag value).size = Ixon.tagNByteWidth f value.toNat := by + unfold tagNBytes Ixon.tagNByteWidth + simp only + repeat' split + all_goals simp [trimmedBytes_size] + +theorem tagNBytes_size_pos (f : Nat) (flag : UInt8) (value : UInt64) : + 0 < (tagNBytes f flag value).size := by + rw [tagNBytes_size] + unfold Ixon.tagNByteWidth + repeat' split + all_goals omega + +theorem runPut_putTagN_size (f : Nat) (flag : UInt8) (value : UInt64) : + (Ixon.runPut (Ixon.putTagN f flag value)).size = + Ixon.tagNByteWidth f value.toNat := by + rw [runPut_putTagN, tagNBytes_size] + +/-! ## Header arithmetic -/ + +/-- The constants of the supported flag widths, as linear facts. -/ +theorem tagN_consts (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) : + 2 ^ (8 - f) = 2 * 2 ^ (8 - f - 1) ∧ 2 ^ (8 - f - 1) = 2 * 2 ^ (8 - f - 2) ∧ + 4 ≤ 2 ^ (8 - f - 2) ∧ Ixon.tagNEnd1 f = 2 ^ (8 - f - 1) ∧ + Ixon.tagNEnd2 f = Ixon.tagNEnd1 f + 2 ^ (8 - f - 2) * 256 ∧ + Ixon.tagNEnd3 f = Ixon.tagNEnd2 f + 65536 ∧ + Ixon.tagNEnd4 f = Ixon.tagNEnd3 f + 16777216 ∧ + Ixon.tagNEnd5 f = Ixon.tagNEnd4 f + 4294967296 ∧ + Ixon.tagNEnd5 f < 2 ^ 33 := by + rcases hf with rfl | rfl | rfl <;> decide + +theorem tagNHeader_fields (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) (flag : UInt8) + (hflag : flag.toNat < 2 ^ f) (payload : Nat) (hp : payload < 2 ^ (8 - f)) : + (Ixon.tagNHeader f flag payload).toNat / 2 ^ (8 - f) = flag.toNat ∧ + (Ixon.tagNHeader f flag payload).toNat % 2 ^ (8 - f) = payload := by + have key : ∀ n : Nat, (n.toUInt8).toNat = n % 256 := fun n => by simp + unfold Ixon.tagNHeader + rw [key] + rcases hf with rfl | rfl | rfl <;> + simp only [Nat.reduceSub, Nat.reducePow] at hflag hp ⊢ <;> + constructor <;> omega + +/-! ## Reads -/ + +theorem Reads.pure_of_eq {a b : α} (h : a = b) : + Reads (Pure.pure a : Ixon.GetM α) ByteArray.empty b := by + subst h + exact Reads.pure a + +theorem tagN_mk_eq {flag : UInt8} {value : UInt64} {n m : Nat} + (hn : n = flag.toNat) (hm : m = value.toNat) : + (⟨n.toUInt8, m.toUInt64⟩ : Ixon.TagN) = ⟨flag, value⟩ := by + subst hn hm + simp -theorem tag2_large_fields (flag byteCount : UInt8) - (hflag : flag < 4) (hpos : 0 < byteCount.toNat) - (hle : byteCount.toNat ≤ 8) : - let header := (flag <<< 6) ||| 0x20 ||| (byteCount - 1) - header >>> 6 = flag ∧ - header &&& 0x20 = 0x20 ∧ - (header &&& 0x1f).toNat + 1 = byteCount.toNat ∧ - (header &&& 0x1f) + 1 = byteCount := by - rcases uint8_cases4 flag hflag with rfl | rfl | rfl | rfl <;> - rcases uint8_cases1_8 byteCount hpos hle with - rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> - decide +/-- `getTagN` reads the bytes of `putTagN` back, in any surrounding input. -/ +theorem getTagN_reads (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) (flag : UInt8) + (hflag : flag.toNat < 2 ^ f) (value : UInt64) : + Reads (Ixon.getTagN f) (tagNBytes f flag value) ⟨flag, value⟩ := by + obtain ⟨hR, hlead, hmbit, hE1, hE2, hE3, hE4, hE5, hE5lt⟩ := tagN_consts f hf + have hv := value.toNat_lt + unfold tagNBytes Ixon.getTagN + simp only + by_cases h1 : value.toNat < Ixon.tagNEnd1 f + · rw [if_pos h1, ← ByteArray.append_empty (b := [_].toByteArray)] + refine Reads.bind (getU8_reads _) ?_ + obtain ⟨hdiv, hmod⟩ := tagNHeader_fields f hf flag hflag value.toNat (by omega) + simp only [hdiv, hmod] + rw [if_pos (by omega)] + exact Reads.pure_of_eq (tagN_mk_eq rfl rfl) + by_cases h2 : value.toNat < Ixon.tagNEnd2 f + · rw [if_neg h1, if_pos h2] + refine Reads.bind (getU8_reads _) ?_ + obtain ⟨hdiv, hmod⟩ := tagNHeader_fields f hf flag hflag + (2 ^ (8 - f - 1) + (value.toNat - Ixon.tagNEnd1 f) / 256) (by omega) + simp only [hdiv, hmod] + rw [if_neg (by omega), if_pos (by omega), ← ByteArray.append_empty (b := [_].toByteArray)] + refine Reads.bind (getU8_reads _) ?_ + exact Reads.pure_of_eq (tagN_mk_eq rfl (by simp; omega)) + by_cases h3 : value.toNat < Ixon.tagNEnd3 f + · rw [if_neg h1, if_neg h2, if_pos h3] + refine Reads.bind (getU8_reads _) ?_ + obtain ⟨hdiv, hmod⟩ := tagNHeader_fields f hf flag hflag + (2 ^ (8 - f - 1) + 2 ^ (8 - f - 2)) (by omega) + simp only [hdiv, hmod] + rw [if_neg (by omega), if_neg (by omega)] + unfold Ixon.getTagNWide + rw [if_pos (by omega), ← ByteArray.append_empty (b := trimmedBytes _ _)] + have hx : ((value.toNat - Ixon.tagNEnd2 f).toUInt64).toNat = + value.toNat - Ixon.tagNEnd2 f := by simp; omega + refine Reads.bind (getU64TrimmedLEAux_reads _ 2 + (shiftBytes_eq_zero_of_lt _ _ (by rw [hx]; omega))) ?_ + exact Reads.pure_of_eq (tagN_mk_eq rfl (by rw [hx]; omega)) + by_cases h4 : value.toNat < Ixon.tagNEnd4 f + · rw [if_neg h1, if_neg h2, if_neg h3, if_pos h4] + refine Reads.bind (getU8_reads _) ?_ + obtain ⟨hdiv, hmod⟩ := tagNHeader_fields f hf flag hflag + (2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) + 1) (by omega) + simp only [hdiv, hmod] + rw [if_neg (by omega), if_neg (by omega)] + unfold Ixon.getTagNWide + rw [if_neg (by omega), if_pos (by omega), + ← ByteArray.append_empty (b := trimmedBytes _ _)] + have hx : ((value.toNat - Ixon.tagNEnd3 f).toUInt64).toNat = + value.toNat - Ixon.tagNEnd3 f := by simp; omega + refine Reads.bind (getU64TrimmedLEAux_reads _ 3 + (shiftBytes_eq_zero_of_lt _ _ (by rw [hx]; omega))) ?_ + exact Reads.pure_of_eq (tagN_mk_eq rfl (by rw [hx]; omega)) + by_cases h5 : value.toNat < Ixon.tagNEnd5 f + · rw [if_neg h1, if_neg h2, if_neg h3, if_neg h4, if_pos h5] + refine Reads.bind (getU8_reads _) ?_ + obtain ⟨hdiv, hmod⟩ := tagNHeader_fields f hf flag hflag + (2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) + 2) (by omega) + simp only [hdiv, hmod] + rw [if_neg (by omega), if_neg (by omega)] + unfold Ixon.getTagNWide + rw [if_neg (by omega), if_neg (by omega), if_pos (by omega), + ← ByteArray.append_empty (b := trimmedBytes _ _)] + have hx : ((value.toNat - Ixon.tagNEnd4 f).toUInt64).toNat = + value.toNat - Ixon.tagNEnd4 f := by simp; omega + refine Reads.bind (getU64TrimmedLEAux_reads _ 4 + (shiftBytes_eq_zero_of_lt _ _ (by rw [hx]; omega))) ?_ + exact Reads.pure_of_eq (tagN_mk_eq rfl (by rw [hx]; omega)) + · rw [if_neg h1, if_neg h2, if_neg h3, if_neg h4, if_neg h5] + refine Reads.bind (getU8_reads _) ?_ + obtain ⟨hdiv, hmod⟩ := tagNHeader_fields f hf flag hflag + (2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) + 3) (by omega) + simp only [hdiv, hmod] + rw [if_neg (by omega), if_neg (by omega)] + unfold Ixon.getTagNWide + rw [if_neg (by omega), if_neg (by omega), if_neg (by omega), if_pos (by omega), + ← ByteArray.append_empty (b := trimmedBytes _ _)] + have hx : ((value.toNat - Ixon.tagNEnd5 f).toUInt64).toNat = + value.toNat - Ixon.tagNEnd5 f := by simp; omega + refine Reads.bind (getU64TrimmedLEAux_reads _ 8 + (shiftBytes_eq_zero_of_lt _ _ (by rw [hx]; omega))) ?_ + rw [if_pos (by rw [hx]; omega)] + exact Reads.pure_of_eq (tagN_mk_eq rfl (by rw [hx]; omega)) + +/-- A read law gives the exact full-buffer decode. -/ +theorem Reads.runGetExact {getm : Ixon.GetM α} {bytes : ByteArray} {value : α} + (h : Reads getm bytes value) : Ixon.runGetExact getm bytes = .ok value := by + have hread := h ByteArray.empty ByteArray.empty + simp only [ByteArray.empty_append, ByteArray.append_empty, + ByteArray.size_empty, Nat.zero_add] at hread + unfold Ixon.runGetExact + change EStateM.run getm { bytes := bytes } = _ at hread + rw [hread] + simp -/-- Exact bytes emitted by a production `Tag2`, including its trimmed - large-size payload. -/ -def tag2Bytes (flag : UInt8) (size : UInt64) : ByteArray := - if size < 32 then - [((flag <<< 6) ||| size.toUInt8)].toByteArray - else - let byteCount := Ixon.u64ByteCount size - [((flag <<< 6) ||| 0x20 ||| (byteCount - 1))].toByteArray ++ - trimmedBytes size byteCount.toNat +/-- Exact roundtrip of the TagN code. -/ +theorem runGetExact_getTagN_putTagN (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) + (flag : UInt8) (hflag : flag.toNat < 2 ^ f) (value : UInt64) : + Ixon.runGetExact (Ixon.getTagN f) (Ixon.runPut (Ixon.putTagN f flag value)) = + .ok ⟨flag, value⟩ := by + rw [runPut_putTagN] + exact Reads.runGetExact (getTagN_reads f hf flag hflag value) -theorem putTag2_writes (flag : UInt8) (size : UInt64) : - Writes (Ixon.putTag2 ⟨flag, size⟩) (tag2Bytes flag size) := by - unfold Ixon.putTag2 tag2Bytes - split <;> rename_i hsize - · exact putU8_writes _ - · exact (putU8_writes _).bind (putU64TrimmedLE_writes size) - -theorem getTag2_reads_large (flag : UInt8) (size : UInt64) - (hflag : flag < 4) (hsize : ¬ size < 32) : - Reads Ixon.getTag2 (tag2Bytes flag size) ⟨flag, size⟩ := by - let byteCount := Ixon.u64ByteCount size - let header := (flag <<< 6) ||| 0x20 ||| (byteCount - 1) - have hsizeNat : 32 ≤ size.toNat := by - simp only [UInt64.lt_iff_toNat_lt, UInt64.toNat_ofNat] at hsize - omega - have hcountPos : 0 < byteCount.toNat := by - apply Nat.pos_of_ne_zero - intro hzero - have hfit := u64ByteCount_fits size - simp only [byteCount, hzero, Nat.mul_zero, Nat.pow_zero] at hfit - omega - have hcountLe : byteCount.toNat ≤ 8 := u64ByteCount_toNat_le size - obtain ⟨hdecodedFlag, hlarge, hdecodedLen, hwidth⟩ := - tag2_large_fields flag byteCount hflag hcountPos hcountLe - have hdecodedFlag' : header >>> 6 = flag := by - simpa [header] using hdecodedFlag - have hheader : Reads Ixon.getU8 [header].toByteArray header := - getU8_reads header - have hsizeRead := getU64TrimmedLE_reads size - have hreturn : Reads - (pure (⟨flag, size⟩ : Ixon.Tag2) : Ixon.GetM Ixon.Tag2) - ByteArray.empty ⟨flag, size⟩ := Reads.pure _ - have hcheckedReturn : Reads - (do - if size < 32 || Ixon.u64ByteCount size != (header &&& 0x1f) + 1 then - throw "noncanonical Tag2 integer" - return (⟨flag, size⟩ : Ixon.Tag2)) - ByteArray.empty ⟨flag, size⟩ := by - simpa [hsize, hwidth, byteCount, header] using hreturn - have hafterSize : Reads - (do - let decoded ← Ixon.getU64TrimmedLE byteCount.toNat - if decoded < 32 || Ixon.u64ByteCount decoded != (header &&& 0x1f) + 1 then - throw "noncanonical Tag2 integer" - return (⟨flag, decoded⟩ : Ixon.Tag2)) - (trimmedBytes size byteCount.toNat) ⟨flag, size⟩ := by - simpa [byteCount] using Reads.bind - (next := fun decoded : UInt64 => do - if decoded < 32 || Ixon.u64ByteCount decoded != (header &&& 0x1f) + 1 then - throw "noncanonical Tag2 integer" - return (⟨flag, decoded⟩ : Ixon.Tag2)) - hsizeRead hcheckedReturn - have hlargeNe : header &&& 0x20 ≠ 0 := by - rw [hlarge] - decide - have hdecodedLen' : (header.toNat &&& 0x1f) + 1 = byteCount.toNat := by - simpa [header] using hdecodedLen - have htail : Reads - (do - let decodedFlag := header >>> 6 - let large := header &&& 0x20 != 0 - let small := header &&& 0x1f - let decodedSize ← if large then - Ixon.getU64TrimmedLE (small.toNat + 1) - else - pure small.toUInt64 - if large && (decodedSize < 32 || Ixon.u64ByteCount decodedSize != small + 1) then - throw "noncanonical Tag2 integer" - return (⟨decodedFlag, decodedSize⟩ : Ixon.Tag2)) - (trimmedBytes size byteCount.toNat) ⟨flag, size⟩ := by - simpa [hdecodedFlag', hlargeNe, hdecodedLen'] using hafterSize - have hall := Reads.bind - (next := fun b : UInt8 => do - let decodedFlag := b >>> 6 - let large := b &&& 0x20 != 0 - let small := b &&& 0x1f - let decodedSize ← if large then - Ixon.getU64TrimmedLE (small.toNat + 1) - else - pure small.toUInt64 - if large && (decodedSize < 32 || Ixon.u64ByteCount decodedSize != small + 1) then - throw "noncanonical Tag2 integer" - return (⟨decodedFlag, decodedSize⟩ : Ixon.Tag2)) - hheader htail - simpa [Ixon.getTag2, tag2Bytes, hsize, byteCount, header] using hall - -/-- Full production `Tag2` read law for every `UInt64` size. -/ -theorem getTag2_reads (flag : UInt8) (size : UInt64) - (hflag : flag < 4) : - Reads Ixon.getTag2 (tag2Bytes flag size) ⟨flag, size⟩ := by - by_cases hsize : size < 32 - · simpa [tag2Bytes, hsize] using - getTag2_reads_small flag size hflag hsize - · exact getTag2_reads_large flag size hflag hsize - -/-! ### Full `Tag0` and `Tag4` primitives -/ - -/-- Exact bytes emitted by a production `Tag0`, including its trimmed - large-size payload. -/ -def tag0Bytes (size : UInt64) : ByteArray := - if size < 128 then - [size.toUInt8].toByteArray - else - let byteCount := Ixon.u64ByteCount size - [(0x80 ||| (byteCount - 1))].toByteArray ++ - trimmedBytes size byteCount.toNat +/-! ## The wire's integer fields -theorem putTag0_writes (size : UInt64) : - Writes (Ixon.putTag0 ⟨size⟩) (tag0Bytes size) := by - unfold Ixon.putTag0 tag0Bytes - split - · exact putU8_writes _ - · exact (putU8_writes _).bind (putU64TrimmedLE_writes size) - -private theorem uint64_cases128 (size : UInt64) (h : size < 128) : - size = 0 ∨ - size = 1 ∨ - size = 2 ∨ - size = 3 ∨ - size = 4 ∨ - size = 5 ∨ - size = 6 ∨ - size = 7 ∨ - size = 8 ∨ - size = 9 ∨ - size = 10 ∨ - size = 11 ∨ - size = 12 ∨ - size = 13 ∨ - size = 14 ∨ - size = 15 ∨ - size = 16 ∨ - size = 17 ∨ - size = 18 ∨ - size = 19 ∨ - size = 20 ∨ - size = 21 ∨ - size = 22 ∨ - size = 23 ∨ - size = 24 ∨ - size = 25 ∨ - size = 26 ∨ - size = 27 ∨ - size = 28 ∨ - size = 29 ∨ - size = 30 ∨ - size = 31 ∨ - size = 32 ∨ - size = 33 ∨ - size = 34 ∨ - size = 35 ∨ - size = 36 ∨ - size = 37 ∨ - size = 38 ∨ - size = 39 ∨ - size = 40 ∨ - size = 41 ∨ - size = 42 ∨ - size = 43 ∨ - size = 44 ∨ - size = 45 ∨ - size = 46 ∨ - size = 47 ∨ - size = 48 ∨ - size = 49 ∨ - size = 50 ∨ - size = 51 ∨ - size = 52 ∨ - size = 53 ∨ - size = 54 ∨ - size = 55 ∨ - size = 56 ∨ - size = 57 ∨ - size = 58 ∨ - size = 59 ∨ - size = 60 ∨ - size = 61 ∨ - size = 62 ∨ - size = 63 ∨ - size = 64 ∨ - size = 65 ∨ - size = 66 ∨ - size = 67 ∨ - size = 68 ∨ - size = 69 ∨ - size = 70 ∨ - size = 71 ∨ - size = 72 ∨ - size = 73 ∨ - size = 74 ∨ - size = 75 ∨ - size = 76 ∨ - size = 77 ∨ - size = 78 ∨ - size = 79 ∨ - size = 80 ∨ - size = 81 ∨ - size = 82 ∨ - size = 83 ∨ - size = 84 ∨ - size = 85 ∨ - size = 86 ∨ - size = 87 ∨ - size = 88 ∨ - size = 89 ∨ - size = 90 ∨ - size = 91 ∨ - size = 92 ∨ - size = 93 ∨ - size = 94 ∨ - size = 95 ∨ - size = 96 ∨ - size = 97 ∨ - size = 98 ∨ - size = 99 ∨ - size = 100 ∨ - size = 101 ∨ - size = 102 ∨ - size = 103 ∨ - size = 104 ∨ - size = 105 ∨ - size = 106 ∨ - size = 107 ∨ - size = 108 ∨ - size = 109 ∨ - size = 110 ∨ - size = 111 ∨ - size = 112 ∨ - size = 113 ∨ - size = 114 ∨ - size = 115 ∨ - size = 116 ∨ - size = 117 ∨ - size = 118 ∨ - size = 119 ∨ - size = 120 ∨ - size = 121 ∨ - size = 122 ∨ - size = 123 ∨ - size = 124 ∨ - size = 125 ∨ - size = 126 ∨ - size = 127 := by - simp only [← UInt64.toNat_inj, UInt64.lt_iff_toNat_lt, - UInt64.toNat_ofNat] at h ⊢ - omega +Every integer field of the wire format is a TagN integer: `f = 2` for +universe terms, `f = 0` (no flag) for counts and indices, `f = 4` for +expression and constant headers. -/ -theorem tag0_small_fields (size : UInt64) (hsize : size < 128) : - size.toUInt8 &&& 0x80 = 0 ∧ - (size.toUInt8 &&& 0x7f).toUInt64 = size := by - rcases uint64_cases128 size hsize 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 | 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 | 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 | 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 <;> - decide +/-- The bytes of a universe header (`Ixon.putTagN 2`). -/ +def tag2Bytes (flag : UInt8) (size : UInt64) : ByteArray := tagNBytes 2 flag size -theorem getTag0_reads_small (size : UInt64) (hsize : size < 128) : - Reads Ixon.getTag0 [size.toUInt8].toByteArray ⟨size⟩ := by - intro before after - unfold Ixon.getTag0 - change (EStateM.bind Ixon.getU8 _) _ = _ - rw [EStateM.bind, getU8_reads _ before after] - obtain ⟨hlarge, hdecodedSize⟩ := tag0_small_fields size hsize - simp only [hlarge] - change (EStateM.bind (EStateM.pure _) _) _ = _ - simp only [EStateM.bind, EStateM.pure] - change (EStateM.pure _) _ = _ - simp [EStateM.pure, hdecodedSize] - -theorem tag0_large_fields (byteCount : UInt8) - (hpos : 0 < byteCount.toNat) (hle : byteCount.toNat ≤ 8) : - let header := 0x80 ||| (byteCount - 1) - header &&& 0x80 = 0x80 ∧ - (header &&& 0x7f).toNat + 1 = byteCount.toNat ∧ - (header &&& 0x7f) + 1 = byteCount := by - rcases uint8_cases1_8 byteCount hpos hle with - rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> - decide +/-- The bytes of a count or index (`Ixon.putTagN 0 0`). -/ +def tag0Bytes (size : UInt64) : ByteArray := tagNBytes 0 0 size -theorem getTag0_reads_large (size : UInt64) (hsize : ¬ size < 128) : - Reads Ixon.getTag0 (tag0Bytes size) ⟨size⟩ := by - let byteCount := Ixon.u64ByteCount size - let header := 0x80 ||| (byteCount - 1) - have hsizeNat : 128 ≤ size.toNat := by - simp only [UInt64.lt_iff_toNat_lt, UInt64.toNat_ofNat] at hsize - omega - have hcountPos : 0 < byteCount.toNat := by - apply Nat.pos_of_ne_zero - intro hzero - have hfit := u64ByteCount_fits size - simp only [byteCount, hzero, Nat.mul_zero, Nat.pow_zero] at hfit - omega - have hcountLe : byteCount.toNat ≤ 8 := u64ByteCount_toNat_le size - obtain ⟨hlarge, hdecodedLen, hwidth⟩ := - tag0_large_fields byteCount hcountPos hcountLe - have hheader : Reads Ixon.getU8 [header].toByteArray header := - getU8_reads header - have hsizeRead := getU64TrimmedLE_reads size - have hreturn : Reads - (pure (⟨size⟩ : Ixon.Tag0) : Ixon.GetM Ixon.Tag0) - ByteArray.empty ⟨size⟩ := Reads.pure _ - have hcheckedReturn : Reads - (do - if size < 128 || Ixon.u64ByteCount size != (header &&& 0x7f) + 1 then - throw "noncanonical Tag0 integer" - return (⟨size⟩ : Ixon.Tag0)) - ByteArray.empty ⟨size⟩ := by - simpa [hsize, hwidth, byteCount, header] using hreturn - have hafterSize : Reads - (do - let decoded ← Ixon.getU64TrimmedLE byteCount.toNat - if decoded < 128 || Ixon.u64ByteCount decoded != (header &&& 0x7f) + 1 then - throw "noncanonical Tag0 integer" - return (⟨decoded⟩ : Ixon.Tag0)) - (trimmedBytes size byteCount.toNat) ⟨size⟩ := by - simpa [byteCount] using Reads.bind - (next := fun decoded : UInt64 => do - if decoded < 128 || Ixon.u64ByteCount decoded != (header &&& 0x7f) + 1 then - throw "noncanonical Tag0 integer" - return (⟨decoded⟩ : Ixon.Tag0)) - hsizeRead hcheckedReturn - have hlargeNe : header &&& 0x80 ≠ 0 := by - rw [hlarge] - decide - have hdecodedLen' : (header.toNat &&& 0x7f) + 1 = byteCount.toNat := by - simpa [header] using hdecodedLen - have htail : Reads - (do - let large := header &&& 0x80 != 0 - let small := header &&& 0x7f - let decodedSize ← if large then - Ixon.getU64TrimmedLE (small.toNat + 1) - else - pure small.toUInt64 - if large && (decodedSize < 128 || Ixon.u64ByteCount decodedSize != small + 1) then - throw "noncanonical Tag0 integer" - return (⟨decodedSize⟩ : Ixon.Tag0)) - (trimmedBytes size byteCount.toNat) ⟨size⟩ := by - simpa [hlargeNe, hdecodedLen'] using hafterSize - have hall := Reads.bind - (next := fun b : UInt8 => do - let large := b &&& 0x80 != 0 - let small := b &&& 0x7f - let decodedSize ← if large then - Ixon.getU64TrimmedLE (small.toNat + 1) - else - pure small.toUInt64 - if large && (decodedSize < 128 || Ixon.u64ByteCount decodedSize != small + 1) then - throw "noncanonical Tag0 integer" - return (⟨decodedSize⟩ : Ixon.Tag0)) - hheader htail - simpa [Ixon.getTag0, tag0Bytes, hsize, byteCount, header] using hall - -/-- Full production `Tag0` read law for every `UInt64` size. -/ -theorem getTag0_reads (size : UInt64) : - Reads Ixon.getTag0 (tag0Bytes size) ⟨size⟩ := by - by_cases hsize : size < 128 - · simpa [tag0Bytes, hsize] using getTag0_reads_small size hsize - · exact getTag0_reads_large size hsize - -private theorem uint8_cases16 (flag : UInt8) (h : flag < 16) : - flag = 0 ∨ flag = 1 ∨ flag = 2 ∨ flag = 3 ∨ - flag = 4 ∨ flag = 5 ∨ flag = 6 ∨ flag = 7 ∨ - flag = 8 ∨ flag = 9 ∨ flag = 10 ∨ flag = 11 ∨ - flag = 12 ∨ flag = 13 ∨ flag = 14 ∨ flag = 15 := by - simp only [← UInt8.toNat_inj, UInt8.lt_iff_toNat_lt, - UInt8.toNat_ofNat] at h ⊢ - omega +/-- The bytes of an expression or constant header (`Ixon.putTagN 4`). -/ +def tag4Bytes (flag : UInt8) (size : UInt64) : ByteArray := tagNBytes 4 flag size -/-- Exact bytes emitted by a production `Tag4`, including its trimmed - large-size payload. -/ -def tag4Bytes (flag : UInt8) (size : UInt64) : ByteArray := - if size < 8 then - [((flag <<< 4) ||| size.toUInt8)].toByteArray - else - let byteCount := Ixon.u64ByteCount size - [((flag <<< 4) ||| 0x08 ||| (byteCount - 1))].toByteArray ++ - trimmedBytes size byteCount.toNat +theorem putTag2_writes (flag : UInt8) (size : UInt64) : + Writes (Ixon.putTagN 2 flag size) (tag2Bytes flag size) := + putTagN_writes 2 flag size + +theorem getTag2_reads (flag : UInt8) (size : UInt64) (hflag : flag < 4) : + Reads (Ixon.getTagN 2) (tag2Bytes flag size) ⟨flag, size⟩ := + getTagN_reads 2 (by decide) flag (by simpa [UInt8.lt_iff_toNat_lt] using hflag) size + +theorem putTag0_writes (size : UInt64) : + Writes (Ixon.putTagN 0 0 size) (tag0Bytes size) := + putTagN_writes 0 0 size + +theorem getTag0_reads (size : UInt64) : + Reads (Ixon.getTagN 0) (tag0Bytes size) ⟨0, size⟩ := + getTagN_reads 0 (by decide) 0 (by decide) size theorem putTag4_writes (flag : UInt8) (size : UInt64) : - Writes (Ixon.putTag4 ⟨flag, size⟩) (tag4Bytes flag size) := by - unfold Ixon.putTag4 tag4Bytes - split - · exact putU8_writes _ - · exact (putU8_writes _).bind (putU64TrimmedLE_writes size) + Writes (Ixon.putTagN 4 flag size) (tag4Bytes flag size) := + putTagN_writes 4 flag size -private theorem uint64_cases8 (size : UInt64) (h : size < 8) : - size = 0 ∨ size = 1 ∨ size = 2 ∨ size = 3 ∨ - size = 4 ∨ size = 5 ∨ size = 6 ∨ size = 7 := by - simp only [← UInt64.toNat_inj, UInt64.lt_iff_toNat_lt, - UInt64.toNat_ofNat] at h ⊢ - omega +theorem getTag4_reads (flag : UInt8) (size : UInt64) (hflag : flag < 16) : + Reads (Ixon.getTagN 4) (tag4Bytes flag size) ⟨flag, size⟩ := + getTagN_reads 4 (by decide) flag (by simpa [UInt8.lt_iff_toNat_lt] using hflag) size -theorem tag4_small_fields (flag : UInt8) (size : UInt64) - (hflag : flag < 16) (hsize : size < 8) : - (((flag <<< 4) ||| size.toUInt8) >>> 4) = flag ∧ - (((flag <<< 4) ||| size.toUInt8) &&& 0x08) = 0 ∧ - ((((flag <<< 4) ||| size.toUInt8) &&& 0x07).toUInt64) = size := by - rcases uint8_cases16 flag hflag with +/-- A small universe header is one byte: the flag in the top two bits, the +value below. -/ +theorem tag2Bytes_small (flag : UInt8) (size : UInt64) + (hflag : flag < 4) (hsize : size < 32) : + tag2Bytes flag size = [((flag <<< 6) ||| size.toUInt8)].toByteArray := by + have hs : size.toNat < Ixon.tagNEnd1 2 := by + simpa [UInt64.lt_iff_toNat_lt, show Ixon.tagNEnd1 2 = 32 by decide] using hsize + unfold tag2Bytes tagNBytes + simp only [if_pos hs] + congr 1 + rcases uint8_cases4 flag hflag with rfl | rfl | rfl | rfl <;> + rcases uint64_cases32 size hsize 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 <;> - rcases uint64_cases8 size hsize with - rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> - decide - -theorem getTag4_reads_small (flag : UInt8) (size : UInt64) - (hflag : flag < 16) (hsize : size < 8) : - Reads Ixon.getTag4 - [((flag <<< 4) ||| size.toUInt8)].toByteArray - ⟨flag, size⟩ := by - intro before after - unfold Ixon.getTag4 - change (EStateM.bind Ixon.getU8 _) _ = _ - rw [EStateM.bind, getU8_reads _ before after] - obtain ⟨hdecodedFlag, hlarge, hdecodedSize⟩ := - tag4_small_fields flag size hflag hsize - simp only [hdecodedFlag, hlarge] - change (EStateM.bind (EStateM.pure _) _) _ = _ - simp only [EStateM.bind, EStateM.pure] - change (EStateM.pure _) _ = _ - simp [EStateM.pure, hdecodedSize] - -theorem tag4_large_fields (flag byteCount : UInt8) - (hflag : flag < 16) (hpos : 0 < byteCount.toNat) - (hle : byteCount.toNat ≤ 8) : - let header := (flag <<< 4) ||| 0x08 ||| (byteCount - 1) - header >>> 4 = flag ∧ - header &&& 0x08 = 0x08 ∧ - (header &&& 0x07).toNat + 1 = byteCount.toNat ∧ - (header &&& 0x07) + 1 = byteCount := by - rcases uint8_cases16 flag hflag with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | - rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> - rcases uint8_cases1_8 byteCount hpos hle with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> decide -theorem getTag4_reads_large (flag : UInt8) (size : UInt64) - (hflag : flag < 16) (hsize : ¬ size < 8) : - Reads Ixon.getTag4 (tag4Bytes flag size) ⟨flag, size⟩ := by - let byteCount := Ixon.u64ByteCount size - let header := (flag <<< 4) ||| 0x08 ||| (byteCount - 1) - have hsizeNat : 8 ≤ size.toNat := by - simp only [UInt64.lt_iff_toNat_lt, UInt64.toNat_ofNat] at hsize - omega - have hcountPos : 0 < byteCount.toNat := by - apply Nat.pos_of_ne_zero - intro hzero - have hfit := u64ByteCount_fits size - simp only [byteCount, hzero, Nat.mul_zero, Nat.pow_zero] at hfit - omega - have hcountLe : byteCount.toNat ≤ 8 := u64ByteCount_toNat_le size - obtain ⟨hdecodedFlag, hlarge, hdecodedLen, hwidth⟩ := - tag4_large_fields flag byteCount hflag hcountPos hcountLe - have hdecodedFlag' : header >>> 4 = flag := by - simpa [header] using hdecodedFlag - have hheader : Reads Ixon.getU8 [header].toByteArray header := - getU8_reads header - have hsizeRead := getU64TrimmedLE_reads size - have hreturn : Reads - (pure (⟨flag, size⟩ : Ixon.Tag4) : Ixon.GetM Ixon.Tag4) - ByteArray.empty ⟨flag, size⟩ := Reads.pure _ - have hcheckedReturn : Reads - (do - if size < 8 || Ixon.u64ByteCount size != (header &&& 0x07) + 1 then - throw "noncanonical Tag4 integer" - return (⟨flag, size⟩ : Ixon.Tag4)) - ByteArray.empty ⟨flag, size⟩ := by - simpa [hsize, hwidth, byteCount, header] using hreturn - have hafterSize : Reads - (do - let decoded ← Ixon.getU64TrimmedLE byteCount.toNat - if decoded < 8 || Ixon.u64ByteCount decoded != (header &&& 0x07) + 1 then - throw "noncanonical Tag4 integer" - return (⟨flag, decoded⟩ : Ixon.Tag4)) - (trimmedBytes size byteCount.toNat) ⟨flag, size⟩ := by - simpa [byteCount] using Reads.bind - (next := fun decoded : UInt64 => do - if decoded < 8 || Ixon.u64ByteCount decoded != (header &&& 0x07) + 1 then - throw "noncanonical Tag4 integer" - return (⟨flag, decoded⟩ : Ixon.Tag4)) - hsizeRead hcheckedReturn - have hlargeNe : header &&& 0x08 ≠ 0 := by - rw [hlarge] - decide - have hdecodedLen' : (header.toNat &&& 0x07) + 1 = byteCount.toNat := by - simpa [header] using hdecodedLen - have htail : Reads - (do - let decodedFlag := header >>> 4 - let large := header &&& 0x08 != 0 - let small := header &&& 0x07 - let decodedSize ← if large then - Ixon.getU64TrimmedLE (small.toNat + 1) - else - pure small.toUInt64 - if large && (decodedSize < 8 || Ixon.u64ByteCount decodedSize != small + 1) then - throw "noncanonical Tag4 integer" - return (⟨decodedFlag, decodedSize⟩ : Ixon.Tag4)) - (trimmedBytes size byteCount.toNat) ⟨flag, size⟩ := by - simpa [hdecodedFlag', hlargeNe, hdecodedLen'] using hafterSize - have hall := Reads.bind - (next := fun b : UInt8 => do - let decodedFlag := b >>> 4 - let large := b &&& 0x08 != 0 - let small := b &&& 0x07 - let decodedSize ← if large then - Ixon.getU64TrimmedLE (small.toNat + 1) - else - pure small.toUInt64 - if large && (decodedSize < 8 || Ixon.u64ByteCount decodedSize != small + 1) then - throw "noncanonical Tag4 integer" - return (⟨decodedFlag, decodedSize⟩ : Ixon.Tag4)) - hheader htail - simpa [Ixon.getTag4, tag4Bytes, hsize, byteCount, header] using hall - -/-- Full production `Tag4` read law for every `UInt64` size. -/ -theorem getTag4_reads (flag : UInt8) (size : UInt64) - (hflag : flag < 16) : - Reads Ixon.getTag4 (tag4Bytes flag size) ⟨flag, size⟩ := by - by_cases hsize : size < 8 - · simpa [tag4Bytes, hsize] using - getTag4_reads_small flag size hflag hsize - · exact getTag4_reads_large flag size hflag hsize +theorem getTag2_reads_small (flag : UInt8) (size : UInt64) + (hflag : flag < 4) (hsize : size < 32) : + Reads (Ixon.getTagN 2) [((flag <<< 6) ||| size.toUInt8)].toByteArray ⟨flag, size⟩ := by + rw [← tag2Bytes_small flag size hflag hsize] + exact getTag2_reads flag size hflag + +theorem putTag2_writes_small (flag : UInt8) (size : UInt64) + (hflag : flag < 4) (hsize : size < 32) : + Writes (Ixon.putTagN 2 flag size) [((flag <<< 6) ||| size.toUInt8)].toByteArray := by + rw [← tag2Bytes_small flag size hflag hsize] + exact putTag2_writes flag size theorem nat_toUInt64_lt_32 {n : Nat} (h : n < 32) : n.toUInt64 < 32 := by @@ -997,15 +625,14 @@ theorem putUniv_writes_small (u : Ixon.Univ) (h : SmallWireWF u) : cases u with | zero => simpa [Ixon.putUniv, smallEncode, Ixon.Univ.FLAG_ZERO_SUCC] using - putTag2_writes_small Ixon.Univ.FLAG_ZERO_SUCC 0 (by decide) + putTag2_writes_small Ixon.Univ.FLAG_ZERO_SUCC 0 (by decide) (by decide) | succ inner => let u : Ixon.Univ := .succ inner have hcount : u.succCount < 32 := by exact nat_toUInt64_lt_32 h.1 - have htag : Writes (Ixon.putTag2 ⟨Ixon.Univ.FLAG_ZERO_SUCC, - u.succCount⟩) [u.succCount.toUInt8].toByteArray := by + have htag : Writes (Ixon.putTagN 2 Ixon.Univ.FLAG_ZERO_SUCC u.succCount) [u.succCount.toUInt8].toByteArray := by simpa only [tag2_zero_header] using - putTag2_writes_small Ixon.Univ.FLAG_ZERO_SUCC u.succCount hcount + putTag2_writes_small Ixon.Univ.FLAG_ZERO_SUCC u.succCount (by decide) hcount have hlt : sizeOf u.succBase < sizeOf u := by change sizeOf inner.succBase < 1 + sizeOf inner have hsize := Ixon.Univ.succBase_sizeOf_le inner @@ -1013,26 +640,26 @@ theorem putUniv_writes_small (u : Ixon.Univ) (h : SmallWireWF u) : have hbase := ih u.succBase hlt h.succBase simpa [u, Ixon.putUniv, smallEncode] using htag.bind hbase | max left right => - have htag : Writes (Ixon.putTag2 ⟨Ixon.Univ.FLAG_MAX, 0⟩) + have htag : Writes (Ixon.putTagN 2 Ixon.Univ.FLAG_MAX 0) [0x40].toByteArray := by simpa only [tag2_max_zero_header] using - putTag2_writes_small Ixon.Univ.FLAG_MAX 0 (by decide) + putTag2_writes_small Ixon.Univ.FLAG_MAX 0 (by decide) (by decide) have hleft := ih left (by simp_wf; omega) h.1 have hright := ih right (by simp_wf; omega) h.2 simpa [Ixon.putUniv, smallEncode, ByteArray.append_assoc] using htag.bind (hleft.bind hright) | imax left right => - have htag : Writes (Ixon.putTag2 ⟨Ixon.Univ.FLAG_IMAX, 0⟩) + have htag : Writes (Ixon.putTagN 2 Ixon.Univ.FLAG_IMAX 0) [0x80].toByteArray := by simpa only [tag2_imax_zero_header] using - putTag2_writes_small Ixon.Univ.FLAG_IMAX 0 (by decide) + putTag2_writes_small Ixon.Univ.FLAG_IMAX 0 (by decide) (by decide) have hleft := ih left (by simp_wf; omega) h.1 have hright := ih right (by simp_wf; omega) h.2 simpa [Ixon.putUniv, smallEncode, ByteArray.append_assoc] using htag.bind (hleft.bind hright) | var idx => simpa only [Ixon.putUniv, smallEncode, tag2_var_header] using - putTag2_writes_small Ixon.Univ.FLAG_VAR idx h + putTag2_writes_small Ixon.Univ.FLAG_VAR idx (by decide) h theorem getUnivFuel_reads_small (u : Ixon.Univ) (h : SmallWireWF u) (fuel : Nat) (hfuel : (smallEncode u).size ≤ fuel) : @@ -1051,7 +678,7 @@ theorem getUnivFuel_reads_small (u : Ixon.Univ) (h : SmallWireWF u) | succ fuel => cases u with | zero => - have htag : Reads Ixon.getTag2 [0].toByteArray + have htag : Reads (Ixon.getTagN 2) [0].toByteArray ⟨Ixon.Univ.FLAG_ZERO_SUCC, 0⟩ := by simpa [Ixon.Univ.FLAG_ZERO_SUCC] using getTag2_reads_small Ixon.Univ.FLAG_ZERO_SUCC 0 @@ -1068,7 +695,7 @@ theorem getUnivFuel_reads_small (u : Ixon.Univ) (h : SmallWireWF u) | succ inner => let whole : Ixon.Univ := .succ inner have hcount : whole.succCount < 32 := nat_toUInt64_lt_32 h.1 - have htag : Reads Ixon.getTag2 + have htag : Reads (Ixon.getTagN 2) [whole.succCount.toUInt8].toByteArray ⟨Ixon.Univ.FLAG_ZERO_SUCC, whole.succCount⟩ := by simpa only [tag2_zero_header] using @@ -1117,7 +744,7 @@ theorem getUnivFuel_reads_small (u : Ixon.Univ) (h : SmallWireWF u) simpa [whole, Ixon.getUnivFuel, smallEncode, Ixon.Univ.FLAG_ZERO_SUCC, hcountNe, ByteArray.append_assoc] using hall | max left right => - have htag : Reads Ixon.getTag2 [0x40].toByteArray + have htag : Reads (Ixon.getTagN 2) [0x40].toByteArray ⟨Ixon.Univ.FLAG_MAX, 0⟩ := by simpa only [tag2_max_zero_header] using getTag2_reads_small Ixon.Univ.FLAG_MAX 0 (by decide) (by decide) @@ -1149,7 +776,7 @@ theorem getUnivFuel_reads_small (u : Ixon.Univ) (h : SmallWireWF u) simpa [Ixon.getUnivFuel, smallEncode, Ixon.Univ.FLAG_MAX, ByteArray.append_assoc] using hall | imax left right => - have htag : Reads Ixon.getTag2 [0x80].toByteArray + have htag : Reads (Ixon.getTagN 2) [0x80].toByteArray ⟨Ixon.Univ.FLAG_IMAX, 0⟩ := by simpa only [tag2_imax_zero_header] using getTag2_reads_small Ixon.Univ.FLAG_IMAX 0 (by decide) (by decide) @@ -1181,7 +808,7 @@ theorem getUnivFuel_reads_small (u : Ixon.Univ) (h : SmallWireWF u) simpa [Ixon.getUnivFuel, smallEncode, Ixon.Univ.FLAG_IMAX, ByteArray.append_assoc] using hall | var idx => - have htag : Reads Ixon.getTag2 + have htag : Reads (Ixon.getTagN 2) [0xc0 ||| idx.toUInt8].toByteArray ⟨Ixon.Univ.FLAG_VAR, idx⟩ := by simpa only [tag2_var_header] using @@ -1271,9 +898,7 @@ decreasing_by omega theorem tag2Bytes_size_pos (flag : UInt8) (size : UInt64) : - 0 < (tag2Bytes flag size).size := by - unfold tag2Bytes - split <;> simp <;> omega + 0 < (tag2Bytes flag size).size := tagNBytes_size_pos 2 flag size theorem wireEncode_size_pos (u : Ixon.Univ) : 0 < (wireEncode u).size := by @@ -1334,7 +959,7 @@ theorem getUnivFuel_reads (u : Ixon.Univ) (h : WireWF u) | succ fuel => cases u with | zero => - have htag : Reads Ixon.getTag2 + have htag : Reads (Ixon.getTagN 2) (tag2Bytes Ixon.Univ.FLAG_ZERO_SUCC 0) ⟨Ixon.Univ.FLAG_ZERO_SUCC, 0⟩ := getTag2_reads Ixon.Univ.FLAG_ZERO_SUCC 0 (by decide) @@ -1350,7 +975,7 @@ theorem getUnivFuel_reads (u : Ixon.Univ) (h : WireWF u) Ixon.Univ.FLAG_ZERO_SUCC] using hall | succ inner => let whole : Ixon.Univ := .succ inner - have htag : Reads Ixon.getTag2 + have htag : Reads (Ixon.getTagN 2) (tag2Bytes Ixon.Univ.FLAG_ZERO_SUCC whole.succCount) ⟨Ixon.Univ.FLAG_ZERO_SUCC, whole.succCount⟩ := getTag2_reads Ixon.Univ.FLAG_ZERO_SUCC whole.succCount (by decide) @@ -1399,7 +1024,7 @@ theorem getUnivFuel_reads (u : Ixon.Univ) (h : WireWF u) simpa [whole, Ixon.getUnivFuel, wireEncode, Ixon.Univ.FLAG_ZERO_SUCC, hcountNe, ByteArray.append_assoc] using hall | max left right => - have htag : Reads Ixon.getTag2 + have htag : Reads (Ixon.getTagN 2) (tag2Bytes Ixon.Univ.FLAG_MAX 0) ⟨Ixon.Univ.FLAG_MAX, 0⟩ := getTag2_reads Ixon.Univ.FLAG_MAX 0 (by decide) @@ -1431,7 +1056,7 @@ theorem getUnivFuel_reads (u : Ixon.Univ) (h : WireWF u) simpa [Ixon.getUnivFuel, wireEncode, Ixon.Univ.FLAG_MAX, ByteArray.append_assoc] using hall | imax left right => - have htag : Reads Ixon.getTag2 + have htag : Reads (Ixon.getTagN 2) (tag2Bytes Ixon.Univ.FLAG_IMAX 0) ⟨Ixon.Univ.FLAG_IMAX, 0⟩ := getTag2_reads Ixon.Univ.FLAG_IMAX 0 (by decide) @@ -1463,7 +1088,7 @@ theorem getUnivFuel_reads (u : Ixon.Univ) (h : WireWF u) simpa [Ixon.getUnivFuel, wireEncode, Ixon.Univ.FLAG_IMAX, ByteArray.append_assoc] using hall | var idx => - have htag : Reads Ixon.getTag2 + have htag : Reads (Ixon.getTagN 2) (tag2Bytes Ixon.Univ.FLAG_VAR idx) ⟨Ixon.Univ.FLAG_VAR, idx⟩ := getTag2_reads Ixon.Univ.FLAG_VAR idx (by decide) @@ -1535,12 +1160,12 @@ namespace Ix.Compile.Verify abbrev UnivWireWF : Ixon.Univ → Prop := Codec.Ixon.Univ.WireWF -/-- Universe values whose v2 tags all use the one-byte `Tag2` form. -/ +/-- Universe values whose tags all use the one-byte TagN (`f = 2`) rung. -/ abbrev SmallUnivWireWF : Ixon.Univ → Prop := Codec.Ixon.Univ.SmallWireWF -/-- X1-U64: exact full-buffer universe round trip across both the one-byte - and trimmed large-size `Tag2` forms. -/ +/-- X1-U64: exact full-buffer universe round trip across every TagN (`f = 2`) + rung. -/ theorem deUniv_serUniv (u : Ixon.Univ) (h : UnivWireWF u) : Ixon.deUniv (Ixon.serUniv u) = .ok u := Codec.Ixon.Univ.deUniv_serUniv u h diff --git a/Ix/Compile/Verify/CompileAxiomCodec.lean b/Ix/Compile/Verify/CompileAxiomCodec.lean index 23ece46a4..b885e2c77 100644 --- a/Ix/Compile/Verify/CompileAxiomCodec.lean +++ b/Ix/Compile/Verify/CompileAxiomCodec.lean @@ -263,18 +263,9 @@ theorem compileAxiomBlock_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (axiomCompileBlockEnv blockEnv axiomVal) snapshot) axiomVal.cnst.type = some target) : - ∃ constMeta state', - let info : Ixon.ConstantInfo := - .axio (compiledAxiomPayload axiomVal target) - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state'.refs state'.univs) - constMeta - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileAxiomBlock axiomVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileAxiomBlock axiomVal)) := by obtain ⟨constMeta, state', haxiom, htables', hinfo⟩ := compileAxiom_run_ordinary_wireWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables axiomVal hsource hbound @@ -282,9 +273,6 @@ theorem compileAxiomBlock_run_ordinary_codecWF have hfinish := finishConstantInfoWithSharing_run_codecWF compileEnv blockEnv state' (.axio (compiledAxiomPayload axiomVal target)) constMeta hinfo htables' - refine ⟨constMeta, state', ?_⟩ - dsimp only - dsimp only at hfinish unfold Ix.CompileM.compileAxiomBlock rw [run_bind, haxiom] exact hfinish @@ -353,23 +341,13 @@ theorem compileAxiomInfo_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (axiomCompileBlockEnv blockEnv axiomVal) snapshot) axiomVal.cnst.type = some target) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileAxiomInfo axiomVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by - obtain ⟨constMeta, state', hrun, hcodec⟩ := + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileAxiomInfo axiomVal)) := by + have hrun := compileAxiomBlock_run_ordinary_codecWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables axiomVal hsource hbound hstate href - let info : Ixon.ConstantInfo := - .axio (compiledAxiomPayload axiomVal target) - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state'.refs state'.univs) - constMeta - refine ⟨result, state', ?_, hcodec⟩ unfold Ix.CompileM.compileAxiomInfo rw [run_bind, hpreseed] exact hrun @@ -432,17 +410,14 @@ theorem compileConstantInfo_axiom_run_ordinary_codecWF (singletonAxiomBlockEnv blockEnv axiomVal) axiomVal) snapshot) axiomVal.cnst.type = some target) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstantInfo (.axiomInfo axiomVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by - obtain ⟨result, state', hrun, hcodec⟩ := + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstantInfo (.axiomInfo axiomVal))) := by + have hrun := compileAxiomInfo_run_ordinary_codecWF compileEnv (singletonAxiomBlockEnv blockEnv axiomVal) snapshot hfree hclosed hlevelFaithful hexprFaithful htables axiomVal state preseedState hpreseed hsource hbound hstate href - refine ⟨result, state', ?_, hcodec⟩ have haudit := auditConstantInfoPlanHeads_axiom_run_surgeryFree compileEnv blockEnv state axiomVal hfree rw [compileConstantInfo_axiom_run_eq, haudit] @@ -495,11 +470,9 @@ theorem compileConstantInfo_axiom_run_ready_codecWF (htableBound : SingletonPreseedSourceBound (singletonAxiomBlockEnv blockEnv axiomVal) state axiomVal.cnst.type) (hbound : ExprWireBound axiomVal.cnst.type) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstantInfo (.axiomInfo axiomVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstantInfo (.axiomInfo axiomVal))) := by let singletonEnv := singletonAxiomBlockEnv blockEnv axiomVal obtain ⟨preseedState, target, hpreseed, htables, href, hpreseedExpr, hpreseedCanon, hpreseedArena, hpreseedFinal⟩ := @@ -540,12 +513,10 @@ theorem compileConstantInfo_axiom_default_run_ready_codecWF (singletonAxiomBlockEnv blockEnv axiomVal) (default : Ix.CompileM.BlockState) axiomVal.cnst.type) (hbound : ExprWireBound axiomVal.cnst.type) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv (default : Ix.CompileM.BlockState) - (Ix.CompileM.compileConstantInfo (.axiomInfo axiomVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + (Ix.CompileM.compileConstantInfo (.axiomInfo axiomVal))) := by apply compileConstantInfo_axiom_run_ready_codecWF compileEnv blockEnv hfree hclosed hlevelFaithful hexprFaithful axiomVal (default : Ix.CompileM.BlockState) rfl CanonUnivCacheWF.empty diff --git a/Ix/Compile/Verify/CompileConstantCodec.lean b/Ix/Compile/Verify/CompileConstantCodec.lean index 6a1a048d7..8d2a789a1 100644 --- a/Ix/Compile/Verify/CompileConstantCodec.lean +++ b/Ix/Compile/Verify/CompileConstantCodec.lean @@ -6,8 +6,8 @@ import Ix.Compile.Verify.MutualConstantCodec This module closes the unshared axiom and definition assembly core against the production constant codec. The production declaration driver subsequently -runs `Sharing.applySharing`; preservation by that rewrite remains a separate, -explicit proof obligation. +runs the canonical sharing builder, whose output is closed against the codec +in `CompileSharingCodec`. -/ namespace Ix.Compile.Verify diff --git a/Ix/Compile/Verify/CompileDefinitionCodec.lean b/Ix/Compile/Verify/CompileDefinitionCodec.lean index 96ff338ed..2f326d558 100644 --- a/Ix/Compile/Verify/CompileDefinitionCodec.lean +++ b/Ix/Compile/Verify/CompileDefinitionCodec.lean @@ -290,18 +290,9 @@ theorem compileDefinitionBlock_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (definitionCompileBlockEnv blockEnv definitionVal) snapshot) definitionVal.value = some valueTarget) : - ∃ constMeta state', - let info : Ixon.ConstantInfo := - .defn (compiledDefinitionPayload definitionVal typeTarget valueTarget) - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state'.refs state'.univs) - constMeta - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileDefinitionBlock definitionVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileDefinitionBlock definitionVal)) := by obtain ⟨constMeta, state', hdefinition, htables', hinfo⟩ := compileDefinition_run_ordinary_wireWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables definitionVal htypeSource @@ -310,9 +301,6 @@ theorem compileDefinitionBlock_run_ordinary_codecWF compileEnv blockEnv state' (.defn (compiledDefinitionPayload definitionVal typeTarget valueTarget)) constMeta hinfo htables' - refine ⟨constMeta, state', ?_⟩ - dsimp only - dsimp only at hfinish unfold Ix.CompileM.compileDefinitionBlock rw [run_bind, hdefinition] exact hfinish @@ -353,23 +341,13 @@ theorem compileDefinitionInfo_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (definitionCompileBlockEnv blockEnv definitionVal) snapshot) definitionVal.value = some valueTarget) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileDefinitionInfo definitionVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by - obtain ⟨constMeta, state', hrun, hcodec⟩ := + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileDefinitionInfo definitionVal)) := by + have hrun := compileDefinitionBlock_run_ordinary_codecWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables definitionVal htypeSource hvalueSource htypeBound hvalueBound hstate htypeRef hvalueRef - let info : Ixon.ConstantInfo := - .defn (compiledDefinitionPayload definitionVal typeTarget valueTarget) - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state'.refs state'.univs) - constMeta - refine ⟨result, state', ?_, hcodec⟩ unfold Ix.CompileM.compileDefinitionInfo rw [run_bind, hpreseed] exact hrun @@ -404,11 +382,9 @@ theorem compileDefinitionInfo_run_ready_codecWF definitionVal.cnst.type definitionVal.value) (htypeBound : ExprWireBound definitionVal.cnst.type) (hvalueBound : ExprWireBound definitionVal.value) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileDefinitionInfo definitionVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileDefinitionInfo definitionVal)) := by let params := definitionVal.cnst.levelParams.toList obtain ⟨preseedState, typeTarget, valueTarget, hpreseed, htables, htypeRef, hvalueRef, hexpr, hcanonState, harena, hfinal⟩ := @@ -520,18 +496,15 @@ theorem compileConstantInfo_definition_run_ready_codecWF definitionVal.cnst.type definitionVal.value) (htypeBound : ExprWireBound definitionVal.cnst.type) (hvalueBound : ExprWireBound definitionVal.value) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstantInfo (.defnInfo definitionVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstantInfo (.defnInfo definitionVal))) := by let singletonEnv := singletonDefinitionBlockEnv blockEnv definitionVal - obtain ⟨result, state', hrun, hcodec⟩ := + have hrun := compileDefinitionInfo_run_ready_codecWF compileEnv singletonEnv hfree hclosed hlevelFaithful hexprFaithful definitionVal state hexprCache hcanonCache hrefTable hunivTable htypeReady hvalueReady htableBound htypeBound hvalueBound - refine ⟨result, state', ?_, hcodec⟩ rw [compileConstantInfo_definition_run_surgeryFree_eq compileEnv blockEnv state definitionVal hfree] exact hrun @@ -566,12 +539,10 @@ theorem compileConstantInfo_definition_default_run_ready_codecWF definitionVal.cnst.type definitionVal.value) (htypeBound : ExprWireBound definitionVal.cnst.type) (hvalueBound : ExprWireBound definitionVal.value) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv (default : Ix.CompileM.BlockState) - (Ix.CompileM.compileConstantInfo (.defnInfo definitionVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + (Ix.CompileM.compileConstantInfo (.defnInfo definitionVal))) := by apply compileConstantInfo_definition_run_ready_codecWF compileEnv blockEnv hfree hclosed hlevelFaithful hexprFaithful definitionVal (default : Ix.CompileM.BlockState) rfl CanonUnivCacheWF.empty diff --git a/Ix/Compile/Verify/CompileDefinitionDataCodec.lean b/Ix/Compile/Verify/CompileDefinitionDataCodec.lean index d8999ce76..8a7f3d616 100644 --- a/Ix/Compile/Verify/CompileDefinitionDataCodec.lean +++ b/Ix/Compile/Verify/CompileDefinitionDataCodec.lean @@ -280,19 +280,9 @@ theorem compileDefinitionDataBlock_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (definitionDataCompileBlockEnv blockEnv definitionData) snapshot) definitionData.value = some valueTarget) : - ∃ constMeta state', - let info : Ixon.ConstantInfo := - .defn (compiledDefinitionDataPayload definitionData - typeTarget valueTarget) - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state'.refs state'.univs) - constMeta - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileDefinitionDataBlock definitionData) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileDefinitionDataBlock definitionData)) := by obtain ⟨constMeta, state', hdefinition, htables', _, hinfo, _, _⟩ := compileDefinitionData_run_ordinary_wireWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables definitionData @@ -302,9 +292,6 @@ theorem compileDefinitionDataBlock_run_ordinary_codecWF compileEnv blockEnv state' (.defn (compiledDefinitionDataPayload definitionData typeTarget valueTarget)) constMeta hinfo htables' - refine ⟨constMeta, state', ?_⟩ - dsimp only - dsimp only at hfinish unfold Ix.CompileM.compileDefinitionDataBlock rw [run_bind, hdefinition] exact hfinish @@ -343,25 +330,14 @@ theorem compileDefinitionDataInfo_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (definitionDataCompileBlockEnv blockEnv definitionData) snapshot) definitionData.value = some valueTarget) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileDefinitionDataInfo definitionData) = - .ok (result, state') ∧ - BlockResultCodecWF result := by - obtain ⟨constMeta, state', hrun, hcodec⟩ := + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileDefinitionDataInfo definitionData)) := by + have hrun := compileDefinitionDataBlock_run_ordinary_codecWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables definitionData htypeSource hvalueSource htypeBound hvalueBound hstate htypeRef hvalueRef - let info : Ixon.ConstantInfo := - .defn (compiledDefinitionDataPayload definitionData - typeTarget valueTarget) - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state'.refs state'.univs) - constMeta - refine ⟨result, state', ?_, hcodec⟩ unfold Ix.CompileM.compileDefinitionDataInfo rw [run_bind, hpreseed] exact hrun @@ -391,11 +367,9 @@ theorem compileDefinitionDataInfo_run_ready_codecWF definitionData.type definitionData.value) (htypeBound : ExprWireBound definitionData.type) (hvalueBound : ExprWireBound definitionData.value) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileDefinitionDataInfo definitionData) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileDefinitionDataInfo definitionData)) := by let params := definitionData.levelParams.toList obtain ⟨preseedState, typeTarget, valueTarget, hpreseed, htables, htypeRef, hvalueRef, hexpr, hcanonState, harena, hfinal⟩ := @@ -521,20 +495,17 @@ theorem compileConstantInfo_theorem_run_ready_codecWF theoremVal.cnst.type theoremVal.value) (htypeBound : ExprWireBound theoremVal.cnst.type) (hvalueBound : ExprWireBound theoremVal.value) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstantInfo (.thmInfo theoremVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstantInfo (.thmInfo theoremVal))) := by let definitionData := Ix.CompileM.theoremValData theoremVal let singletonEnv := singletonDefinitionDataBlockEnv blockEnv definitionData - obtain ⟨result, state', hrun, hcodec⟩ := + have hrun := compileDefinitionDataInfo_run_ready_codecWF compileEnv singletonEnv hfree hclosed hlevelFaithful hexprFaithful definitionData state hexprCache hcanonCache hrefTable hunivTable htypeReady hvalueReady htableBound htypeBound hvalueBound - refine ⟨result, state', ?_, hcodec⟩ rw [compileConstantInfo_theorem_run_surgeryFree_eq compileEnv blockEnv state theoremVal hfree] exact hrun @@ -571,12 +542,10 @@ theorem compileConstantInfo_theorem_default_run_ready_codecWF theoremVal.cnst.type theoremVal.value) (htypeBound : ExprWireBound theoremVal.cnst.type) (hvalueBound : ExprWireBound theoremVal.value) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv (default : Ix.CompileM.BlockState) - (Ix.CompileM.compileConstantInfo (.thmInfo theoremVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + (Ix.CompileM.compileConstantInfo (.thmInfo theoremVal))) := by apply compileConstantInfo_theorem_run_ready_codecWF compileEnv blockEnv hfree hclosed hlevelFaithful hexprFaithful theoremVal (default : Ix.CompileM.BlockState) rfl CanonUnivCacheWF.empty @@ -658,20 +627,17 @@ theorem compileConstantInfo_opaque_run_ready_codecWF opaqueVal.cnst.type opaqueVal.value) (htypeBound : ExprWireBound opaqueVal.cnst.type) (hvalueBound : ExprWireBound opaqueVal.value) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstantInfo (.opaqueInfo opaqueVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstantInfo (.opaqueInfo opaqueVal))) := by let definitionData := Ix.CompileM.opaqueValData opaqueVal let singletonEnv := singletonDefinitionDataBlockEnv blockEnv definitionData - obtain ⟨result, state', hrun, hcodec⟩ := + have hrun := compileDefinitionDataInfo_run_ready_codecWF compileEnv singletonEnv hfree hclosed hlevelFaithful hexprFaithful definitionData state hexprCache hcanonCache hrefTable hunivTable htypeReady hvalueReady htableBound htypeBound hvalueBound - refine ⟨result, state', ?_, hcodec⟩ rw [compileConstantInfo_opaque_run_surgeryFree_eq compileEnv blockEnv state opaqueVal hfree] exact hrun @@ -708,12 +674,10 @@ theorem compileConstantInfo_opaque_default_run_ready_codecWF opaqueVal.cnst.type opaqueVal.value) (htypeBound : ExprWireBound opaqueVal.cnst.type) (hvalueBound : ExprWireBound opaqueVal.value) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv (default : Ix.CompileM.BlockState) - (Ix.CompileM.compileConstantInfo (.opaqueInfo opaqueVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + (Ix.CompileM.compileConstantInfo (.opaqueInfo opaqueVal))) := by apply compileConstantInfo_opaque_run_ready_codecWF compileEnv blockEnv hfree hclosed hlevelFaithful hexprFaithful opaqueVal (default : Ix.CompileM.BlockState) rfl CanonUnivCacheWF.empty diff --git a/Ix/Compile/Verify/CompileInductiveCodec.lean b/Ix/Compile/Verify/CompileInductiveCodec.lean index b02308772..5a8bd720c 100644 --- a/Ix/Compile/Verify/CompileInductiveCodec.lean +++ b/Ix/Compile/Verify/CompileInductiveCodec.lean @@ -596,15 +596,11 @@ theorem finishInductiveFamilyBlock_run_codecWF (inductiveVal : Ix.InductiveVal) (ind : Ixon.Inductive) (indMeta : Ixon.ConstantMeta) (ctorMetaPairs : Array (Ix.Name × Ixon.ConstantMeta)) - (ctorExprs : Array Ixon.Expr) - (hind : ind.wireWF) (hroots : ExprArrayWireWF ctorExprs) - (htables : BlockWireTablesWF state) : - ∃ result, - Ix.CompileM.CompileM.run compileEnv blockEnv state + (hind : ind.wireWF) (htables : BlockWireTablesWF state) : + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state (Ix.CompileM.finishInductiveFamilyBlock inductiveVal ind indMeta - ctorMetaPairs ctorExprs) = - .ok (result, state) ∧ - BlockResultCodecWF result := by + ctorMetaPairs)) := by let info : Ixon.ConstantInfo := .muts #[.indc ind] have hinfo : info.wireWF := by refine ⟨?_, ?_⟩ @@ -614,16 +610,25 @@ theorem finishInductiveFamilyBlock_run_codecWF have heq : member = .indc ind := by simpa [info] using hmem subst member exact hind - let block := Ix.CompileM.buildConstantWithSharing - info ctorExprs state.refs state.univs - let blockAddr := Address.blake3 (Ixon.ser block) - let projections := Ix.CompileM.buildInductiveProjections inductiveVal - indMeta ctorMetaPairs blockAddr - let result := Ix.CompileM.BlockResult.mk' block .empty projections - have hblock : block.wireWF := - buildConstantWithSharing_wireWF info ctorExprs hinfo hroots htables - refine ⟨result, ?_, BlockResult.mk'_codecWF block .empty projections hblock⟩ - rfl + have hrun : Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.finishInductiveFamilyBlock inductiveVal ind indMeta ctorMetaPairs) = + match Ix.CompileM.buildConstantWithSharing compileEnv.sharingLimits info + state.refs state.univs with + | .ok block => .ok (Ix.CompileM.BlockResult.mk' block .empty + (Ix.CompileM.buildInductiveProjections inductiveVal indMeta ctorMetaPairs + (Address.blake3 (Ixon.ser block))), state) + | .error err => .error err := by + simp only [Ix.CompileM.finishInductiveFamilyBlock, Ix.CompileM.buildBlockConstant, + run_bind, run_getBlockState_eq, run_read_eq, run_liftSharing_eq] + cases Ix.CompileM.buildConstantWithSharing compileEnv.sharingLimits info + state.refs state.univs <;> rfl + rw [hrun] + cases hbuild : Ix.CompileM.buildConstantWithSharing compileEnv.sharingLimits info + state.refs state.univs with + | ok block => + exact .inl ⟨_, _, rfl, BlockResult.mk'_codecWF block .empty _ + (buildConstantWithSharing_wireWF hinfo htables hbuild)⟩ + | error err => exact .inr ⟨info, state, err, hbuild, rfl⟩ theorem compileInductiveFamilyBlock_run_ordinary_codecWF (compileEnv : Ix.CompileM.CompileEnv) @@ -656,21 +661,18 @@ theorem compileInductiveFamilyBlock_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (inductiveCompileBlockEnv blockEnv inductiveVal) snapshot) ctor.cnst.type = some target) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileInductiveFamilyBlock inductiveVal ctorVals) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileInductiveFamilyBlock inductiveVal ctorVals)) := by obtain ⟨ind, indMeta, ctorMetaPairs, ctorExprs, state', hindRun, - htables', _, hind, hroots, _, _⟩ := + htables', _, hind, _, _, _⟩ := compileInductive_run_ordinary_wireWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables inductiveVal ctorVals htypeSource hctorSources htypeBound hctorBounds hctorCount hstate htypeRef hctorRefs - obtain ⟨result, hfinish, hcodec⟩ := + have hfinish := finishInductiveFamilyBlock_run_codecWF compileEnv blockEnv state' - inductiveVal ind indMeta ctorMetaPairs ctorExprs hind hroots htables' - refine ⟨result, state', ?_, hcodec⟩ + inductiveVal ind indMeta ctorMetaPairs hind htables' unfold Ix.CompileM.compileInductiveFamilyBlock rw [run_bind, hindRun] exact hfinish @@ -710,17 +712,14 @@ theorem compileInductiveFamilyInfo_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (inductiveCompileBlockEnv blockEnv inductiveVal) snapshot) ctor.cnst.type = some target) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileInductiveFamilyInfo inductiveVal ctorVals) = - .ok (result, state') ∧ - BlockResultCodecWF result := by - obtain ⟨result, state', hrun, hcodec⟩ := + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileInductiveFamilyInfo inductiveVal ctorVals)) := by + have hrun := compileInductiveFamilyBlock_run_ordinary_codecWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables inductiveVal ctorVals htypeSource hctorSources htypeBound hctorBounds hctorCount hstate htypeRef hctorRefs - refine ⟨result, state', ?_, hcodec⟩ unfold Ix.CompileM.compileInductiveFamilyInfo rw [run_bind, hpreseed] exact hrun @@ -785,11 +784,9 @@ theorem compileInductiveFamilyInfo_run_ready_codecWF Ix.CompileM.inductiveSourceExprs inductiveVal ctorVals, ExprWireBound source) (hctorCount : ctorVals.size < UInt64.size) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileInductiveFamilyInfo inductiveVal ctorVals) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileInductiveFamilyInfo inductiveVal ctorVals)) := by let params := inductiveVal.cnst.levelParams.toList let rest := ctorVals.toList.map (·.cnst.type) have htypeMem : inductiveVal.cnst.type ∈ @@ -970,27 +967,30 @@ theorem compileInductiveInfo_run_ready_codecWF Ix.CompileM.inductiveSourceExprs inductiveVal ctorVals, ExprWireBound source) (hctorCount : ctorVals.size < UInt64.size) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileInductiveInfo inductiveVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileInductiveInfo inductiveVal)) := by have hlookupRun := lookupInductiveConstructors_run_of_lookup compileEnv blockEnv state inductiveVal ctorVals hlookup hfree - obtain ⟨result, state', hfamily, hcodec⟩ := + have hfamily := compileInductiveFamilyInfo_run_ready_codecWF compileEnv (inductiveFamilyBlockEnv blockEnv inductiveVal ctorVals) hfree hclosed hlevelFaithful hexprFaithful inductiveVal ctorVals state hexprCache hcanonCache hrefTable hunivTable hparams hready htableBound hexprBounds hctorCount - refine ⟨result, state', ?_, hcodec⟩ - unfold Ix.CompileM.compileInductiveInfo - rw [run_bind, hlookupRun] - simpa only [inductiveFamilyBlockEnv] using - run_withMutCtx compileEnv blockEnv state - (Ix.CompileM.buildInductiveMutCtx inductiveVal ctorVals) - (Ix.CompileM.compileInductiveFamilyInfo inductiveVal ctorVals) |>.trans - hfamily + have hgoal : Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileInductiveInfo inductiveVal) = + Ix.CompileM.CompileM.run compileEnv + (inductiveFamilyBlockEnv blockEnv inductiveVal ctorVals) state + (Ix.CompileM.compileInductiveFamilyInfo inductiveVal ctorVals) := by + unfold Ix.CompileM.compileInductiveInfo + rw [run_bind, hlookupRun] + simpa only [inductiveFamilyBlockEnv] using + run_withMutCtx compileEnv blockEnv state + (Ix.CompileM.buildInductiveMutCtx inductiveVal ctorVals) + (Ix.CompileM.compileInductiveFamilyInfo inductiveVal ctorVals) + rw [hgoal] + exact hfamily def singletonInductiveBlockEnv (blockEnv : Ix.CompileM.BlockEnv) (inductiveVal : Ix.InductiveVal) : Ix.CompileM.BlockEnv := @@ -1073,18 +1073,15 @@ theorem compileConstantInfo_inductive_run_ready_codecWF Ix.CompileM.inductiveSourceExprs inductiveVal ctorVals, ExprWireBound source) (hctorCount : ctorVals.size < UInt64.size) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstantInfo (.inductInfo inductiveVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstantInfo (.inductInfo inductiveVal))) := by let singletonEnv := singletonInductiveBlockEnv blockEnv inductiveVal - obtain ⟨result, state', hrun, hcodec⟩ := + have hrun := compileInductiveInfo_run_ready_codecWF compileEnv singletonEnv hfree hclosed hlevelFaithful hexprFaithful inductiveVal ctorVals state hlookup hexprCache hcanonCache hrefTable hunivTable hparams hready htableBound hexprBounds hctorCount - refine ⟨result, state', ?_, hcodec⟩ rw [compileConstantInfo_inductive_run_surgeryFree_eq compileEnv blockEnv state inductiveVal hfree] exact hrun @@ -1122,12 +1119,10 @@ theorem compileConstantInfo_inductive_default_run_ready_codecWF Ix.CompileM.inductiveSourceExprs inductiveVal ctorVals, ExprWireBound source) (hctorCount : ctorVals.size < UInt64.size) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv (default : Ix.CompileM.BlockState) - (Ix.CompileM.compileConstantInfo (.inductInfo inductiveVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + (Ix.CompileM.compileConstantInfo (.inductInfo inductiveVal))) := by apply compileConstantInfo_inductive_run_ready_codecWF compileEnv blockEnv hfree hclosed hlevelFaithful hexprFaithful inductiveVal ctorVals (default : Ix.CompileM.BlockState) hlookup rfl CanonUnivCacheWF.empty @@ -1172,19 +1167,16 @@ theorem compileConstructorInfo_run_ready_codecWF Ix.CompileM.inductiveSourceExprs inductiveVal ctorVals, ExprWireBound source) (hctorCount : ctorVals.size < UInt64.size) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstructorInfo constructorVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstructorInfo constructorVal)) := by have hparentRun := findConst_run_of_get compileEnv blockEnv state constructorVal.induct (.inductInfo inductiveVal) hparent - obtain ⟨result, state', hrun, hcodec⟩ := + have hrun := compileInductiveInfo_run_ready_codecWF compileEnv blockEnv hfree hclosed hlevelFaithful hexprFaithful inductiveVal ctorVals state hlookup hexprCache hcanonCache hrefTable hunivTable hparams hready htableBound hexprBounds hctorCount - refine ⟨result, state', ?_, hcodec⟩ unfold Ix.CompileM.compileConstructorInfo rw [run_bind, hparentRun] exact hrun @@ -1272,18 +1264,15 @@ theorem compileConstantInfo_constructor_run_ready_codecWF Ix.CompileM.inductiveSourceExprs inductiveVal ctorVals, ExprWireBound source) (hctorCount : ctorVals.size < UInt64.size) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstantInfo (.ctorInfo constructorVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstantInfo (.ctorInfo constructorVal))) := by let singletonEnv := singletonConstructorBlockEnv blockEnv constructorVal - obtain ⟨result, state', hrun, hcodec⟩ := + have hrun := compileConstructorInfo_run_ready_codecWF compileEnv singletonEnv hfree hclosed hlevelFaithful hexprFaithful constructorVal inductiveVal ctorVals state hparent hlookup hexprCache hcanonCache hrefTable hunivTable hparams hready htableBound hexprBounds hctorCount - refine ⟨result, state', ?_, hcodec⟩ rw [compileConstantInfo_constructor_run_surgeryFree_eq compileEnv blockEnv state constructorVal hfree] exact hrun @@ -1323,12 +1312,10 @@ theorem compileConstantInfo_constructor_default_run_ready_codecWF Ix.CompileM.inductiveSourceExprs inductiveVal ctorVals, ExprWireBound source) (hctorCount : ctorVals.size < UInt64.size) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv (default : Ix.CompileM.BlockState) - (Ix.CompileM.compileConstantInfo (.ctorInfo constructorVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + (Ix.CompileM.compileConstantInfo (.ctorInfo constructorVal))) := by apply compileConstantInfo_constructor_run_ready_codecWF compileEnv blockEnv hfree hclosed hlevelFaithful hexprFaithful constructorVal inductiveVal ctorVals (default : Ix.CompileM.BlockState) hparent hlookup rfl diff --git a/Ix/Compile/Verify/CompileMeta.lean b/Ix/Compile/Verify/CompileMeta.lean index bd7a7e0fb..8e6e986e5 100644 --- a/Ix/Compile/Verify/CompileMeta.lean +++ b/Ix/Compile/Verify/CompileMeta.lean @@ -17,18 +17,18 @@ def concatSerialized (parts : Array ByteArray) : ByteArray := /-- Pure reference encoding for a source substring. -/ def serializeIxSubstringRef (source : Ix.Substring) : ByteArray := (Address.blake3 source.str.toUTF8).hash ++ - Ix.CompileM.putTag0 source.startPos ++ - Ix.CompileM.putTag0 source.stopPos + Ix.CompileM.tagN0Bytes source.startPos ++ + Ix.CompileM.tagN0Bytes source.stopPos /-- Pure reference encoding for source-location metadata. -/ def serializeIxSourceInfoRef : Ix.SourceInfo → ByteArray | .original leading leadingPos trailing trailingPos => ByteArray.mk #[0] ++ serializeIxSubstringRef leading ++ - Ix.CompileM.putTag0 leadingPos ++ serializeIxSubstringRef trailing ++ - Ix.CompileM.putTag0 trailingPos + Ix.CompileM.tagN0Bytes leadingPos ++ serializeIxSubstringRef trailing ++ + Ix.CompileM.tagN0Bytes trailingPos | .synthetic start stop canonical => - ByteArray.mk #[1] ++ Ix.CompileM.putTag0 start ++ - Ix.CompileM.putTag0 stop ++ ByteArray.mk #[if canonical then 1 else 0] + ByteArray.mk #[1] ++ Ix.CompileM.tagN0Bytes start ++ + Ix.CompileM.tagN0Bytes stop ++ ByteArray.mk #[if canonical then 1 else 0] | .none => ByteArray.mk #[2] /-- Pure reference encoding for a preresolved syntax identifier. -/ @@ -36,7 +36,7 @@ def serializeIxSyntaxPreresolvedRef : Ix.SyntaxPreresolved → ByteArray | .namespace name => ByteArray.mk #[0] ++ name.getHash.hash | .decl name aliases => let header := ByteArray.mk #[1] ++ name.getHash.hash ++ - Ix.CompileM.putTag0 aliases.size + Ix.CompileM.tagN0Bytes aliases.size let aliasHashes := aliases.map fun aliasValue => (Address.blake3 aliasValue.toUTF8).hash header ++ concatSerialized aliasHashes @@ -49,7 +49,7 @@ def serializeIxSyntaxRef (source : Ix.Syntax) : ByteArray := let serializedArgs := args.attach.map fun arg => serializeIxSyntaxRef arg.1 ByteArray.mk #[1] ++ serializeIxSourceInfoRef info ++ kind.getHash.hash ++ - Ix.CompileM.putTag0 args.size ++ concatSerialized serializedArgs + Ix.CompileM.tagN0Bytes args.size ++ concatSerialized serializedArgs | .atom info value => ByteArray.mk #[2] ++ serializeIxSourceInfoRef info ++ (Address.blake3 value.toUTF8).hash @@ -57,7 +57,7 @@ def serializeIxSyntaxRef (source : Ix.Syntax) : ByteArray := let serializedPres := preresolved.map serializeIxSyntaxPreresolvedRef ByteArray.mk #[3] ++ serializeIxSourceInfoRef info ++ serializeIxSubstringRef rawValue ++ value.getHash.hash ++ - Ix.CompileM.putTag0 preresolved.size ++ concatSerialized serializedPres + Ix.CompileM.tagN0Bytes preresolved.size ++ concatSerialized serializedPres termination_by sizeOf source decreasing_by simp_wf diff --git a/Ix/Compile/Verify/CompileMetaStore.lean b/Ix/Compile/Verify/CompileMetaStore.lean index a9ffdc7a4..c84bd913d 100644 --- a/Ix/Compile/Verify/CompileMetaStore.lean +++ b/Ix/Compile/Verify/CompileMetaStore.lean @@ -946,8 +946,8 @@ private theorem serializeIxSubstring_run_strict hsupported.blobs (by simp [substringStoreItems]) obtain ⟨addr, state', hrun, hstep⟩ := storeString_run_strict compileEnv blockEnv hfaithful source.str hstate hbytes - refine ⟨addr.hash ++ Ix.CompileM.putTag0 source.startPos ++ - Ix.CompileM.putTag0 source.stopPos, state', ?_, ?_⟩ + refine ⟨addr.hash ++ Ix.CompileM.tagN0Bytes source.startPos ++ + Ix.CompileM.tagN0Bytes source.stopPos, state', ?_, ?_⟩ · rw [Ix.CompileM.serializeIxSubstring, run_bind_strict compileEnv blockEnv state _ _, hrun] rfl @@ -971,8 +971,8 @@ private theorem serializeIxSourceInfo_run_strict serializeIxSubstring_run_strict compileEnv blockEnv hfaithful leadingState hleadingStep.strict trailing hsupported.right refine ⟨ByteArray.mk #[0] ++ leadingBytes ++ - Ix.CompileM.putTag0 leadingPos ++ trailingBytes ++ - Ix.CompileM.putTag0 trailingPos, finalState, ?_, ?_⟩ + Ix.CompileM.tagN0Bytes leadingPos ++ trailingBytes ++ + Ix.CompileM.tagN0Bytes trailingPos, finalState, ?_, ?_⟩ · rw [Ix.CompileM.serializeIxSourceInfo, run_bind_strict compileEnv blockEnv state _ _, hleadingRun] simp only @@ -1027,7 +1027,7 @@ private theorem serializeIxSyntaxPreresolved_run_strict rw [MetaStoreItems.concat_singletonBlobs] exact haliasSupported) refine ⟨ByteArray.mk #[1] ++ name.getHash.hash ++ - Ix.CompileM.putTag0 aliases.size ++ + Ix.CompileM.tagN0Bytes aliases.size ++ aliasAddrs.foldl (fun bytes addr => bytes ++ addr.hash) ByteArray.empty, finalState, ?_, ?_⟩ @@ -1098,7 +1098,7 @@ private theorem serializeIxSyntax_run_strict_effect (fun current arg hcurrent harg => ih arg current hcurrent harg) infoState hinfoStep.strict args.attach hargsSupported refine ⟨ByteArray.mk #[1] ++ infoBytes ++ kind.getHash.hash ++ - Ix.CompileM.putTag0 args.size ++ + Ix.CompileM.tagN0Bytes args.size ++ serializedArgs.foldl (fun bytes arg => bytes ++ arg) ByteArray.empty, finalState, ?_, ?_⟩ · rw [Ix.CompileM.serializeIxSyntax.eq_2, @@ -1155,7 +1155,7 @@ private theorem serializeIxSyntax_run_strict_effect serializeIxSyntaxPreresolved_array_run_strict compileEnv blockEnv hfaithful rawState hrawStep.strict preresolved hpreSupported refine ⟨ByteArray.mk #[3] ++ infoBytes ++ rawBytes ++ - value.getHash.hash ++ Ix.CompileM.putTag0 preresolved.size ++ + value.getHash.hash ++ Ix.CompileM.tagN0Bytes preresolved.size ++ serializedPres.foldl (fun bytes pr => bytes ++ pr) ByteArray.empty, finalState, ?_, ?_⟩ · rw [Ix.CompileM.serializeIxSyntax.eq_4, diff --git a/Ix/Compile/Verify/CompileMutualCodec.lean b/Ix/Compile/Verify/CompileMutualCodec.lean index d5e192bf1..548abd897 100644 --- a/Ix/Compile/Verify/CompileMutualCodec.lean +++ b/Ix/Compile/Verify/CompileMutualCodec.lean @@ -1108,75 +1108,126 @@ theorem standaloneMutConstInfo?_wireWF next hsize => simp at hinfo -/-- Both the standalone-collapse and general mutual-wrapper branches produce -an exactly decodable main block. Projection construction is deliberately -irrelevant to this codec postcondition. -/ -theorem buildCompiledMutualBlock_codecWF - (classes : List (List Ix.MutConst)) - (payloads : Array Ixon.MutConst) (roots : Array Ixon.Expr) - (metas : Array (Ix.Name × Ixon.ConstantMeta)) - (cache : Ix.CompileM.BlockState) +/-- Both the standalone-collapse and general mutual-wrapper branches build +their main block with `buildConstantWithSharing` on a wire-safe payload, so a +successful assembly is exactly decodable. Projection construction is +deliberately irrelevant to this codec postcondition. -/ +theorem buildCompiledMutualBlock_codecWF {limits : Ix.Sharing.Exact.Limits} + {classes : List (List Ix.MutConst)} + {payloads : Array Ixon.MutConst} + {metas : Array (Ix.Name × Ixon.ConstantMeta)} + {cache : Ix.CompileM.BlockState} {result : Ix.CompileM.BlockResult} (hpayloadCount : payloads.size < UInt64.size) (hpayloads : ∀ payload ∈ payloads, payload.wireWF) - (hroots : ExprArrayWireWF roots) - (htables : BlockWireTablesWF cache) : - BlockResultCodecWF - (Ix.CompileM.buildCompiledMutualBlock classes payloads roots metas - cache) := by - generalize hstandalone : - Ix.CompileM.standaloneMutConstInfo? payloads = standalone - cases standalone with - | none => - let info : Ixon.ConstantInfo := .muts payloads - have hinfo : info.wireWF := ⟨hpayloadCount, hpayloads⟩ - let block := Ix.CompileM.buildConstantWithSharing info roots - cache.refs cache.univs - have hblock : block.wireWF := - buildConstantWithSharing_wireWF info roots hinfo hroots htables - simpa [Ix.CompileM.buildCompiledMutualBlock, hstandalone, info, - block] using - (BlockResult.mk'_codecWF block .empty - (Ix.CompileM.buildMutualProjections classes - (Address.blake3 (Ixon.ser block)) metas) hblock) - | some info => - have hinfo : info.wireWF := - standaloneMutConstInfo?_wireWF payloads hpayloads hstandalone - let block := Ix.CompileM.buildConstantWithSharing info roots - cache.refs cache.univs - have hblock : block.wireWF := - buildConstantWithSharing_wireWF info roots hinfo hroots htables - simpa [Ix.CompileM.buildCompiledMutualBlock, hstandalone, block] using - (BlockResult.mk'_codecWF block .empty - (Ix.CompileM.buildStandaloneMutualProjections classes block metas) - hblock) - -/-- The state-reading finalizer is total, leaves the compiler state unchanged, -and inherits the pure assembler's codec postcondition. -/ + (htables : BlockWireTablesWF cache) + (h : Ix.CompileM.buildCompiledMutualBlock limits classes payloads metas + cache = .ok result) : + BlockResultCodecWF result := by + unfold Ix.CompileM.buildCompiledMutualBlock at h + split at h + next info hstandalone => + have hinfo : info.wireWF := + standaloneMutConstInfo?_wireWF payloads hpayloads hstandalone + cases hbuild : Ix.CompileM.buildConstantWithSharing limits info + cache.refs cache.univs with + | error err => simp [hbuild, bind, Except.bind] at h + | ok block => + simp only [hbuild, bind, Except.bind, pure, Except.pure, + Except.ok.injEq] at h + subst h + exact BlockResult.mk'_codecWF block .empty _ + (buildConstantWithSharing_wireWF hinfo htables hbuild) + next => + have hinfo : (Ixon.ConstantInfo.muts payloads).wireWF := + ⟨hpayloadCount, hpayloads⟩ + cases hbuild : Ix.CompileM.buildConstantWithSharing limits + (.muts payloads) cache.refs cache.univs with + | error err => simp [hbuild, bind, Except.bind] at h + | ok block => + simp only [hbuild, bind, Except.bind, pure, Except.pure, + Except.ok.injEq] at h + subst h + exact BlockResult.mk'_codecWF block .empty _ + (buildConstantWithSharing_wireWF hinfo htables hbuild) + +/-- The mutual assembler fails only with the error of its sharing builder. -/ +theorem buildCompiledMutualBlock_error {limits : Ix.Sharing.Exact.Limits} + {classes : List (List Ix.MutConst)} + {payloads : Array Ixon.MutConst} + {metas : Array (Ix.Name × Ixon.ConstantMeta)} + {cache : Ix.CompileM.BlockState} {err : Ix.CompileM.CompileError} + (h : Ix.CompileM.buildCompiledMutualBlock limits classes payloads metas + cache = .error err) : + ∃ info, Ix.CompileM.buildConstantWithSharing limits info + cache.refs cache.univs = .error err := by + unfold Ix.CompileM.buildCompiledMutualBlock at h + split at h + next info _ => + cases hbuild : Ix.CompileM.buildConstantWithSharing limits info + cache.refs cache.univs with + | error e => + simp only [hbuild, bind, Except.bind, Except.error.injEq] at h + subst h + exact ⟨info, hbuild⟩ + | ok block => simp [hbuild, bind, Except.bind, pure, Except.pure] at h + next => + cases hbuild : Ix.CompileM.buildConstantWithSharing limits + (.muts payloads) cache.refs cache.univs with + | error e => + simp only [hbuild, bind, Except.bind, Except.error.injEq] at h + subst h + exact ⟨_, hbuild⟩ + | ok block => simp [hbuild, bind, Except.bind, pure, Except.pure] at h + +/-- The state-reading finalizer runs the assembler under +`CompileEnv.sharingLimits`, leaves the compiler state unchanged, and fails +exactly when the assembler does. -/ +theorem finishMutualCompilation_run + (compileEnv : Ix.CompileM.CompileEnv) + (blockEnv : Ix.CompileM.BlockEnv) + (state : Ix.CompileM.BlockState) + (classes : List (List Ix.MutConst)) + (payloads : Array Ixon.MutConst) + (metas : Array (Ix.Name × Ixon.ConstantMeta)) : + Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.finishMutualCompilation classes payloads metas) = + match Ix.CompileM.buildCompiledMutualBlock compileEnv.sharingLimits + classes payloads metas state with + | .ok result => .ok (result, state) + | .error err => .error err := by + simp only [Ix.CompileM.finishMutualCompilation, run_bind, + run_getBlockState_eq, run_read_eq] + cases Ix.CompileM.buildCompiledMutualBlock compileEnv.sharingLimits + classes payloads metas state <;> rfl + +/-- The finalizer inherits the assembler's codec postcondition; its only +failure is the sharing builder's. -/ theorem finishMutualCompilation_run_codecWF (compileEnv : Ix.CompileM.CompileEnv) (blockEnv : Ix.CompileM.BlockEnv) (state : Ix.CompileM.BlockState) (classes : List (List Ix.MutConst)) - (payloads : Array Ixon.MutConst) (roots : Array Ixon.Expr) + (payloads : Array Ixon.MutConst) (metas : Array (Ix.Name × Ixon.ConstantMeta)) (hpayloadCount : payloads.size < UInt64.size) (hpayloads : ∀ payload ∈ payloads, payload.wireWF) - (hroots : ExprArrayWireWF roots) (htables : BlockWireTablesWF state) : - ∃ result, - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.finishMutualCompilation classes payloads roots metas) = - .ok (result, state) ∧ - BlockResultCodecWF result := by - let result := Ix.CompileM.buildCompiledMutualBlock classes payloads roots - metas state - refine ⟨result, rfl, ?_⟩ - exact buildCompiledMutualBlock_codecWF classes payloads roots metas state - hpayloadCount hpayloads hroots htables + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.finishMutualCompilation classes payloads metas)) := by + rw [finishMutualCompilation_run] + cases hbuild : Ix.CompileM.buildCompiledMutualBlock compileEnv.sharingLimits + classes payloads metas state with + | ok result => + exact .inl ⟨result, state, rfl, + buildCompiledMutualBlock_codecWF hpayloadCount hpayloads htables hbuild⟩ + | error err => + obtain ⟨info, hinfo⟩ := buildCompiledMutualBlock_error hbuild + exact .inr ⟨info, state, err, hinfo, rfl⟩ /-- The complete post-preseed mutual payload phase compiles all class members, retains one representative per nonempty class, and returns a codec-safe main -block through either assembler branch. -/ +block through either assembler branch, or fails only in the sharing builder. -/ theorem compileMutualPayload_run_ordinary_codecWF (compileEnv : Ix.CompileM.CompileEnv) (blockEnv : Ix.CompileM.BlockEnv) @@ -1192,14 +1243,11 @@ theorem compileMutualPayload_run_ordinary_codecWF (hcount : nonemptyMutConstClassCount classes < UInt64.size) (state : Ix.CompileM.BlockState) (hstate : MutualMemberStateWF snapshot state) : - ∃ result finalState, - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileMutualPayload classes) = - .ok (result, finalState) ∧ - MutualMemberStateWF snapshot finalState ∧ - BlockResultCodecWF result := by - obtain ⟨payloads, roots, metas, compiledState, hcompile, - hcompiledState, hpayloads, hroots, hsize⟩ := + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileMutualPayload classes)) := by + obtain ⟨payloads, _roots, metas, compiledState, hcompile, + hcompiledState, hpayloads, _hroots, hsize⟩ := compileMutConsts_run_ordinary_wireWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables classes hmembers state hstate @@ -1208,11 +1256,9 @@ theorem compileMutualPayload_run_ordinary_codecWF exact hcount have hcompiledTables : BlockWireTablesWF compiledState := htables.of_exprTableView_eq hcompiledState.tables - obtain ⟨result, hfinish, hcodec⟩ := + have hfinish := finishMutualCompilation_run_codecWF compileEnv blockEnv compiledState - classes payloads roots metas hpayloadCount hpayloads hroots - hcompiledTables - refine ⟨result, compiledState, ?_, hcompiledState, hcodec⟩ + classes payloads metas hpayloadCount hpayloads hcompiledTables unfold Ix.CompileM.compileMutualPayload rw [run_bind, hcompile] exact hfinish @@ -1340,29 +1386,26 @@ theorem compileMutualBlock_run_of_preseed_ordinary_codecWF MutConstOrdinaryReady compileEnv (mutualCompileBlockEnv blockEnv classes) snapshot levelSupport source) (hcount : nonemptyMutConstClassCount classes < UInt64.size) : - ∃ result finalState, - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileMutualBlock classes) = - .ok (result, finalState) ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileMutualBlock classes)) := by have hstart : MutualMemberStateWF snapshot snapshot := ⟨rfl, hexprCache, hcanonCache⟩ - obtain ⟨result, finalState, hpayload, hfinalState, hcodec⟩ := + have hpayload := compileMutualPayload_run_ordinary_codecWF compileEnv (mutualCompileBlockEnv blockEnv classes) snapshot hfree hclosed hlevelFaithful hexprFaithful htables classes hmembers hcount snapshot hstart - refine ⟨result, finalState, ?_, hcodec⟩ unfold Ix.CompileM.compileMutualBlock rw [run_bind, auditMutConstClassesPlanHeads_run_surgeryFree compileEnv blockEnv state classes hfree] simp only rw [run_withMutCtx] - change Ix.CompileM.CompileM.run compileEnv + change SharingRunOK compileEnv.sharingLimits (Ix.CompileM.CompileM.run compileEnv (mutualCompileBlockEnv blockEnv classes) state (do Ix.CompileM.preseedExprTables (Ix.CompileM.mutualPreseedExprs classes) - Ix.CompileM.compileMutualPayload classes) = _ + Ix.CompileM.compileMutualPayload classes)) rw [run_bind, hpreseed] exact hpayload @@ -1400,11 +1443,9 @@ theorem compileMutualBlock_run_ready_codecWF (hmembers : ∀ constClass ∈ classes, ∀ source ∈ constClass, MutConstOrdinaryBounds source) (hcount : nonemptyMutConstClassCount classes < UInt64.size) : - ∃ result finalState, - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileMutualBlock classes) = - .ok (result, finalState) ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileMutualBlock classes)) := by let mutualEnv := mutualCompileBlockEnv blockEnv classes let inputs := Ix.CompileM.mutualPreseedInputs classes obtain ⟨snapshot, hpreseed, htables, htargets, hsnapshotExpr, @@ -1466,11 +1507,9 @@ theorem compileMutualBlock_run_uniform_ready_codecWF (hmembers : ∀ constClass ∈ classes, ∀ source ∈ constClass, MutConstOrdinaryBounds source) (hcount : nonemptyMutConstClassCount classes < UInt64.size) : - ∃ result finalState, - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileMutualBlock classes) = - .ok (result, finalState) ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileMutualBlock classes)) := by have hseen := heterogeneousPreseedSeenSafe_of_uniform compileEnv (mutualCompileBlockEnv blockEnv classes) state params hclosed hlevelFaithful hexprFaithful @@ -1508,11 +1547,9 @@ theorem compileMutualBlock_run_member_uniform_ready_codecWF (hmembers : ∀ constClass ∈ classes, ∀ source ∈ constClass, MutConstOrdinaryBounds source) (hcount : nonemptyMutConstClassCount classes < UInt64.size) : - ∃ result finalState, - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileMutualBlock classes) = - .ok (result, finalState) ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileMutualBlock classes)) := by apply compileMutualBlock_run_uniform_ready_codecWF compileEnv blockEnv state hfree hclosed hlevelFaithful hexprFaithful classes params hexprCache hcanonCache hrefTable hunivTable @@ -3799,17 +3836,14 @@ theorem compileMutualConstants_run_of_collected_sorted_codecWF (hmembers : ∀ constClass ∈ classes, ∀ source ∈ constClass, MutConstOrdinaryBounds source) (hcount : nonemptyMutConstClassCount classes < UInt64.size) : - ∃ result finalState, - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileMutualConstants all) = - .ok (result, finalState) ∧ - BlockResultCodecWF result := by - obtain ⟨result, finalState, hblock, hcodec⟩ := + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileMutualConstants all)) := by + have hblock := compileMutualBlock_run_member_uniform_ready_codecWF compileEnv blockEnv collectState hfree hclosed hlevelFaithful hexprFaithful classes params hexprCache hcanonCache hrefTable hunivTable huniform hready htableBound hmembers hcount - refine ⟨result, finalState, ?_, hcodec⟩ unfold Ix.CompileM.compileMutualConstants rw [run_bind, hcollect] simp only @@ -3855,18 +3889,15 @@ theorem compileConstant_run_mutual_of_collected_sorted_codecWF (hmembers : ∀ constClass ∈ classes, ∀ source ∈ constClass, MutConstOrdinaryBounds source) (hcount : nonemptyMutConstClassCount classes < UInt64.size) : - ∃ result finalState, - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstant name) = - .ok (result, finalState) ∧ - BlockResultCodecWF result := by - obtain ⟨result, finalState, hmutual, hcodec⟩ := + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstant name)) := by + have hmutual := compileMutualConstants_run_of_collected_sorted_codecWF compileEnv blockEnv state collectState sortState hfree hclosed hlevelFaithful hexprFaithful blockEnv.all sources classes params hcollect hsort hexprCache hcanonCache hrefTable hunivTable huniform hready htableBound hmembers hcount - refine ⟨result, finalState, ?_, hcodec⟩ unfold Ix.CompileM.compileConstant rw [run_bind, findConst_run_of_get_entry compileEnv blockEnv state name constInfo hlookup] @@ -3921,11 +3952,9 @@ theorem compileConstant_run_mutual_of_lookup_sorted_codecWF (Ix.CompileM.mutualPreseedInputs classes)) (hmembers : ∀ source ∈ resolved.filterMap id, MutConstOrdinaryBounds source) : - ∃ result finalState, - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstant name) = - .ok (result, finalState) ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstant name)) := by have hsourceCount : (resolved.filterMap id).length < UInt64.size := collectedMutConstSourceCount_lt compileEnv blockEnv.all resolved hlookups hallCount diff --git a/Ix/Compile/Verify/CompileQuotientCodec.lean b/Ix/Compile/Verify/CompileQuotientCodec.lean index f3dbf6255..7abdf4e8e 100644 --- a/Ix/Compile/Verify/CompileQuotientCodec.lean +++ b/Ix/Compile/Verify/CompileQuotientCodec.lean @@ -196,18 +196,9 @@ theorem compileQuotientBlock_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (quotientCompileBlockEnv blockEnv quotientVal) snapshot) quotientVal.cnst.type = some target) : - ∃ constMeta state', - let info : Ixon.ConstantInfo := - .quot (compiledQuotientPayload quotientVal target) - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state'.refs state'.univs) - constMeta - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileQuotientBlock quotientVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileQuotientBlock quotientVal)) := by obtain ⟨constMeta, state', hquotient, htables', hinfo⟩ := compileQuotient_run_ordinary_wireWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables quotientVal hsource @@ -216,9 +207,6 @@ theorem compileQuotientBlock_run_ordinary_codecWF compileEnv blockEnv state' (.quot (compiledQuotientPayload quotientVal target)) constMeta hinfo htables' - refine ⟨constMeta, state', ?_⟩ - dsimp only - dsimp only at hfinish unfold Ix.CompileM.compileQuotientBlock rw [run_bind, hquotient] exact hfinish @@ -248,23 +236,13 @@ theorem compileQuotientInfo_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (quotientCompileBlockEnv blockEnv quotientVal) snapshot) quotientVal.cnst.type = some target) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileQuotientInfo quotientVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by - obtain ⟨constMeta, state', hrun, hcodec⟩ := + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileQuotientInfo quotientVal)) := by + have hrun := compileQuotientBlock_run_ordinary_codecWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables quotientVal hsource hbound hstate href - let info : Ixon.ConstantInfo := - .quot (compiledQuotientPayload quotientVal target) - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state'.refs state'.univs) - constMeta - refine ⟨result, state', ?_, hcodec⟩ unfold Ix.CompileM.compileQuotientInfo rw [run_bind, hpreseed] exact hrun @@ -338,11 +316,9 @@ theorem compileConstantInfo_quotient_run_ready_codecWF (singletonQuotientBlockEnv blockEnv quotientVal) state quotientVal.cnst.type) (hbound : ExprWireBound quotientVal.cnst.type) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstantInfo (.quotInfo quotientVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstantInfo (.quotInfo quotientVal))) := by let singletonEnv := singletonQuotientBlockEnv blockEnv quotientVal obtain ⟨preseedState, target, hpreseed, htables, href, hpreseedExpr, hpreseedCanon, hpreseedArena, hpreseedFinal⟩ := @@ -357,12 +333,11 @@ theorem compileConstantInfo_quotient_run_ready_codecWF axiomCompileStartState_frozen compileEnv (quotientCompileBlockEnv singletonEnv quotientVal) levelSupport preseedState hexprPreseed hpreseedCanon - obtain ⟨result, state', hrun, hcodec⟩ := + have hrun := compileQuotientInfo_run_ordinary_codecWF compileEnv singletonEnv preseedState hfree hclosed hlevelFaithful hexprFaithful htables quotientVal state preseedState hpreseed hready.supported hbound hstate href - refine ⟨result, state', ?_, hcodec⟩ rw [compileConstantInfo_quotient_run_surgeryFree_eq compileEnv blockEnv state quotientVal hfree] exact hrun @@ -387,12 +362,10 @@ theorem compileConstantInfo_quotient_default_run_ready_codecWF (singletonQuotientBlockEnv blockEnv quotientVal) (default : Ix.CompileM.BlockState) quotientVal.cnst.type) (hbound : ExprWireBound quotientVal.cnst.type) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv (default : Ix.CompileM.BlockState) - (Ix.CompileM.compileConstantInfo (.quotInfo quotientVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + (Ix.CompileM.compileConstantInfo (.quotInfo quotientVal))) := by apply compileConstantInfo_quotient_run_ready_codecWF compileEnv blockEnv hfree hclosed hlevelFaithful hexprFaithful quotientVal (default : Ix.CompileM.BlockState) rfl CanonUnivCacheWF.empty diff --git a/Ix/Compile/Verify/CompileRecursorCodec.lean b/Ix/Compile/Verify/CompileRecursorCodec.lean index be60b7c07..b22aa6cbe 100644 --- a/Ix/Compile/Verify/CompileRecursorCodec.lean +++ b/Ix/Compile/Verify/CompileRecursorCodec.lean @@ -341,17 +341,9 @@ theorem compileRecursorBlock_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (recursorCompileBlockEnv blockEnv recursorVal) snapshot) rule.rhs = some target) : - ∃ recursor constMeta state', - let info : Ixon.ConstantInfo := .recr recursor - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state'.refs state'.univs) - constMeta - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileRecursorBlock recursorVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileRecursorBlock recursorVal)) := by obtain ⟨recursor, constMeta, state', hrecursor, htables', _, hwire, _, _⟩ := compileRecursor_run_ordinary_wireWF compileEnv blockEnv snapshot hfree @@ -360,9 +352,6 @@ theorem compileRecursorBlock_run_ordinary_codecWF hruleRefs have hfinish := finishConstantInfoWithSharing_run_codecWF compileEnv blockEnv state' (.recr recursor) constMeta hwire htables' - refine ⟨recursor, constMeta, state', ?_⟩ - dsimp only - dsimp only at hfinish unfold Ix.CompileM.compileRecursorBlock rw [run_bind, hrecursor] exact hfinish @@ -401,23 +390,14 @@ theorem compileRecursorInfo_run_ordinary_codecWF (frozenRefCompileCtx compileEnv (recursorCompileBlockEnv blockEnv recursorVal) snapshot) rule.rhs = some target) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileRecursorInfo recursorVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by - obtain ⟨recursor, constMeta, state', hrun, hcodec⟩ := + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileRecursorInfo recursorVal)) := by + have hrun := compileRecursorBlock_run_ordinary_codecWF compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables recursorVal htypeSource hruleSources htypeBound hruleBounds hruleCount hstate htypeRef hruleRefs - let info : Ixon.ConstantInfo := .recr recursor - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state'.refs state'.univs) - constMeta - refine ⟨result, state', ?_, hcodec⟩ unfold Ix.CompileM.compileRecursorInfo rw [run_bind, hpreseed] exact hrun @@ -452,11 +432,9 @@ theorem compileRecursorInfo_run_ready_codecWF (hexprBounds : ∀ source ∈ Ix.CompileM.recursorSourceExprs recursorVal, ExprWireBound source) (hruleCount : recursorVal.rules.size < UInt64.size) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileRecursorInfo recursorVal) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileRecursorInfo recursorVal)) := by let params := recursorVal.cnst.levelParams.toList let rest := recursorVal.rules.toList.map (·.rhs) have htypeMem : recursorVal.cnst.type ∈ @@ -623,18 +601,15 @@ theorem compileConstantInfo_recursor_run_ready_codecWF (hexprBounds : ∀ source ∈ Ix.CompileM.recursorSourceExprs recursorVal, ExprWireBound source) (hruleCount : recursorVal.rules.size < UInt64.size) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.compileConstantInfo (.recInfo recursorVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.compileConstantInfo (.recInfo recursorVal))) := by let singletonEnv := singletonRecursorBlockEnv blockEnv recursorVal - obtain ⟨result, state', hrun, hcodec⟩ := + have hrun := compileRecursorInfo_run_ready_codecWF compileEnv singletonEnv hfree hclosed hlevelFaithful hexprFaithful recursorVal state hexprCache hcanonCache hrefTable hunivTable hready htableBound hexprBounds hruleCount - refine ⟨result, state', ?_, hcodec⟩ rw [compileConstantInfo_recursor_run_surgeryFree_eq compileEnv blockEnv state recursorVal hfree] exact hrun @@ -664,12 +639,10 @@ theorem compileConstantInfo_recursor_default_run_ready_codecWF (hexprBounds : ∀ source ∈ Ix.CompileM.recursorSourceExprs recursorVal, ExprWireBound source) (hruleCount : recursorVal.rules.size < UInt64.size) : - ∃ result state', - Ix.CompileM.CompileM.run compileEnv blockEnv + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv (default : Ix.CompileM.BlockState) - (Ix.CompileM.compileConstantInfo (.recInfo recursorVal)) = - .ok (result, state') ∧ - BlockResultCodecWF result := by + (Ix.CompileM.compileConstantInfo (.recInfo recursorVal))) := by apply compileConstantInfo_recursor_run_ready_codecWF compileEnv blockEnv hfree hclosed hlevelFaithful hexprFaithful recursorVal (default : Ix.CompileM.BlockState) rfl CanonUnivCacheWF.empty diff --git a/Ix/Compile/Verify/CompileSharingCodec.lean b/Ix/Compile/Verify/CompileSharingCodec.lean index 60aeee40d..136fb8ed5 100644 --- a/Ix/Compile/Verify/CompileSharingCodec.lean +++ b/Ix/Compile/Verify/CompileSharingCodec.lean @@ -1,198 +1,349 @@ import Ix.Compile.Verify.CompileConstantCodec -import Ix.Compile.Verify.Sharing +import Ix.Compile.Verify.TieredWire /-! # Production sharing/constant-codec bridge -This bridge connects the real `buildConstantWithSharing` and `BlockResult.mk'` -functions to the axiom and definition compiler theorems. The original exact -no-sharing equalities remain useful, while the complete results now cover -nonempty production sharing through the verified analysis/rewrite pipeline -and its explicit `UInt64` overflow fallback. +This bridge connects the compiler's canonical sharing builder +`Ix.CompileM.buildConstantWithSharing` and `BlockResult.mk'` to the declaration +compiler theorems. The builder shares the payload's roots +(`constantInfoRootExprs`) with `canonicalSharingTiered .tagN` and writes the +result back with `withRootExprs` (`Ix.Sharing.Exact.withRoots`, which fails +unless there is one root per slot); its output facts come from +`Tiered.canonicalSharingTiered_format` (`FormatOK`: every table entry and root +is wire-safe, the table count fits a `UInt64`, and Shares point backwards). +The builder fails when the construction does (a resource limit or an +internal error), so the theorems here describe successful builds, and +`SharingSucceeds` is the hypothesis under which a compile step succeeds. -/ namespace Ix.Compile.Verify -/-- When sharing analysis leaves a singleton axiom root unchanged, the actual -production builder is exactly the unshared axiom assembly. -/ -theorem buildConstantWithSharing_axiom_eq_unshared - (isUnsafe : Bool) (lvls : UInt64) (typ : Ixon.Expr) - (state : Ix.CompileM.BlockState) - (hsharing : Ix.Sharing.applySharing #[typ] = (#[typ], #[])) : - Ix.CompileM.buildConstantWithSharing - (.axio { isUnsafe, lvls, typ }) #[typ] state.refs state.univs = - unsharedAxiomConstant isUnsafe lvls typ state := by - simp [Ix.CompileM.buildConstantWithSharing, hsharing, - unsharedAxiomConstant] - -/-- When sharing analysis leaves both definition roots unchanged, the actual -production builder is exactly the unshared definition assembly. -/ -theorem buildConstantWithSharing_definition_eq_unshared - (kind : Ix.DefKind) (safety : Ix.DefinitionSafety) (lvls : UInt64) - (typ value : Ixon.Expr) (state : Ix.CompileM.BlockState) - (hsharing : Ix.Sharing.applySharing #[typ, value] = - (#[typ, value], #[])) : - Ix.CompileM.buildConstantWithSharing - (.defn { kind, safety, lvls, typ, value }) #[typ, value] - state.refs state.univs = - unsharedDefinitionConstant kind safety lvls typ value state := by - simp [Ix.CompileM.buildConstantWithSharing, hsharing, - unsharedDefinitionConstant] - -theorem buildConstantWithSharing_axiom_noSharing_wireWF - {isUnsafe : Bool} {lvls : UInt64} {typ : Ixon.Expr} - {state : Ix.CompileM.BlockState} - (hsharing : Ix.Sharing.applySharing #[typ] = (#[typ], #[])) - (htyp : typ.wireWF) (htables : BlockWireTablesWF state) : - (Ix.CompileM.buildConstantWithSharing - (.axio { isUnsafe, lvls, typ }) #[typ] - state.refs state.univs).wireWF := by - rw [buildConstantWithSharing_axiom_eq_unshared - isUnsafe lvls typ state hsharing] - exact unsharedAxiomConstant_wireWF htyp htables - -theorem buildConstantWithSharing_definition_noSharing_wireWF - {kind : Ix.DefKind} {safety : Ix.DefinitionSafety} {lvls : UInt64} - {typ value : Ixon.Expr} {state : Ix.CompileM.BlockState} - (hsharing : Ix.Sharing.applySharing #[typ, value] = - (#[typ, value], #[])) - (htyp : typ.wireWF) (hvalue : value.wireWF) - (htables : BlockWireTablesWF state) : - (Ix.CompileM.buildConstantWithSharing - (.defn { kind, safety, lvls, typ, value }) #[typ, value] - state.refs state.univs).wireWF := by - rw [buildConstantWithSharing_definition_eq_unshared - kind safety lvls typ value state hsharing] - exact unsharedDefinitionConstant_wireWF htyp hvalue htables - -theorem updateRecursorRules_size (rules : Array Ixon.RecursorRule) - (rewrittenExprs : Array Ixon.Expr) (startIdx : Nat) : - (Ix.CompileM.updateRecursorRules rules rewrittenExprs startIdx).1.size = - rules.size := by - simp [Ix.CompileM.updateRecursorRules] - -/-- Pointwise recursor-rule rewriting preserves every rule's expression wire -domain. -/ -theorem updateRecursorRules_wireWF (rules : Array Ixon.RecursorRule) - (rewrittenExprs : Array Ixon.Expr) (startIdx : Nat) - (hrules : ∀ rule ∈ rules, rule.wireWF) - (hrewritten : ExprArrayWireWF rewrittenExprs) : - ∀ rule ∈ (Ix.CompileM.updateRecursorRules - rules rewrittenExprs startIdx).1, rule.wireWF := by - intro rule hmem - unfold Ix.CompileM.updateRecursorRules at hmem - obtain ⟨i, hi, heq⟩ := Array.mem_mapIdx.mp hmem - subst rule - change (rewrittenExprs[startIdx + i]?.getD rules[i].rhs).wireWF - apply hrewritten.getElem?_getD - exact hrules _ (Array.getElem_mem hi) - -theorem updateConstructorTypes_size (ctors : Array Ixon.Constructor) - (rewrittenExprs : Array Ixon.Expr) (startIdx : Nat) : - (Ix.CompileM.updateConstructorTypes ctors rewrittenExprs startIdx).1.size = - ctors.size := by - simp [Ix.CompileM.updateConstructorTypes] - -/-- Pointwise constructor rewriting preserves every constructor type's wire -domain. -/ -theorem updateConstructorTypes_wireWF (ctors : Array Ixon.Constructor) - (rewrittenExprs : Array Ixon.Expr) (startIdx : Nat) - (hctors : ∀ ctor ∈ ctors, ctor.wireWF) - (hrewritten : ExprArrayWireWF rewrittenExprs) : - ∀ ctor ∈ (Ix.CompileM.updateConstructorTypes - ctors rewrittenExprs startIdx).1, ctor.wireWF := by - intro ctor hmem - unfold Ix.CompileM.updateConstructorTypes at hmem - obtain ⟨i, hi, heq⟩ := Array.mem_mapIdx.mp hmem - subst ctor - change (rewrittenExprs[startIdx + i]?.getD ctors[i].typ).wireWF - apply hrewritten.getElem?_getD - exact hctors _ (Array.getElem_mem hi) - -/-- Every mutual member accumulated by the production updater is wire-safe. -/ -def MutConstUpdateStateWireWF - (state : Ix.CompileM.MutConstUpdateState) : Prop := - ∀ member ∈ state.result, member.wireWF - -theorem MutConstUpdateStateWireWF.empty : - MutConstUpdateStateWireWF - ({} : Ix.CompileM.MutConstUpdateState) := by - intro member hmem +/-- Every member of an expression array is in the expression codec's public +wire domain. -/ +def ExprArrayWireWF (exprs : Array Ixon.Expr) : Prop := + ∀ expr ∈ exprs, expr.wireWF + +theorem ExprArrayWireWF.empty : ExprArrayWireWF #[] := by + intro expr hmem simp at hmem -theorem updateMutConst_wireWF (rewrittenExprs : Array Ixon.Expr) - (state : Ix.CompileM.MutConstUpdateState) (member : Ixon.MutConst) - (hstate : MutConstUpdateStateWireWF state) - (hmember : member.wireWF) - (hrewritten : ExprArrayWireWF rewrittenExprs) : - MutConstUpdateStateWireWF - (Ix.CompileM.updateMutConst rewrittenExprs state member) := by - cases member with - | defn definition => - intro resultMember hmem - simp only [Ix.CompileM.updateMutConst] at hmem - rw [Array.mem_push] at hmem - rcases hmem with hmem | rfl - · exact hstate _ hmem - · exact ⟨hrewritten.getElem?_getD _ hmember.1, - hrewritten.getElem?_getD _ hmember.2⟩ - | indc indInfo => - intro resultMember hmem - simp only [Ix.CompileM.updateMutConst] at hmem - rw [Array.mem_push] at hmem - rcases hmem with hmem | rfl - · exact hstate _ hmem - · refine ⟨hrewritten.getElem?_getD _ hmember.1, ?_, ?_⟩ - · rw [updateConstructorTypes_size] - exact hmember.2.1 - · exact updateConstructorTypes_wireWF _ _ _ - hmember.2.2 hrewritten - | recr recursor => - intro resultMember hmem - simp only [Ix.CompileM.updateMutConst] at hmem - rw [Array.mem_push] at hmem - rcases hmem with hmem | rfl - · exact hstate _ hmem - · refine ⟨hrewritten.getElem?_getD _ hmember.1, ?_, ?_⟩ - · rw [updateRecursorRules_size] - exact hmember.2.1 - · exact updateRecursorRules_wireWF _ _ _ hmember.2.2 hrewritten - -theorem updateMutConst_size (rewrittenExprs : Array Ixon.Expr) - (state : Ix.CompileM.MutConstUpdateState) (member : Ixon.MutConst) : - (Ix.CompileM.updateMutConst rewrittenExprs state member).result.size = - state.result.size + 1 := by - cases member <;> simp [Ix.CompileM.updateMutConst] - -theorem updateMutConsts_size (members : Array Ixon.MutConst) - (rewrittenExprs : Array Ixon.Expr) : - (Ix.CompileM.updateMutConsts members rewrittenExprs).size = - members.size := by - unfold Ix.CompileM.updateMutConsts - apply Array.foldl_induction - (motive := fun i (state : Ix.CompileM.MutConstUpdateState) => - state.result.size = i) - · simp - · intro i state hstate - rw [updateMutConst_size, hstate] - -/-- The heterogeneous mutual-member fold preserves every nested expression -and counted child array in the public constant wire domain. -/ -theorem updateMutConsts_wireWF (members : Array Ixon.MutConst) - (rewrittenExprs : Array Ixon.Expr) - (hmembers : ∀ member ∈ members, member.wireWF) - (hrewritten : ExprArrayWireWF rewrittenExprs) : - ∀ member ∈ Ix.CompileM.updateMutConsts members rewrittenExprs, - member.wireWF := by - unfold Ix.CompileM.updateMutConsts - apply Array.foldl_induction - (motive := fun _ state => MutConstUpdateStateWireWF state) - · exact MutConstUpdateStateWireWF.empty - · intro i state hstate - apply updateMutConst_wireWF - · exact hstate - · exact hmembers _ (Array.getElem_mem i.isLt) - · exact hrewritten +/-! ## Root write-back (`Ix.Sharing.Exact.withRoots`) + +`Ix.CompileM.withRootExprs` writes the shared roots back with +`Ix.Sharing.Exact.withRoots`, which consumes them as a cursor in +`constantInfoRoots` order and fails unless there is exactly one root per slot. -/ + +section WithRoots +open Ix.Sharing.Exact + +/-- A successful `takeRoot` splits off the head of the cursor. -/ +theorem takeRoot_eq_ok {rs : List Ixon.Expr} {e : Ixon.Expr} {rest : List Ixon.Expr} + (h : takeRoot rs = .ok (e, rest)) : rs = e :: rest := by + cases rs with + | nil => simp [takeRoot] at h + | cons x xs => + simp only [takeRoot, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + rfl + +/-- A successful `takeRoots k` splits off the first `k` roots of the cursor. -/ +theorem takeRoots_eq_ok : ∀ {k : Nat} {rs es rest : List Ixon.Expr}, + takeRoots k rs = .ok (es, rest) → es.length = k ∧ rs = es ++ rest + | 0, rs, es, rest, h => by + simp only [takeRoots, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + simp + | k + 1, rs, es, rest, h => by + simp only [takeRoots] at h + cases h1 : takeRoot rs with + | error err => simp [h1, bind, Except.bind] at h + | ok p => + obtain ⟨e, r1⟩ := p + cases h2 : takeRoots k r1 with + | error err => simp [h1, h2, bind, Except.bind] at h + | ok q => + obtain ⟨es', r2⟩ := q + simp [h1, h2, bind, Except.bind, pure, Except.pure] at h + obtain ⟨rfl, rfl⟩ := h + obtain ⟨hl, rfl⟩ := takeRoots_eq_ok h2 + rw [takeRoot_eq_ok h1] + simp [hl] + +/-- `takeRoots` takes exactly the roots it is asked for. -/ +theorem takeRoots_append : ∀ (es rest : List Ixon.Expr), + takeRoots es.length (es ++ rest) = .ok (es, rest) + | [], rest => rfl + | e :: es, rest => by + simp only [List.length_cons, List.cons_append, takeRoots, takeRoot, bind, Except.bind, + takeRoots_append es rest, pure, Except.pure] + + +/-- Writing wire-safe roots into a wire-safe mutual member keeps it wire-safe, +and leaves a wire-safe rest of the cursor. -/ +theorem withMutConstRoots_wireWF {m m' : Ixon.MutConst} {rs rest : List Ixon.Expr} + (h : withMutConstRoots m rs = .ok (m', rest)) (hm : m.wireWF) + (hrs : ∀ e ∈ rs, e.wireWF) : + m'.wireWF ∧ ∀ e ∈ rest, e.wireWF := by + cases m with + | defn d => + simp only [withMutConstRoots] at h + cases h1 : takeRoot rs with + | error err => simp [h1, bind, Except.bind] at h + | ok p => + obtain ⟨typ, r1⟩ := p + cases h2 : takeRoot r1 with + | error err => simp [h1, h2, bind, Except.bind] at h + | ok q => + obtain ⟨value, r2⟩ := q + simp [h1, h2, bind, Except.bind, pure, Except.pure] at h + obtain ⟨rfl, rfl⟩ := h + obtain rfl := takeRoot_eq_ok h1 + obtain rfl := takeRoot_eq_ok h2 + exact ⟨⟨hrs _ (by simp), hrs _ (by simp)⟩, fun e he => hrs e (by simp [he])⟩ + | indc i => + simp only [withMutConstRoots] at h + cases h1 : takeRoot rs with + | error err => simp [h1, bind, Except.bind] at h + | ok p => + obtain ⟨typ, r1⟩ := p + cases h2 : takeRoots i.ctors.size r1 with + | error err => simp [h1, h2, bind, Except.bind] at h + | ok q => + obtain ⟨tys, r2⟩ := q + simp [h1, h2, bind, Except.bind, pure, Except.pure] at h + obtain ⟨rfl, rfl⟩ := h + obtain rfl := takeRoot_eq_ok h1 + obtain ⟨hlen, rfl⟩ := takeRoots_eq_ok h2 + refine ⟨⟨hrs _ (by simp), ?_, ?_⟩, fun e he => hrs e (by simp [he])⟩ + · have := hm.2.1 + simp only [List.size_toArray, List.length_map, List.length_zip, Array.length_toList] + omega + · intro c hc + simp only [List.mem_toArray, List.mem_map] at hc + obtain ⟨⟨c0, t⟩, hmem, rfl⟩ := hc + exact hrs t (by simp [(List.of_mem_zip hmem).2]) + | recr r => + simp only [withMutConstRoots] at h + cases h1 : takeRoot rs with + | error err => simp [h1, bind, Except.bind] at h + | ok p => + obtain ⟨typ, r1⟩ := p + cases h2 : takeRoots r.rules.size r1 with + | error err => simp [h1, h2, bind, Except.bind] at h + | ok q => + obtain ⟨rhss, r2⟩ := q + simp [h1, h2, bind, Except.bind, pure, Except.pure] at h + obtain ⟨rfl, rfl⟩ := h + obtain rfl := takeRoot_eq_ok h1 + obtain ⟨hlen, rfl⟩ := takeRoots_eq_ok h2 + refine ⟨⟨hrs _ (by simp), ?_, ?_⟩, fun e he => hrs e (by simp [he])⟩ + · have := hm.2.1 + simp only [List.size_toArray, List.length_map, List.length_zip, Array.length_toList] + omega + · intro c hc + simp only [List.mem_toArray, List.mem_map] at hc + obtain ⟨⟨c0, t⟩, hmem, rfl⟩ := hc + exact hrs t (by simp [(List.of_mem_zip hmem).2]) + + +/-- With one root per slot of the member at the front of the cursor, +`withMutConstRoots` succeeds and leaves the rest. -/ +theorem withMutConstRoots_append (m : Ixon.MutConst) (xs rest : List Ixon.Expr) + (hlen : xs.length = (mutConstRoots m).length) : + ∃ m', withMutConstRoots m (xs ++ rest) = .ok (m', rest) := by + cases m with + | defn d => + match xs, hlen with + | [a, b], _ => exact ⟨_, rfl⟩ + | indc i => + match xs, hlen with + | t :: tys, hlen => + have htys : i.ctors.size = tys.length := by + simp [mutConstRoots] at hlen; omega + + simp only [withMutConstRoots, List.cons_append, takeRoot, bind, Except.bind, htys, + takeRoots_append, pure, Except.pure, Except.ok.injEq, Prod.mk.injEq, and_true, exists_eq'] + | recr r => + match xs, hlen with + | t :: rhss, hlen => + have hrhss : r.rules.size = rhss.length := by + simp [mutConstRoots] at hlen; omega + + simp only [withMutConstRoots, List.cons_append, takeRoot, bind, Except.bind, hrhss, + takeRoots_append, pure, Except.pure, Except.ok.injEq, Prod.mk.injEq, and_true, exists_eq'] + +/-- An invariant of a `for` loop in `Except` whose body only continues: it holds +of the result when every successful step keeps it. -/ +theorem forIn_except_inv {α β ε : Type} (P : List α → β → Prop) + (f : α → β → Except ε (ForInStep β)) + (step : ∀ a l b r, P (a :: l) b → f a b = .ok r → ∃ b', r = .yield b' ∧ P l b') : + ∀ (l : List α) (b r : β), P l b → forIn l b f = .ok r → P [] r + | [], b, r, hb, h => by + simp only [List.forIn_nil, pure, Except.pure, Except.ok.injEq] at h + exact h ▸ hb + | a :: l, b, r, hb, h => by + simp only [List.forIn_cons] at h + cases hf : f a b with + | error e => simp [hf, bind, Except.bind] at h + | ok s => + obtain ⟨b', rfl, hb'⟩ := step a l b s hb hf + simp only [hf, bind, Except.bind] at h + exact forIn_except_inv P f step l b' r hb' h + +/-- A `for` loop in `Except` succeeds when every step does (continuing) while +an invariant holds. -/ +theorem forIn_except_ok {α β ε : Type} (Q : List α → β → Prop) + (f : α → β → Except ε (ForInStep β)) + (step : ∀ a l b, Q (a :: l) b → ∃ b', f a b = .ok (.yield b') ∧ Q l b') : + ∀ (l : List α) (b : β), Q l b → ∃ r, forIn l b f = .ok r ∧ Q [] r + | [], b, hb => ⟨b, rfl, hb⟩ + | a :: l, b, hb => by + obtain ⟨b', hf, hb'⟩ := step a l b hb + obtain ⟨r, hr, hq⟩ := forIn_except_ok Q f step l b' hb' + refine ⟨r, ?_, hq⟩ + simp only [List.forIn_cons, hf, bind, Except.bind, hr] + + +/-- A successful `Except` bind has a successful first action. -/ +theorem except_bind_eq_ok {ε α β : Type} {x : Except ε α} {f : α → Except ε β} {y : β} + (h : x >>= f = .ok y) : ∃ a, x = .ok a ∧ f a = .ok y := by + cases x with + | error e => simp [bind, Except.bind] at h + | ok a => exact ⟨a, rfl, h⟩ + +/-- The final cursor check of `withRoots` returns the reassembled payload. -/ +theorem withRoots_tail {x info' : Ixon.ConstantInfo} {c : Prop} [Decidable c] + (h : (if c then Except.ok x + else Except.error (SharingError.internal "root cursor not exhausted")) = + (Except.ok info' : Except SharingError Ixon.ConstantInfo)) : x = info' := by + split at h <;> simp_all + +/-- **The root write-back keeps the payload wire-safe**: `withRoots` of +wire-safe roots into a wire-safe `ConstantInfo` yields a wire-safe +`ConstantInfo`, for every variant. -/ +theorem withRoots_wireWF {info info' : Ixon.ConstantInfo} {roots : Array Ixon.Expr} + (h : withRoots info roots = .ok info') (hinfo : info.wireWF) + (hroots : ∀ e ∈ roots, e.wireWF) : info'.wireWF := by + have hrs : ∀ e ∈ roots.toList, e.wireWF := fun e he => hroots e (by simpa using he) + simp only [withRoots] at h + split at h + · simp [throw, throwThe, MonadExceptOf.throw, bind, Except.bind] at h + cases info with + | defn d => + obtain ⟨⟨m, rest⟩, hw, h⟩ := except_bind_eq_ok h + have hm := (withMutConstRoots_wireWF hw hinfo hrs).1 + cases m with + | defn d' => + simp [bind, Except.bind, pure, Except.pure, throw, throwThe, MonadExceptOf.throw] at h + exact withRoots_tail h ▸ hm + | _ => simp [bind, Except.bind, throw, throwThe, MonadExceptOf.throw] at h + | recr r => + obtain ⟨⟨m, rest⟩, hw, h⟩ := except_bind_eq_ok h + have hm := (withMutConstRoots_wireWF hw hinfo hrs).1 + cases m with + | recr r' => + simp [bind, Except.bind, pure, Except.pure, throw, throwThe, MonadExceptOf.throw] at h + exact withRoots_tail h ▸ hm + | _ => simp [bind, Except.bind, throw, throwThe, MonadExceptOf.throw] at h + | axio a => + obtain ⟨⟨typ, rest⟩, hw, h⟩ := except_bind_eq_ok h + have htyp : typ.wireWF := hrs typ (by simp [takeRoot_eq_ok hw]) + simp [bind, Except.bind, pure, Except.pure, throw, throwThe, MonadExceptOf.throw] at h + exact withRoots_tail h ▸ htyp + | quot q => + obtain ⟨⟨typ, rest⟩, hw, h⟩ := except_bind_eq_ok h + have htyp : typ.wireWF := hrs typ (by simp [takeRoot_eq_ok hw]) + simp [bind, Except.bind, pure, Except.pure, throw, throwThe, MonadExceptOf.throw] at h + exact withRoots_tail h ▸ htyp + | cPrj p | rPrj p | iPrj p | dPrj p => + simp [bind, Except.bind, pure, Except.pure, throw, throwThe, MonadExceptOf.throw] at h + exact withRoots_tail h ▸ hinfo + | muts ms => + dsimp only at h + rw [← Array.forIn_toList] at h + obtain ⟨s, hs, h⟩ := except_bind_eq_ok h + have hloop := forIn_except_inv + (fun (l : List Ixon.MutConst) (b : Array Ixon.MutConst × List Ixon.Expr) => + b.1.size + l.length = ms.size ∧ (∀ m ∈ b.1, m.wireWF) ∧ + (∀ e ∈ b.2, e.wireWF) ∧ ∀ m ∈ l, m.wireWF) _ + (by + intro a l b r hb hf + obtain ⟨⟨m', rest⟩, hw, hf⟩ := except_bind_eq_ok hf + simp only [pure, Except.pure, Except.ok.injEq] at hf + have hm := withMutConstRoots_wireWF hw (hb.2.2.2 a (by simp)) hb.2.2.1 + refine ⟨_, hf.symm, ?_, ?_, hm.2, fun m hmem => hb.2.2.2 m (by simp [hmem])⟩ + · simp only [Array.size_push, List.length_cons] at hb ⊢ + omega + · intro m hmem + rcases Array.mem_push.mp hmem with hmem | rfl + · exact hb.2.1 m hmem + · exact hm.1) + ms.toList (#[], roots.toList) s + ⟨by simp, by simp, hrs, fun m hm => hinfo.2 m (by simpa using hm)⟩ hs + simp [bind, Except.bind, pure, Except.pure, throw, throwThe, MonadExceptOf.throw] at h + rw [← withRoots_tail h] + have hsize : s.1.size = ms.size := by simpa using hloop.1 + exact ⟨hsize ▸ hinfo.1, hloop.2.1⟩ + + +/-- `takeRoots` of a whole cursor. -/ +theorem takeRoots_self (es : List Ixon.Expr) : takeRoots es.length es = .ok (es, []) := by + simpa using takeRoots_append es [] + +/-- `withRoots` succeeds whenever there is one root per root slot. -/ +theorem withRoots_ok_of_size {info : Ixon.ConstantInfo} {roots : Array Ixon.Expr} + (hsize : roots.size = (constantInfoRoots info).size) : + ∃ info', withRoots info roots = .ok info' := by + have hlen : roots.toList.length = (constantInfoRoots info).size := by simpa using hsize + simp only [withRoots] + rw [if_neg (by simp [hsize])] + cases info with + | defn d => + match roots.toList, hlen with + | [a, b], _ => simp [withMutConstRoots, takeRoot, bind, Except.bind, pure, Except.pure] + | recr r => + match roots.toList, hlen with + | t :: rhss, hlen => + have hr : r.rules.size = rhss.length := by + simp [constantInfoRoots, mutConstRoots] at hlen; omega + simp [withMutConstRoots, takeRoot, bind, Except.bind, pure, Except.pure, hr, + takeRoots_self] + | axio a => + match roots.toList, hlen with + | [t], _ => simp [takeRoot, bind, Except.bind, pure, Except.pure] + | quot q => + match roots.toList, hlen with + | [t], _ => simp [takeRoot, bind, Except.bind, pure, Except.pure] + | cPrj p | rPrj p | iPrj p | dPrj p => + match roots.toList, hlen with + | [], _ => simp [bind, Except.bind, pure, Except.pure] + | muts ms => + dsimp only + rw [← Array.forIn_toList] + obtain ⟨s, hs, hq⟩ := forIn_except_ok + (fun (l : List Ixon.MutConst) (b : Array Ixon.MutConst × List Ixon.Expr) => + b.2.length = (l.flatMap mutConstRoots).length) + (fun m (s : Array Ixon.MutConst × List Ixon.Expr) => do + let x ← withMutConstRoots m s.snd + pure (ForInStep.yield (s.fst.push x.fst, x.snd))) + (by + intro a l b hb + have hn : (b.2.take (mutConstRoots a).length).length = (mutConstRoots a).length := by + simp only [List.flatMap_cons, List.length_append] at hb + simp [List.length_take]; omega + obtain ⟨m', hw⟩ := withMutConstRoots_append a _ (b.2.drop (mutConstRoots a).length) hn + rw [List.take_append_drop] at hw + refine ⟨(b.1.push m', b.2.drop (mutConstRoots a).length), ?_, ?_⟩ + · simp [hw, bind, Except.bind, pure, Except.pure] + · simp only [List.flatMap_cons, List.length_append] at hb + simp [List.length_drop, hb]) + ms.toList (#[], roots.toList) (by simpa [constantInfoRoots] using hlen) + rw [hs] + simp at hq + simp [hq, bind, Except.bind, pure, Except.pure] + +end WithRoots /-- The production cursor-order extractor agrees with the catalog's logical expression view for every mutual-member variant. -/ @@ -297,205 +448,169 @@ theorem constantInfoRootExprs_wireWF (info : Ixon.ConstantInfo) exact mutConstRootExprs_wireWF member (hinfo.2 member (by simpa using hmember)) expr hexpr -/-- For every `ConstantInfo` variant, the production sharing builder preserves -the complete public constant wire domain. The root array may be arbitrary: -present rewritten slots are safe by `applySharing_wireWF`, while absent slots -fall back to the wire-safe expressions already stored in `info`. -/ -theorem buildConstantWithSharing_wireWF - (info : Ixon.ConstantInfo) (rootExprs : Array Ixon.Expr) - {state : Ix.CompileM.BlockState} (hinfo : info.wireWF) - (hroots : ExprArrayWireWF rootExprs) - (htables : BlockWireTablesWF state) : - (Ix.CompileM.buildConstantWithSharing info rootExprs - state.refs state.univs).wireWF := by - let output := Ix.Sharing.applySharing rootExprs - have houtput : Ix.Sharing.applySharing rootExprs = output := rfl - rcases output with ⟨rewritten, sharing⟩ - have hwire := applySharing_wireWF rootExprs hroots - have hcapacity := applySharing_capacity rootExprs - rw [houtput] at hwire hcapacity - cases info with - | defn definition => - rw [show Ix.CompileM.buildConstantWithSharing (.defn definition) - rootExprs state.refs state.univs = - Ixon.Constant.mk - (.defn { definition with - typ := rewritten[0]?.getD definition.typ - value := rewritten[1]?.getD definition.value }) - sharing state.refs state.univs by - simp [Ix.CompileM.buildConstantWithSharing, houtput]] - refine ⟨⟨?_, ?_⟩, hcapacity, hwire.2, htables.refsCount, - htables.refs, htables.univsCount, htables.univs⟩ - · exact hwire.1.getElem?_getD 0 hinfo.1 - · exact hwire.1.getElem?_getD 1 hinfo.2 - | recr recursor => - rw [show Ix.CompileM.buildConstantWithSharing (.recr recursor) - rootExprs state.refs state.univs = - Ixon.Constant.mk - (.recr { recursor with - typ := rewritten[0]?.getD recursor.typ - rules := (Ix.CompileM.updateRecursorRules - recursor.rules rewritten 1).1 }) - sharing state.refs state.univs by - simp [Ix.CompileM.buildConstantWithSharing, houtput]] - refine ⟨⟨?_, ?_, ?_⟩, hcapacity, hwire.2, htables.refsCount, - htables.refs, htables.univsCount, htables.univs⟩ - · exact hwire.1.getElem?_getD 0 hinfo.1 - · rw [updateRecursorRules_size] - exact hinfo.2.1 - · exact updateRecursorRules_wireWF _ _ _ hinfo.2.2 hwire.1 - | axio axiomInfo => - rw [show Ix.CompileM.buildConstantWithSharing (.axio axiomInfo) - rootExprs state.refs state.univs = - Ixon.Constant.mk - (.axio { axiomInfo with - typ := rewritten[0]?.getD axiomInfo.typ }) - sharing state.refs state.univs by - simp [Ix.CompileM.buildConstantWithSharing, houtput]] - refine ⟨?_, hcapacity, hwire.2, htables.refsCount, htables.refs, - htables.univsCount, htables.univs⟩ - exact hwire.1.getElem?_getD 0 hinfo - | quot quotient => - rw [show Ix.CompileM.buildConstantWithSharing (.quot quotient) - rootExprs state.refs state.univs = - Ixon.Constant.mk - (.quot { quotient with - typ := rewritten[0]?.getD quotient.typ }) - sharing state.refs state.univs by - simp [Ix.CompileM.buildConstantWithSharing, houtput]] - refine ⟨?_, hcapacity, hwire.2, htables.refsCount, htables.refs, - htables.univsCount, htables.univs⟩ - exact hwire.1.getElem?_getD 0 hinfo - | cPrj projection => - rw [show Ix.CompileM.buildConstantWithSharing (.cPrj projection) - rootExprs state.refs state.univs = - Ixon.Constant.mk (.cPrj projection) sharing state.refs state.univs by - simp [Ix.CompileM.buildConstantWithSharing, houtput]] - exact ⟨hinfo, hcapacity, hwire.2, htables.refsCount, htables.refs, - htables.univsCount, htables.univs⟩ - | rPrj projection => - rw [show Ix.CompileM.buildConstantWithSharing (.rPrj projection) - rootExprs state.refs state.univs = - Ixon.Constant.mk (.rPrj projection) sharing state.refs state.univs by - simp [Ix.CompileM.buildConstantWithSharing, houtput]] - exact ⟨hinfo, hcapacity, hwire.2, htables.refsCount, htables.refs, - htables.univsCount, htables.univs⟩ - | iPrj projection => - rw [show Ix.CompileM.buildConstantWithSharing (.iPrj projection) - rootExprs state.refs state.univs = - Ixon.Constant.mk (.iPrj projection) sharing state.refs state.univs by - simp [Ix.CompileM.buildConstantWithSharing, houtput]] - exact ⟨hinfo, hcapacity, hwire.2, htables.refsCount, htables.refs, - htables.univsCount, htables.univs⟩ - | dPrj projection => - rw [show Ix.CompileM.buildConstantWithSharing (.dPrj projection) - rootExprs state.refs state.univs = - Ixon.Constant.mk (.dPrj projection) sharing state.refs state.univs by - simp [Ix.CompileM.buildConstantWithSharing, houtput]] - exact ⟨hinfo, hcapacity, hwire.2, htables.refsCount, htables.refs, - htables.univsCount, htables.univs⟩ - | muts members => - rw [show Ix.CompileM.buildConstantWithSharing (.muts members) - rootExprs state.refs state.univs = - Ixon.Constant.mk - (.muts (Ix.CompileM.updateMutConsts members rewritten)) - sharing state.refs state.univs by - simp [Ix.CompileM.buildConstantWithSharing, houtput]] - refine ⟨⟨?_, ?_⟩, hcapacity, hwire.2, htables.refsCount, - htables.refs, htables.univsCount, htables.univs⟩ - · rw [updateMutConsts_size] - exact hinfo.1 - · exact updateMutConsts_wireWF _ _ hinfo.2 hwire.1 - -/-- With the canonical production root extractor, payload wire safety alone -discharges every expression-root obligation of the sharing builder. -/ -theorem buildConstantWithSharing_canonical_wireWF - (info : Ixon.ConstantInfo) {state : Ix.CompileM.BlockState} - (hinfo : info.wireWF) (htables : BlockWireTablesWF state) : - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state.refs state.univs).wireWF := - buildConstantWithSharing_wireWF info _ hinfo - (constantInfoRootExprs_wireWF info hinfo) htables - -/-- The production axiom builder lies in the constant codec's wire domain for -both empty and nonempty sharing results. -/ -theorem buildConstantWithSharing_axiom_wireWF - {isUnsafe : Bool} {lvls : UInt64} {typ : Ixon.Expr} - {state : Ix.CompileM.BlockState} - (htyp : typ.wireWF) (htables : BlockWireTablesWF state) : - (Ix.CompileM.buildConstantWithSharing - (.axio { isUnsafe, lvls, typ }) #[typ] - state.refs state.univs).wireWF := by - apply buildConstantWithSharing_wireWF - · exact htyp - · intro expr hmem - simp at hmem - subst expr - exact htyp - · exact htables +/-- The compiler's root order is the order of `Ix.Sharing.Exact.constantInfoRoots`, +which `withRootExprs` consumes. -/ +theorem constantInfoRootExprs_eq_roots (info : Ixon.ConstantInfo) : + Ix.CompileM.constantInfoRootExprs info = Ix.Sharing.Exact.constantInfoRoots info := by + have hm : Ix.CompileM.mutConstRootExprs = Ix.Sharing.Exact.mutConstRoots := by + funext m + cases m <;> rfl + cases info <;> simp [Ix.CompileM.constantInfoRootExprs, Ix.Sharing.Exact.constantInfoRoots, hm] -/-- The production quotient builder lies in the constant codec's wire domain -for both empty and nonempty sharing results. -/ -theorem buildConstantWithSharing_quotient_wireWF - {kind : Ix.QuotKind} {lvls : UInt64} {typ : Ixon.Expr} - {state : Ix.CompileM.BlockState} - (htyp : typ.wireWF) (htables : BlockWireTablesWF state) : - (Ix.CompileM.buildConstantWithSharing - (.quot { kind, lvls, typ }) #[typ] - state.refs state.univs).wireWF := by - apply buildConstantWithSharing_wireWF - · exact htyp +/-- With one rewritten expression per root, the write-back succeeds. -/ +theorem withRootExprs_ok_of_size {info : Ixon.ConstantInfo} {rewritten : Array Ixon.Expr} + (hsize : rewritten.size = (Ix.CompileM.constantInfoRootExprs info).size) : + ∃ info', Ix.CompileM.withRootExprs info rewritten = .ok info' := by + rw [constantInfoRootExprs_eq_roots] at hsize + obtain ⟨info', h⟩ := withRoots_ok_of_size hsize + exact ⟨info', by simp [Ix.CompileM.withRootExprs, h, Except.mapError]⟩ + +/-- Writing wire-safe roots back preserves the payload's wire domain. -/ +theorem withRootExprs_wireWF {info info' : Ixon.ConstantInfo} {rewritten : Array Ixon.Expr} + (h : Ix.CompileM.withRootExprs info rewritten = .ok info') + (hinfo : info.wireWF) (hwire : ExprArrayWireWF rewritten) : info'.wireWF := by + simp only [Ix.CompileM.withRootExprs] at h + cases hw : Ix.Sharing.Exact.withRoots info rewritten with + | error e => simp [hw, Except.mapError] at h + | ok x => + simp [hw, Except.mapError] at h + exact h ▸ withRoots_wireWF hw hinfo hwire + +/-! ## The canonical sharing builder -/ + +/-- The canonical sharing construction succeeds on the payload's roots under +`limits` and returns one root per input root: exactly when +`buildConstantWithSharing` succeeds (`buildConstantWithSharing_of_succeeds`). -/ +def SharingSucceeds (limits : Ix.Sharing.Exact.Limits) (info : Ixon.ConstantInfo) : + Prop := + ∃ r, Ix.Sharing.Exact.canonicalSharingTiered .tagN + (Ix.CompileM.constantInfoRootExprs info) limits = .ok r ∧ + r.result.roots.size = (Ix.CompileM.constantInfoRootExprs info).size + +/-- A successful build is the canonical construction of the payload's roots, +written back into the payload. -/ +theorem buildConstantWithSharing_eq_ok {limits : Ix.Sharing.Exact.Limits} + {info : Ixon.ConstantInfo} {refs : Array Address} {univs : Array Ixon.Univ} + {block : Ixon.Constant} + (h : Ix.CompileM.buildConstantWithSharing limits info refs univs = .ok block) : + ∃ r info', Ix.Sharing.Exact.canonicalSharingTiered .tagN + (Ix.CompileM.constantInfoRootExprs info) limits = .ok r ∧ + r.result.roots.size = (Ix.CompileM.constantInfoRootExprs info).size ∧ + Ix.CompileM.withRootExprs info r.result.roots = .ok info' ∧ + block = { info := info', sharing := r.result.sharing, refs, univs } := by + simp only [Ix.CompileM.buildConstantWithSharing] at h + cases hr : Ix.Sharing.Exact.canonicalSharingTiered .tagN + (Ix.CompileM.constantInfoRootExprs info) limits with + | error e => + simp [hr, Except.mapError, bind, Except.bind] at h + | ok r => + simp only [hr, Except.mapError] at h + by_cases hs : r.result.roots.size = (Ix.CompileM.constantInfoRootExprs info).size + · cases hw : Ix.CompileM.withRootExprs info r.result.roots with + | error e => + simp [hs, hw, bind, Except.bind] at h + | ok info' => + refine ⟨r, info', rfl, hs, hw, ?_⟩ + simp [hs, hw, bind, Except.bind, pure, Except.pure] at h + exact h.symm + · simp [hs, bind, Except.bind, throw, throwThe, MonadExceptOf.throw] at h + +/-- The builder's result when the canonical construction succeeds with one +root per input root. -/ +theorem buildConstantWithSharing_of_canonical {limits : Ix.Sharing.Exact.Limits} + {info : Ixon.ConstantInfo} {r : Ix.Sharing.Exact.TieredSharingResult} + (hr : Ix.Sharing.Exact.canonicalSharingTiered .tagN + (Ix.CompileM.constantInfoRootExprs info) limits = .ok r) + (hs : r.result.roots.size = (Ix.CompileM.constantInfoRootExprs info).size) + (refs : Array Address) (univs : Array Ixon.Univ) : + ∃ info', Ix.CompileM.withRootExprs info r.result.roots = .ok info' ∧ + Ix.CompileM.buildConstantWithSharing limits info refs univs = + .ok { info := info', sharing := r.result.sharing, refs, univs } := by + obtain ⟨info', hw⟩ := withRootExprs_ok_of_size hs + exact ⟨info', hw, by + simp [Ix.CompileM.buildConstantWithSharing, hr, Except.mapError, hs, hw, bind, + Except.bind, pure, Except.pure]⟩ + +/-- Under `SharingSucceeds` the builder succeeds, whatever the tables. -/ +theorem buildConstantWithSharing_of_succeeds {limits : Ix.Sharing.Exact.Limits} + {info : Ixon.ConstantInfo} (h : SharingSucceeds limits info) + (refs : Array Address) (univs : Array Ixon.Univ) : + ∃ block, Ix.CompileM.buildConstantWithSharing limits info refs univs = .ok block := by + obtain ⟨r, hr, hs⟩ := h + obtain ⟨_, _, hb⟩ := buildConstantWithSharing_of_canonical hr hs refs univs + exact ⟨_, hb⟩ + +/-- **Every block the compiler's sharing builds is in the constant codec's wire +domain**, for every `ConstantInfo` variant: the payload's fields are kept, +its roots and the table come from the canonical construction, and +`Tiered.canonicalSharingTiered_format` makes them wire-safe with a table count +below `2^64`. -/ +theorem buildConstantWithSharing_wireWF {limits : Ix.Sharing.Exact.Limits} + {info : Ixon.ConstantInfo} {state : Ix.CompileM.BlockState} + {block : Ixon.Constant} (hinfo : info.wireWF) + (htables : BlockWireTablesWF state) + (h : Ix.CompileM.buildConstantWithSharing limits info + state.refs state.univs = .ok block) : + block.wireWF := by + obtain ⟨r, info', hr, -, hw, rfl⟩ := buildConstantWithSharing_eq_ok h + obtain ⟨hentries, hroots, hcapacity, -, -⟩ := Tiered.canonicalSharingTiered_format hr + refine ⟨withRootExprs_wireWF hw hinfo ?_, hcapacity, ?_, htables.refsCount, + htables.refs, htables.univsCount, htables.univs⟩ · intro expr hmem - simp at hmem - subst expr - exact htyp - · exact htables - -/-- The production definition builder lies in the constant codec's wire -domain for both empty and nonempty sharing results. -/ -theorem buildConstantWithSharing_definition_wireWF - {kind : Ix.DefKind} {safety : Ix.DefinitionSafety} {lvls : UInt64} - {typ value : Ixon.Expr} {state : Ix.CompileM.BlockState} - (htyp : typ.wireWF) (hvalue : value.wireWF) - (htables : BlockWireTablesWF state) : - (Ix.CompileM.buildConstantWithSharing - (.defn { kind, safety, lvls, typ, value }) #[typ, value] - state.refs state.univs).wireWF := by - apply buildConstantWithSharing_wireWF - · exact ⟨htyp, hvalue⟩ + exact hroots expr (by simpa using hmem) · intro expr hmem - simp at hmem - rcases hmem with rfl | rfl - · exact htyp - · exact hvalue - · exact htables - -/-- The production recursor builder preserves its counted rule array and lies -in the constant codec's wire domain for empty or nonempty sharing. -/ -theorem buildConstantWithSharing_recursor_wireWF - (recursor : Ixon.Recursor) (rootExprs : Array Ixon.Expr) - {state : Ix.CompileM.BlockState} (hrecursor : recursor.wireWF) - (hroots : ExprArrayWireWF rootExprs) - (htables : BlockWireTablesWF state) : - (Ix.CompileM.buildConstantWithSharing (.recr recursor) rootExprs - state.refs state.univs).wireWF := by - exact buildConstantWithSharing_wireWF - (.recr recursor) rootExprs hrecursor hroots htables - -/-- The production mutual-block builder preserves the member count and every -nested definition, inductive, constructor, recursor, and rule wire condition. -/ -theorem buildConstantWithSharing_mutual_wireWF - (members : Array Ixon.MutConst) (rootExprs : Array Ixon.Expr) - {state : Ix.CompileM.BlockState} - (hmembersCount : members.size < UInt64.size) - (hmembers : ∀ member ∈ members, member.wireWF) - (hroots : ExprArrayWireWF rootExprs) - (htables : BlockWireTablesWF state) : - (Ix.CompileM.buildConstantWithSharing (.muts members) rootExprs - state.refs state.univs).wireWF := by - exact buildConstantWithSharing_wireWF - (.muts members) rootExprs ⟨hmembersCount, hmembers⟩ hroots htables + exact hentries expr (by simpa using hmem) + +/-- When the canonical construction keeps a singleton axiom root and builds no +table, the builder yields exactly the unshared axiom assembly. -/ +theorem buildConstantWithSharing_axiom_eq_unshared + (limits : Ix.Sharing.Exact.Limits) (isUnsafe : Bool) (lvls : UInt64) + (typ : Ixon.Expr) (state : Ix.CompileM.BlockState) + {r : Ix.Sharing.Exact.TieredSharingResult} + (hsharing : Ix.Sharing.Exact.canonicalSharingTiered .tagN #[typ] limits = .ok r) + (hroots : r.result.roots = #[typ]) (htable : r.result.sharing = #[]) : + Ix.CompileM.buildConstantWithSharing limits + (.axio { isUnsafe, lvls, typ }) state.refs state.univs = + .ok (unsharedAxiomConstant isUnsafe lvls typ state) := by + have hr : Ix.Sharing.Exact.canonicalSharingTiered .tagN + (Ix.CompileM.constantInfoRootExprs (.axio { isUnsafe, lvls, typ })) limits = .ok r := + hsharing + obtain ⟨info', hw, hb⟩ := + buildConstantWithSharing_of_canonical hr (by rw [hroots]; rfl) state.refs state.univs + have hinfo : info' = .axio { isUnsafe, lvls, typ } := by + rw [hroots] at hw + have : Ix.CompileM.withRootExprs (.axio { isUnsafe, lvls, typ }) #[typ] = + .ok (.axio { isUnsafe, lvls, typ }) := rfl + rw [this] at hw + exact (Except.ok.inj hw).symm + rw [hb, hinfo] + simp [htable, unsharedAxiomConstant] + +/-- When the canonical construction keeps both definition roots and builds no +table, the builder yields exactly the unshared definition assembly. -/ +theorem buildConstantWithSharing_definition_eq_unshared + (limits : Ix.Sharing.Exact.Limits) (kind : Ix.DefKind) + (safety : Ix.DefinitionSafety) (lvls : UInt64) (typ value : Ixon.Expr) + (state : Ix.CompileM.BlockState) {r : Ix.Sharing.Exact.TieredSharingResult} + (hsharing : Ix.Sharing.Exact.canonicalSharingTiered .tagN #[typ, value] limits = .ok r) + (hroots : r.result.roots = #[typ, value]) (htable : r.result.sharing = #[]) : + Ix.CompileM.buildConstantWithSharing limits + (.defn { kind, safety, lvls, typ, value }) state.refs state.univs = + .ok (unsharedDefinitionConstant kind safety lvls typ value state) := by + have hr : Ix.Sharing.Exact.canonicalSharingTiered .tagN + (Ix.CompileM.constantInfoRootExprs (.defn { kind, safety, lvls, typ, value })) limits = + .ok r := hsharing + obtain ⟨info', hw, hb⟩ := + buildConstantWithSharing_of_canonical hr (by rw [hroots]; rfl) state.refs state.univs + have hinfo : info' = .defn { kind, safety, lvls, typ, value } := by + rw [hroots] at hw + have : Ix.CompileM.withRootExprs (.defn { kind, safety, lvls, typ, value }) #[typ, value] = + .ok (.defn { kind, safety, lvls, typ, value }) := rfl + rw [this] at hw + exact (Except.ok.inj hw).symm + rw [hb, hinfo] + simp [htable, unsharedDefinitionConstant] + /-- `BlockResult.mk'` stores exactly the production constant serialization, so every wire-well-formed block is recovered from its stored bytes. Metadata @@ -528,71 +643,100 @@ theorem BlockResult.mk'_codecWF exact ⟨hblock, BlockResult.mk'_codec_roundtrip block blockMeta projections hblock⟩ -/-- Building any wire-safe `ConstantInfo` with any wire-safe sharing roots and -then wrapping it in the production `BlockResult` yields stored bytes that -decode exactly to the built block. This includes all projection variants and -both empty and nonempty sharing results. -/ +private theorem run_bind (compileEnv : Ix.CompileM.CompileEnv) + (blockEnv : Ix.CompileM.BlockEnv) (state : Ix.CompileM.BlockState) + (action : Ix.CompileM.CompileM α) + (next : α → Ix.CompileM.CompileM β) : + Ix.CompileM.CompileM.run compileEnv blockEnv state (action >>= next) = + match Ix.CompileM.CompileM.run compileEnv blockEnv state action with + | .error err => .error err + | .ok (value, state') => + Ix.CompileM.CompileM.run compileEnv blockEnv state' (next value) := by + simp [Ix.CompileM.CompileM.run, ReaderT.run_bind, ExceptT.run_bind, + StateT.run_bind] + generalize + (ReaderT.run action (compileEnv, blockEnv)).run.run state = result + rcases result with ⟨result, state'⟩ + cases result <;> rfl + +theorem run_getBlockState_eq (compileEnv : Ix.CompileM.CompileEnv) + (blockEnv : Ix.CompileM.BlockEnv) (state : Ix.CompileM.BlockState) : + Ix.CompileM.CompileM.run compileEnv blockEnv state Ix.CompileM.getBlockState = + .ok (state, state) := rfl + +theorem run_read_eq (compileEnv : Ix.CompileM.CompileEnv) + (blockEnv : Ix.CompileM.BlockEnv) (state : Ix.CompileM.BlockState) : + Ix.CompileM.CompileM.run compileEnv blockEnv state read = + .ok ((compileEnv, blockEnv), state) := rfl + +theorem run_liftSharing_eq (compileEnv : Ix.CompileM.CompileEnv) + (blockEnv : Ix.CompileM.BlockEnv) (state : Ix.CompileM.BlockState) + (x : Except Ix.CompileM.CompileError Ixon.Constant) : + Ix.CompileM.CompileM.run compileEnv blockEnv state (Ix.CompileM.liftSharing x) = + match x with + | .ok c => .ok (c, state) + | .error e => .error e := by + cases x <;> rfl + +/-- A successful build of any wire-safe payload, wrapped in the production +`BlockResult`, stores bytes that decode exactly to the built block. This +includes all projection variants and both empty and nonempty sharing. -/ theorem BlockResult.constantInfo_codec_roundtrip - (info : Ixon.ConstantInfo) (rootExprs : Array Ixon.Expr) - {state : Ix.CompileM.BlockState} (blockMeta : Ixon.ConstantMeta) - (hinfo : info.wireWF) (hroots : ExprArrayWireWF rootExprs) + {limits : Ix.Sharing.Exact.Limits} (info : Ixon.ConstantInfo) + {state : Ix.CompileM.BlockState} {block : Ixon.Constant} + (blockMeta : Ixon.ConstantMeta) (hinfo : info.wireWF) (htables : BlockWireTablesWF state) + (h : Ix.CompileM.buildConstantWithSharing limits info + state.refs state.univs = .ok block) (projections : Array (Ix.Name × Ixon.Constant × Ixon.ConstantMeta) := #[]) : - let block := Ix.CompileM.buildConstantWithSharing - info rootExprs state.refs state.univs Ixon.deConstant - (Ix.CompileM.BlockResult.mk' - block blockMeta projections).blockBytes = .ok block := by - dsimp only + (Ix.CompileM.BlockResult.mk' block blockMeta projections).blockBytes = + .ok block := by apply BlockResult.mk'_codec_roundtrip - exact buildConstantWithSharing_wireWF - info rootExprs hinfo hroots htables + exact buildConstantWithSharing_wireWF hinfo htables h -/-- The production singleton-driver tail is observationally a read of the -current block state followed by the pure sharing builder and canonical -`BlockResult` constructor; it leaves the state unchanged. -/ +/-- The production singleton-driver tail reads the current block state, runs +the canonical sharing builder under `CompileEnv.sharingLimits` and wraps its +result in the canonical `BlockResult`; it leaves the state unchanged, and it +fails exactly when the builder does. -/ theorem finishConstantWithSharing_run (compileEnv : Ix.CompileM.CompileEnv) (blockEnv : Ix.CompileM.BlockEnv) (state : Ix.CompileM.BlockState) - (info : Ixon.ConstantInfo) (rootExprs : Array Ixon.Expr) - (blockMeta : Ixon.ConstantMeta := .empty) : + (info : Ixon.ConstantInfo) (blockMeta : Ixon.ConstantMeta := .empty) : Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.finishConstantWithSharing info rootExprs blockMeta) = - .ok (Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing - info rootExprs state.refs state.univs) - blockMeta, state) := by - rfl - -/-- The exact production tail used by singleton declaration branches returns -a wire-safe, exactly decodable block whenever compilation has established the -wire conditions for its payload, roots, and final tables. -/ + (Ix.CompileM.finishConstantWithSharing info blockMeta) = + match Ix.CompileM.buildConstantWithSharing compileEnv.sharingLimits info + state.refs state.univs with + | .ok block => .ok (Ix.CompileM.BlockResult.mk' block blockMeta, state) + | .error e => .error e := by + simp only [Ix.CompileM.finishConstantWithSharing, Ix.CompileM.buildBlockConstant, + run_bind, run_getBlockState_eq, run_read_eq, run_liftSharing_eq] + cases Ix.CompileM.buildConstantWithSharing compileEnv.sharingLimits info + state.refs state.univs <;> rfl + +/-- When the builder succeeds, the singleton-driver tail returns that block in +a wire-safe, exactly decodable `BlockResult` and leaves the state unchanged. -/ theorem finishConstantWithSharing_run_codecWF (compileEnv : Ix.CompileM.CompileEnv) (blockEnv : Ix.CompileM.BlockEnv) (state : Ix.CompileM.BlockState) - (info : Ixon.ConstantInfo) (rootExprs : Array Ixon.Expr) - (blockMeta : Ixon.ConstantMeta) (hinfo : info.wireWF) - (hroots : ExprArrayWireWF rootExprs) - (htables : BlockWireTablesWF state) : - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing - info rootExprs state.refs state.univs) - blockMeta + (info : Ixon.ConstantInfo) (blockMeta : Ixon.ConstantMeta) + {block : Ixon.Constant} (hinfo : info.wireWF) + (htables : BlockWireTablesWF state) + (hbuild : Ix.CompileM.buildConstantWithSharing compileEnv.sharingLimits info + state.refs state.univs = .ok block) : + let result := Ix.CompileM.BlockResult.mk' block blockMeta Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.finishConstantWithSharing info rootExprs blockMeta) = + (Ix.CompileM.finishConstantWithSharing info blockMeta) = .ok (result, state) ∧ BlockResultCodecWF result := by dsimp only constructor - · exact finishConstantWithSharing_run - compileEnv blockEnv state info rootExprs blockMeta + · rw [finishConstantWithSharing_run compileEnv blockEnv state info blockMeta, hbuild] · apply BlockResult.mk'_codecWF - exact buildConstantWithSharing_wireWF - info rootExprs hinfo hroots htables + exact buildConstantWithSharing_wireWF hinfo htables hbuild -/-- The canonical singleton-driver tail has the same exact run equation as -the arbitrary-root helper, specialized to roots derived from its payload. -/ +/-- `finishConstantInfoWithSharing` is `finishConstantWithSharing`. -/ theorem finishConstantInfoWithSharing_run (compileEnv : Ix.CompileM.CompileEnv) (blockEnv : Ix.CompileM.BlockEnv) (state : Ix.CompileM.BlockState) @@ -600,152 +744,85 @@ theorem finishConstantInfoWithSharing_run (blockMeta : Ixon.ConstantMeta := .empty) : Ix.CompileM.CompileM.run compileEnv blockEnv state (Ix.CompileM.finishConstantInfoWithSharing info blockMeta) = - .ok (Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state.refs state.univs) - blockMeta, state) := by - exact finishConstantWithSharing_run compileEnv blockEnv state info - (Ix.CompileM.constantInfoRootExprs info) blockMeta - -/-- Every wire-safe payload reaching the exact tail used by the six singleton -`compileConstantInfo` branches returns a wire-safe and exactly decodable main -block; no separate root-array hypothesis remains. -/ + match Ix.CompileM.buildConstantWithSharing compileEnv.sharingLimits info + state.refs state.univs with + | .ok block => .ok (Ix.CompileM.BlockResult.mk' block blockMeta, state) + | .error e => .error e := + finishConstantWithSharing_run compileEnv blockEnv state info blockMeta + + +/-- The outcome of a declaration run whose only possible failure is the +canonical sharing builder: either the run succeeds with a wire-safe, exactly +decodable `BlockResult`, or it fails with exactly the error the builder +returns on some payload and tables. This is the conclusion of the compiler +endpoint theorems; with the builder total (`SharingSucceeds`) only the first +case remains. -/ +def SharingRunOK (limits : Ix.Sharing.Exact.Limits) + (run : Except Ix.CompileM.CompileError + (Ix.CompileM.BlockResult × Ix.CompileM.BlockState)) : Prop := + (∃ result state', run = .ok (result, state') ∧ BlockResultCodecWF result) ∨ + ∃ (info : Ixon.ConstantInfo) (state' : Ix.CompileM.BlockState) + (err : Ix.CompileM.CompileError), + Ix.CompileM.buildConstantWithSharing limits info state'.refs state'.univs = + .error err ∧ run = .error err + +/-- Every successful run covered by `SharingRunOK` returns a wire-safe, exactly +decodable block. -/ +theorem SharingRunOK.codecWF {limits : Ix.Sharing.Exact.Limits} + {run : Except Ix.CompileM.CompileError + (Ix.CompileM.BlockResult × Ix.CompileM.BlockState)} + (h : SharingRunOK limits run) {result : Ix.CompileM.BlockResult} + {state' : Ix.CompileM.BlockState} (hrun : run = .ok (result, state')) : + BlockResultCodecWF result := by + rcases h with ⟨result', state'', hok, hcodec⟩ | ⟨_, _, err, _, herr⟩ + · rw [hrun] at hok + cases hok + exact hcodec + · rw [hrun] at herr + cases herr + +/-- The singleton-driver tail on a wire-safe payload: it fails only when the +canonical sharing builder does, and otherwise returns a wire-safe, exactly +decodable block. -/ theorem finishConstantInfoWithSharing_run_codecWF (compileEnv : Ix.CompileM.CompileEnv) (blockEnv : Ix.CompileM.BlockEnv) (state : Ix.CompileM.BlockState) (info : Ixon.ConstantInfo) (blockMeta : Ixon.ConstantMeta) (hinfo : info.wireWF) (htables : BlockWireTablesWF state) : - let result := Ix.CompileM.BlockResult.mk' - (Ix.CompileM.buildConstantWithSharing info - (Ix.CompileM.constantInfoRootExprs info) - state.refs state.univs) - blockMeta - Ix.CompileM.CompileM.run compileEnv blockEnv state - (Ix.CompileM.finishConstantInfoWithSharing info blockMeta) = - .ok (result, state) ∧ - BlockResultCodecWF result := by - simpa [Ix.CompileM.finishConstantInfoWithSharing] using - finishConstantWithSharing_run_codecWF compileEnv blockEnv state info - (Ix.CompileM.constantInfoRootExprs info) blockMeta hinfo - (constantInfoRootExprs_wireWF info hinfo) htables - -/-- The actual axiom builder, including nonempty sharing, stores bytes that -decode to its block. -/ -theorem BlockResult.axiom_codec_roundtrip - {isUnsafe : Bool} {lvls : UInt64} {typ : Ixon.Expr} - {state : Ix.CompileM.BlockState} (blockMeta : Ixon.ConstantMeta) - (htyp : typ.wireWF) (htables : BlockWireTablesWF state) : - let block := Ix.CompileM.buildConstantWithSharing - (.axio { isUnsafe, lvls, typ }) #[typ] state.refs state.univs - Ixon.deConstant - (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = .ok block := by - dsimp only - apply BlockResult.mk'_codec_roundtrip - exact buildConstantWithSharing_axiom_wireWF htyp htables - -/-- The actual quotient builder, including nonempty sharing, stores bytes that -decode to its block. -/ -theorem BlockResult.quotient_codec_roundtrip - {kind : Ix.QuotKind} {lvls : UInt64} {typ : Ixon.Expr} - {state : Ix.CompileM.BlockState} (blockMeta : Ixon.ConstantMeta) - (htyp : typ.wireWF) (htables : BlockWireTablesWF state) : - let block := Ix.CompileM.buildConstantWithSharing - (.quot { kind, lvls, typ }) #[typ] state.refs state.univs - Ixon.deConstant - (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = .ok block := by - dsimp only - apply BlockResult.mk'_codec_roundtrip - exact buildConstantWithSharing_quotient_wireWF htyp htables - -/-- The actual definition builder, including nonempty sharing, stores bytes -that decode to its block. -/ -theorem BlockResult.definition_codec_roundtrip - {kind : Ix.DefKind} {safety : Ix.DefinitionSafety} {lvls : UInt64} - {typ value : Ixon.Expr} {state : Ix.CompileM.BlockState} - (blockMeta : Ixon.ConstantMeta) (htyp : typ.wireWF) - (hvalue : value.wireWF) (htables : BlockWireTablesWF state) : - let block := Ix.CompileM.buildConstantWithSharing - (.defn { kind, safety, lvls, typ, value }) #[typ, value] - state.refs state.univs - Ixon.deConstant - (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = .ok block := by - dsimp only - apply BlockResult.mk'_codec_roundtrip - exact buildConstantWithSharing_definition_wireWF htyp hvalue htables - -/-- The actual recursor builder, including nonempty sharing, stores bytes that -decode to its block. -/ -theorem BlockResult.recursor_codec_roundtrip - (recursor : Ixon.Recursor) (rootExprs : Array Ixon.Expr) - {state : Ix.CompileM.BlockState} (blockMeta : Ixon.ConstantMeta) - (hrecursor : recursor.wireWF) (hroots : ExprArrayWireWF rootExprs) - (htables : BlockWireTablesWF state) : - let block := Ix.CompileM.buildConstantWithSharing - (.recr recursor) rootExprs state.refs state.univs - Ixon.deConstant - (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = .ok block := by - dsimp only - apply BlockResult.mk'_codec_roundtrip - exact buildConstantWithSharing_recursor_wireWF - recursor rootExprs hrecursor hroots htables - -/-- The actual mutual-block builder, including nonempty sharing, stores bytes -that decode to its block. -/ -theorem BlockResult.mutual_codec_roundtrip - (members : Array Ixon.MutConst) (rootExprs : Array Ixon.Expr) - {state : Ix.CompileM.BlockState} (blockMeta : Ixon.ConstantMeta) - (hmembersCount : members.size < UInt64.size) - (hmembers : ∀ member ∈ members, member.wireWF) - (hroots : ExprArrayWireWF rootExprs) - (htables : BlockWireTablesWF state) : - let block := Ix.CompileM.buildConstantWithSharing - (.muts members) rootExprs state.refs state.univs - Ixon.deConstant - (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = .ok block := by - dsimp only - apply BlockResult.mk'_codec_roundtrip - exact buildConstantWithSharing_mutual_wireWF members rootExprs - hmembersCount hmembers hroots htables - -/-- The actual no-sharing axiom builder, wrapped in the production block -result, stores bytes that decode to its block. -/ -theorem BlockResult.axiom_noSharing_codec_roundtrip - {isUnsafe : Bool} {lvls : UInt64} {typ : Ixon.Expr} - {state : Ix.CompileM.BlockState} (blockMeta : Ixon.ConstantMeta) - (hsharing : Ix.Sharing.applySharing #[typ] = (#[typ], #[])) - (htyp : typ.wireWF) (htables : BlockWireTablesWF state) : - let block := Ix.CompileM.buildConstantWithSharing - (.axio { isUnsafe, lvls, typ }) #[typ] state.refs state.univs - Ixon.deConstant - (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = .ok block := by - dsimp only - apply BlockResult.mk'_codec_roundtrip - exact buildConstantWithSharing_axiom_noSharing_wireWF - hsharing htyp htables - -/-- The actual no-sharing definition builder, wrapped in the production block -result, stores bytes that decode to its block. -/ -theorem BlockResult.definition_noSharing_codec_roundtrip - {kind : Ix.DefKind} {safety : Ix.DefinitionSafety} {lvls : UInt64} - {typ value : Ixon.Expr} {state : Ix.CompileM.BlockState} - (blockMeta : Ixon.ConstantMeta) - (hsharing : Ix.Sharing.applySharing #[typ, value] = - (#[typ, value], #[])) - (htyp : typ.wireWF) (hvalue : value.wireWF) - (htables : BlockWireTablesWF state) : - let block := Ix.CompileM.buildConstantWithSharing - (.defn { kind, safety, lvls, typ, value }) #[typ, value] - state.refs state.univs - Ixon.deConstant - (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = .ok block := by - dsimp only - apply BlockResult.mk'_codec_roundtrip - exact buildConstantWithSharing_definition_noSharing_wireWF - hsharing htyp hvalue htables + SharingRunOK compileEnv.sharingLimits + (Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.finishConstantInfoWithSharing info blockMeta)) := by + rw [finishConstantInfoWithSharing_run compileEnv blockEnv state info blockMeta] + cases hbuild : Ix.CompileM.buildConstantWithSharing compileEnv.sharingLimits info + state.refs state.univs with + | ok block => + exact .inl ⟨_, _, rfl, BlockResult.mk'_codecWF block blockMeta #[] + (buildConstantWithSharing_wireWF hinfo htables hbuild)⟩ + | error err => exact .inr ⟨info, state, err, hbuild, rfl⟩ -/-- The ordinary axiom expression phase followed by the actual no-sharing -production block builder yields stored bytes that decode to the built block. -/ +/-- When the canonical sharing of the payload succeeds, so does the +singleton-driver tail, with a wire-safe, exactly decodable block. -/ +theorem finishConstantInfoWithSharing_run_codecWF_of_succeeds + (compileEnv : Ix.CompileM.CompileEnv) + (blockEnv : Ix.CompileM.BlockEnv) (state : Ix.CompileM.BlockState) + (info : Ixon.ConstantInfo) (blockMeta : Ixon.ConstantMeta) + (hinfo : info.wireWF) (htables : BlockWireTablesWF state) + (hshare : SharingSucceeds compileEnv.sharingLimits info) : + ∃ block, + Ix.CompileM.buildConstantWithSharing compileEnv.sharingLimits info + state.refs state.univs = .ok block ∧ + Ix.CompileM.CompileM.run compileEnv blockEnv state + (Ix.CompileM.finishConstantInfoWithSharing info blockMeta) = + .ok (Ix.CompileM.BlockResult.mk' block blockMeta, state) ∧ + BlockResultCodecWF (Ix.CompileM.BlockResult.mk' block blockMeta) := by + obtain ⟨block, hbuild⟩ := buildConstantWithSharing_of_succeeds hshare state.refs state.univs + obtain ⟨hrun, hcodec⟩ := finishConstantWithSharing_run_codecWF compileEnv blockEnv state + info blockMeta hinfo htables hbuild + exact ⟨block, hbuild, hrun, hcodec⟩ + +/-- The ordinary axiom expression phase followed by a no-sharing canonical +build (the construction keeps the root and builds no table) yields stored +bytes that decode to the built block. -/ theorem compileExpr_run_ordinary_axiomBlock_noSharing_roundtrip (compileEnv : Ix.CompileM.CompileEnv) (blockEnv : Ix.CompileM.BlockEnv) @@ -755,23 +832,26 @@ theorem compileExpr_run_ordinary_axiomBlock_noSharing_roundtrip (hlevelFaithful : LevelKeyFaithfulOn levelSupport) (hexprFaithful : ExprKeyFaithfulOn OrdinaryExpr) (htables : BlockWireTablesWF snapshot) + (limits : Ix.Sharing.Exact.Limits) (isUnsafe : Bool) (lvls : UInt64) (blockMeta : Ixon.ConstantMeta) {state : Ix.CompileM.BlockState} {source : Ix.Expr} - {target : Ixon.Expr} + {target : Ixon.Expr} {r : Ix.Sharing.Exact.TieredSharingResult} (hsource : SupportedOrdinaryExpr levelSupport source) (hbound : ExprWireBound source) (hstate : FrozenExprStateWF compileEnv blockEnv levelSupport snapshot state) (href : compileExprRef (frozenRefCompileCtx compileEnv blockEnv snapshot) source = some target) - (hsharing : Ix.Sharing.applySharing #[target] = (#[target], #[])) : + (hsharing : Ix.Sharing.Exact.canonicalSharingTiered .tagN #[target] limits = .ok r) + (hroots : r.result.roots = #[target]) (htable : r.result.sharing = #[]) : ∃ root state', Ix.CompileM.CompileM.run compileEnv blockEnv state (Ix.CompileM.compileExpr source) = .ok ((target, root), state') ∧ FrozenExprStateWF compileEnv blockEnv levelSupport snapshot state' ∧ - (let block := Ix.CompileM.buildConstantWithSharing - (.axio { isUnsafe, lvls, typ := target }) #[target] - state'.refs state'.univs + (let block := unsharedAxiomConstant isUnsafe lvls target state' + Ix.CompileM.buildConstantWithSharing limits + (.axio { isUnsafe, lvls, typ := target }) state'.refs state'.univs = + .ok block ∧ block.wireWF ∧ Ixon.deConstant (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = @@ -782,18 +862,12 @@ theorem compileExpr_run_ordinary_axiomBlock_noSharing_roundtrip isUnsafe lvls hsource hbound hstate href refine ⟨root, state', hrun, hstate', ?_⟩ dsimp only - have hblock : - (Ix.CompileM.buildConstantWithSharing - (.axio { isUnsafe, lvls, typ := target }) #[target] - state'.refs state'.univs).wireWF := by - rw [buildConstantWithSharing_axiom_eq_unshared - isUnsafe lvls target state' hsharing] - exact hunshared - exact ⟨hblock, BlockResult.mk'_codec_roundtrip _ blockMeta #[] hblock⟩ + exact ⟨buildConstantWithSharing_axiom_eq_unshared limits isUnsafe lvls target state' + hsharing hroots htable, hunshared, + BlockResult.mk'_codec_roundtrip _ blockMeta #[] hunshared⟩ -/-- The sequential definition expression phase followed by the actual -no-sharing production block builder yields stored bytes that decode to the -built block. -/ +/-- The sequential definition expression phase followed by a no-sharing +canonical build yields stored bytes that decode to the built block. -/ theorem compileExpr_run_ordinary_definitionBlock_noSharing_roundtrip (compileEnv : Ix.CompileM.CompileEnv) (blockEnv : Ix.CompileM.BlockEnv) @@ -803,11 +877,13 @@ theorem compileExpr_run_ordinary_definitionBlock_noSharing_roundtrip (hlevelFaithful : LevelKeyFaithfulOn levelSupport) (hexprFaithful : ExprKeyFaithfulOn OrdinaryExpr) (htables : BlockWireTablesWF snapshot) + (limits : Ix.Sharing.Exact.Limits) (kind : Ix.DefKind) (safety : Ix.DefinitionSafety) (lvls : UInt64) (blockMeta : Ixon.ConstantMeta) {state : Ix.CompileM.BlockState} {sourceType sourceValue : Ix.Expr} {targetType targetValue : Ixon.Expr} + {r : Ix.Sharing.Exact.TieredSharingResult} (hsourceType : SupportedOrdinaryExpr levelSupport sourceType) (hsourceValue : SupportedOrdinaryExpr levelSupport sourceValue) (hboundType : ExprWireBound sourceType) @@ -819,8 +895,10 @@ theorem compileExpr_run_ordinary_definitionBlock_noSharing_roundtrip (hrefValue : compileExprRef (frozenRefCompileCtx compileEnv blockEnv snapshot) sourceValue = some targetValue) - (hsharing : Ix.Sharing.applySharing #[targetType, targetValue] = - (#[targetType, targetValue], #[])) : + (hsharing : Ix.Sharing.Exact.canonicalSharingTiered .tagN + #[targetType, targetValue] limits = .ok r) + (hroots : r.result.roots = #[targetType, targetValue]) + (htable : r.result.sharing = #[]) : ∃ typeRoot middle valueRoot state', Ix.CompileM.CompileM.run compileEnv blockEnv state (Ix.CompileM.compileExpr sourceType) = @@ -830,10 +908,11 @@ theorem compileExpr_run_ordinary_definitionBlock_noSharing_roundtrip (Ix.CompileM.compileExpr sourceValue) = .ok ((targetValue, valueRoot), state') ∧ FrozenExprStateWF compileEnv blockEnv levelSupport snapshot state' ∧ - (let block := Ix.CompileM.buildConstantWithSharing - (.defn ⟨kind, safety, lvls, targetType, targetValue⟩) - #[targetType, targetValue] - state'.refs state'.univs + (let block := unsharedDefinitionConstant kind safety lvls targetType + targetValue state' + Ix.CompileM.buildConstantWithSharing limits + (.defn ⟨kind, safety, lvls, targetType, targetValue⟩) + state'.refs state'.univs = .ok block ∧ block.wireWF ∧ Ixon.deConstant (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = @@ -847,18 +926,13 @@ theorem compileExpr_run_ordinary_definitionBlock_noSharing_roundtrip refine ⟨typeRoot, middle, valueRoot, state', htypeRun, hmiddle, hvalueRun, hstate', ?_⟩ dsimp only - have hblock : - (Ix.CompileM.buildConstantWithSharing - (.defn ⟨kind, safety, lvls, targetType, targetValue⟩) - #[targetType, targetValue] - state'.refs state'.univs).wireWF := by - rw [buildConstantWithSharing_definition_eq_unshared - kind safety lvls targetType targetValue state' hsharing] - exact hunshared - exact ⟨hblock, BlockResult.mk'_codec_roundtrip _ blockMeta #[] hblock⟩ + exact ⟨buildConstantWithSharing_definition_eq_unshared limits kind safety lvls + targetType targetValue state' hsharing hroots htable, hunshared, + BlockResult.mk'_codec_roundtrip _ blockMeta #[] hunshared⟩ -/-- The ordinary axiom expression phase followed by the complete production -sharing builder yields a wire-safe block whose stored bytes decode exactly. -/ +/-- The ordinary axiom expression phase followed by the canonical sharing +builder: every successful build is a wire-safe block whose stored bytes +decode exactly. -/ theorem compileExpr_run_ordinary_axiomBlock_roundtrip (compileEnv : Ix.CompileM.CompileEnv) (blockEnv : Ix.CompileM.BlockEnv) @@ -881,13 +955,14 @@ theorem compileExpr_run_ordinary_axiomBlock_roundtrip (Ix.CompileM.compileExpr source) = .ok ((target, root), state') ∧ FrozenExprStateWF compileEnv blockEnv levelSupport snapshot state' ∧ - (let block := Ix.CompileM.buildConstantWithSharing - (.axio { isUnsafe, lvls, typ := target }) #[target] - state'.refs state'.univs - block.wireWF ∧ - Ixon.deConstant - (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = - .ok block) := by + ∀ (limits : Ix.Sharing.Exact.Limits) (block : Ixon.Constant), + Ix.CompileM.buildConstantWithSharing limits + (.axio { isUnsafe, lvls, typ := target }) state'.refs state'.univs = + .ok block → + block.wireWF ∧ + Ixon.deConstant + (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = + .ok block := by obtain ⟨root, state', hrun, hstate', hunshared, _⟩ := compileExpr_run_ordinary_axiomConstant_roundtrip compileEnv blockEnv snapshot hfree hclosed hlevelFaithful hexprFaithful htables @@ -895,13 +970,14 @@ theorem compileExpr_run_ordinary_axiomBlock_roundtrip have htables' : BlockWireTablesWF state' := htables.of_exprTableView_eq hstate'.tables refine ⟨root, state', hrun, hstate', ?_⟩ - dsimp only - have hblock := buildConstantWithSharing_axiom_wireWF - (isUnsafe := isUnsafe) (lvls := lvls) hunshared.1 htables' + intro limits block hbuild + have hblock := buildConstantWithSharing_wireWF + (info := .axio { isUnsafe, lvls, typ := target }) hunshared.1 htables' hbuild exact ⟨hblock, BlockResult.mk'_codec_roundtrip _ blockMeta #[] hblock⟩ /-- Sequential ordinary compilation of a definition's type and value followed -by complete production sharing yields a wire-safe, exactly decodable block. -/ +by the canonical sharing builder: every successful build is a wire-safe, +exactly decodable block. -/ theorem compileExpr_run_ordinary_definitionBlock_roundtrip (compileEnv : Ix.CompileM.CompileEnv) (blockEnv : Ix.CompileM.BlockEnv) @@ -936,13 +1012,14 @@ theorem compileExpr_run_ordinary_definitionBlock_roundtrip (Ix.CompileM.compileExpr sourceValue) = .ok ((targetValue, valueRoot), state') ∧ FrozenExprStateWF compileEnv blockEnv levelSupport snapshot state' ∧ - (let block := Ix.CompileM.buildConstantWithSharing - (.defn ⟨kind, safety, lvls, targetType, targetValue⟩) - #[targetType, targetValue] state'.refs state'.univs - block.wireWF ∧ - Ixon.deConstant - (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = - .ok block) := by + ∀ (limits : Ix.Sharing.Exact.Limits) (block : Ixon.Constant), + Ix.CompileM.buildConstantWithSharing limits + (.defn ⟨kind, safety, lvls, targetType, targetValue⟩) + state'.refs state'.univs = .ok block → + block.wireWF ∧ + Ixon.deConstant + (Ix.CompileM.BlockResult.mk' block blockMeta).blockBytes = + .ok block := by obtain ⟨typeRoot, middle, valueRoot, state', htypeRun, hmiddle, hvalueRun, hstate', hunshared, _⟩ := compileExpr_run_ordinary_definitionConstant_roundtrip compileEnv blockEnv @@ -953,10 +1030,9 @@ theorem compileExpr_run_ordinary_definitionBlock_roundtrip htables.of_exprTableView_eq hstate'.tables refine ⟨typeRoot, middle, valueRoot, state', htypeRun, hmiddle, hvalueRun, hstate', ?_⟩ - dsimp only - have hblock := buildConstantWithSharing_definition_wireWF - (kind := kind) (safety := safety) (lvls := lvls) - hunshared.1.1 hunshared.1.2 htables' + intro limits block hbuild + have hblock := buildConstantWithSharing_wireWF + (info := .defn ⟨kind, safety, lvls, targetType, targetValue⟩) hunshared.1 htables' hbuild exact ⟨hblock, BlockResult.mk'_codec_roundtrip _ blockMeta #[] hblock⟩ end Ix.Compile.Verify diff --git a/Ix/Compile/Verify/ConstantCodec.lean b/Ix/Compile/Verify/ConstantCodec.lean index b754f21ac..6aa18db31 100644 --- a/Ix/Compile/Verify/ConstantCodec.lean +++ b/Ix/Compile/Verify/ConstantCodec.lean @@ -1,7 +1,7 @@ import Ix.Compile.Verify.ExprSpineCodec /-! -# Proof-visible v3 core constant codec +# Proof-visible Ixon core constant codec This slice composes the verified arbitrary-spine expression codec through production definition and axiom payloads, their `ConstantInfo` tags, and a @@ -85,17 +85,17 @@ theorem getDefinition_reads (definition : Ixon.Definition) return ({ definition with typ, value } : Ixon.Definition)) htypRead hafterValue have hafterLvls := Reads.bind - (next := fun lvls : Ixon.Tag0 => do + (next := fun lvls : Ixon.TagN => do let typ ← Ixon.getExpr let value ← Ixon.getExpr - return ({ definition with lvls := lvls.size, typ, value } : + return ({ definition with lvls := lvls.value, typ, value } : Ixon.Definition)) hlvls hafterTyp have hafterLvls' : Reads (match Ixon.unpackDefKindSafety (Ixon.packDefKindSafety definition.kind definition.safety) with | (kind, safety) => do - let lvls := (← Ixon.getTag0).size + let lvls := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr let value ← Ixon.getExpr return (⟨kind, safety, lvls, typ, value⟩ : Ixon.Definition)) @@ -110,7 +110,7 @@ theorem getDefinition_reads (definition : Ixon.Definition) if packed >>> 2 > 2 || (packed &&& 3) > 2 then throw "invalid definition kind/safety" let (kind, safety) := Ixon.unpackDefKindSafety packed - let lvls := (← Ixon.getTag0).size + let lvls := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr let value ← Ixon.getExpr return (⟨kind, safety, lvls, typ, value⟩ : Ixon.Definition)) @@ -123,7 +123,7 @@ theorem getDefinition_reads (definition : Ixon.Definition) if packed >>> 2 > 2 || (packed &&& 3) > 2 then throw "invalid definition kind/safety" let (kind, safety) := Ixon.unpackDefKindSafety packed - let lvls := (← Ixon.getTag0).size + let lvls := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr let value ← Ixon.getExpr return (⟨kind, safety, lvls, typ, value⟩ : Ixon.Definition)) @@ -143,13 +143,13 @@ theorem getAxiom_reads (axiomInfo : Ixon.Axiom) (pure ({ axiomInfo with typ } : Ixon.Axiom) : Ixon.GetM Ixon.Axiom)) htypRead hreturn have hafterLvls := Reads.bind - (next := fun lvls : Ixon.Tag0 => do + (next := fun lvls : Ixon.TagN => do let typ ← Ixon.getExpr - return ({ axiomInfo with lvls := lvls.size, typ } : Ixon.Axiom)) + return ({ axiomInfo with lvls := lvls.value, typ } : Ixon.Axiom)) hlvls hafterTyp have hall := Reads.bind (next := fun isUnsafe : Bool => do - let lvls := (← Ixon.getTag0).size + let lvls := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr return (⟨isUnsafe, lvls, typ⟩ : Ixon.Axiom)) hbool hafterLvls @@ -210,14 +210,14 @@ theorem reads_map {getm : Ixon.GetM α} {bytes : ByteArray} {value : α} rw [EStateM.bind, h] rfl -def getInfoFromTag (tag : Ixon.Tag4) : Ixon.GetM Ixon.ConstantInfo := do +def getInfoFromTag (tag : Ixon.TagN) : Ixon.GetM Ixon.ConstantInfo := do if tag.flag == Ixon.Constant.FLAG_MUTS then let mut ms := #[] - for _ in [0:tag.size.toNat] do + for _ in [0:tag.value.toNat] do ms := ms.push (← Ixon.getMutConst) return Ixon.ConstantInfo.muts ms else if tag.flag == Ixon.Constant.FLAG then - match tag.size with + match tag.value with | 0 => Ixon.ConstantInfo.defn <$> Ixon.getDefinition | 1 => Ixon.ConstantInfo.recr <$> Ixon.getRecursor | 2 => Ixon.ConstantInfo.axio <$> Ixon.getAxiom @@ -231,7 +231,7 @@ def getInfoFromTag (tag : Ixon.Tag4) : Ixon.GetM Ixon.ConstantInfo := do throw s!"getConstantInfo: invalid flag {tag.flag}" theorem getConstantInfo_eq : - Ixon.getConstantInfo = (Ixon.getTag4 >>= getInfoFromTag) := by + Ixon.getConstantInfo = ((Ixon.getTagN 4) >>= getInfoFromTag) := by rfl theorem putConstantInfo_writes_core (info : Ixon.ConstantInfo) @@ -304,7 +304,7 @@ def emptyConstantBytes (info : Ixon.ConstantInfo) : ByteArray := def getConstantUnivs (info : Ixon.ConstantInfo) (sharing : Array Ixon.Expr) (refs : Array Address) : Ixon.GetM Ixon.Constant := do - let numUnivs := (← Ixon.getTag0).size.toNat + let numUnivs := (← Ixon.getTagN 0).value.toNat let mut univs : Array Ixon.Univ := #[] for _ in [0:numUnivs] do univs := univs.push (← Ixon.getUniv) @@ -312,7 +312,7 @@ def getConstantUnivs (info : Ixon.ConstantInfo) def getConstantRefs (info : Ixon.ConstantInfo) (sharing : Array Ixon.Expr) : Ixon.GetM Ixon.Constant := do - let numRefs := (← Ixon.getTag0).size.toNat + let numRefs := (← Ixon.getTagN 0).value.toNat let mut refs : Array Address := #[] for _ in [0:numRefs] do refs := refs.push (← Ixon.Serialize.get) @@ -320,7 +320,7 @@ def getConstantRefs (info : Ixon.ConstantInfo) def getConstantAfterInfo (info : Ixon.ConstantInfo) : Ixon.GetM Ixon.Constant := do - let numSharing := (← Ixon.getTag0).size.toNat + let numSharing := (← Ixon.getTagN 0).value.toNat let mut sharing : Array Ixon.Expr := #[] for _ in [0:numSharing] do sharing := sharing.push (← Ixon.getExpr) @@ -355,9 +355,9 @@ theorem getConstant_reads_core_empty (info : Ixon.ConstantInfo) ByteArray.empty (emptyConstant info) := by simpa [emptyConstant] using hreturn have hunivs := Reads.bind - (next := fun count : Ixon.Tag0 => do + (next := fun count : Ixon.TagN => do let mut univs : Array Ixon.Univ := #[] - for _ in [0:count.size.toNat] do + for _ in [0:count.value.toNat] do univs := univs.push (← Ixon.getUniv) return (⟨info, #[], #[], univs⟩ : Ixon.Constant)) hzero hunivsTail @@ -373,9 +373,9 @@ theorem getConstant_reads_core_empty (info : Ixon.ConstantInfo) (tag0Bytes 0) (emptyConstant info) := by simpa using hunivs' have hrefs := Reads.bind - (next := fun count : Ixon.Tag0 => do + (next := fun count : Ixon.TagN => do let mut refs : Array Address := #[] - for _ in [0:count.size.toNat] do + for _ in [0:count.value.toNat] do refs := refs.push (← Ixon.Serialize.get) getConstantUnivs info #[] refs) hzero hrefsTail @@ -391,9 +391,9 @@ theorem getConstant_reads_core_empty (info : Ixon.ConstantInfo) (tag0Bytes 0 ++ tag0Bytes 0) (emptyConstant info) := by simpa using hrefs' have hsharing := Reads.bind - (next := fun count : Ixon.Tag0 => do + (next := fun count : Ixon.TagN => do let mut sharing : Array Ixon.Expr := #[] - for _ in [0:count.size.toNat] do + for _ in [0:count.value.toNat] do sharing := sharing.push (← Ixon.getExpr) getConstantRefs info sharing) hzero hsharingTail diff --git a/Ix/Compile/Verify/ConstantTablesCodec.lean b/Ix/Compile/Verify/ConstantTablesCodec.lean index ba17595e7..3549eb50d 100644 --- a/Ix/Compile/Verify/ConstantTablesCodec.lean +++ b/Ix/Compile/Verify/ConstantTablesCodec.lean @@ -304,9 +304,9 @@ theorem getConstantUnivs_reads_core (info : Ixon.ConstantInfo) ⟨info, sharing, refs, univs⟩ := by simpa [getMany, hdecode] using hafterValues have hall := Reads.bind - (next := fun count : Ixon.Tag0 => do + (next := fun count : Ixon.TagN => do let mut decoded : Array Ixon.Univ := #[] - for _ in [0:count.size.toNat] do + for _ in [0:count.value.toNat] do decoded := decoded.push (← Ixon.getUniv) return (⟨info, sharing, refs, decoded⟩ : Ixon.Constant)) htag htail @@ -345,9 +345,9 @@ theorem getConstantRefs_reads_core (info : Ixon.ConstantInfo) ⟨info, sharing, refs, univs⟩ := by simpa [getMany, hdecode, ByteArray.append_assoc] using hafterValues have hall := Reads.bind - (next := fun count : Ixon.Tag0 => do + (next := fun count : Ixon.TagN => do let mut decoded : Array Address := #[] - for _ in [0:count.size.toNat] do + for _ in [0:count.value.toNat] do decoded := decoded.push (← Ixon.Serialize.get) getConstantUnivs info sharing decoded) htag htail @@ -391,9 +391,9 @@ theorem getConstantAfterInfo_reads_core (info : Ixon.ConstantInfo) ⟨info, sharing, refs, univs⟩ := by simpa [getMany, hdecode, ByteArray.append_assoc] using hafterValues have hall := Reads.bind - (next := fun count : Ixon.Tag0 => do + (next := fun count : Ixon.TagN => do let mut decoded : Array Ixon.Expr := #[] - for _ in [0:count.size.toNat] do + for _ in [0:count.value.toNat] do decoded := decoded.push (← Ixon.getExpr) getConstantRefs info decoded) htag htail diff --git a/Ix/Compile/Verify/ExprCodec.lean b/Ix/Compile/Verify/ExprCodec.lean index 2c3e69849..a8495e28f 100644 --- a/Ix/Compile/Verify/ExprCodec.lean +++ b/Ix/Compile/Verify/ExprCodec.lean @@ -1,12 +1,12 @@ import Ix.Compile.Verify.Codec /-! -# Proof-visible v3 expression codec +# Proof-visible Ixon expression codec This expression slice proves the production writer/reader inverse for all constructors with wire-sized universe-instantiation vectors and canonical singleton application/lambda/forall spines. Numeric fields use the complete -`Tag0`/`Tag4` laws, so they are not artificially restricted to one-byte tags. +TagN laws (`f = 0` and `f = 4`), so they are not artificially restricted to one-byte tags. -/ namespace Ix.Compile.Verify.Codec.Ixon.Expr @@ -56,7 +56,7 @@ theorem collectAllBinders_eq_of_notAll (e : Ixon.Expr) (h : notAll e) : e.collectAllBinders = ([], e) := by cases e <;> simp_all [notAll, Ixon.Expr.collectAllBinders] -/-- Concatenated `Tag0` encodings in list order. -/ +/-- Concatenated TagN (`f = 0`) encodings in list order. -/ def tag0ListBytes : List UInt64 → ByteArray | [] => ByteArray.empty | idx :: idxs => tag0Bytes idx ++ tag0ListBytes idxs @@ -90,9 +90,8 @@ def wireEncode : Ixon.Expr → ByteArray (wireEncode ty ++ (wireEncode val ++ wireEncode body))) | .share idx => tag4Bytes Ixon.Expr.FLAG_SHARE idx -theorem tag0Bytes_size_pos (size : UInt64) : 0 < (tag0Bytes size).size := by - unfold tag0Bytes - split <;> simp <;> omega +theorem tag0Bytes_size_pos (size : UInt64) : 0 < (tag0Bytes size).size := + tagNBytes_size_pos 0 0 size theorem tag0ListBytes_size_ge_length (idxs : List UInt64) : idxs.length ≤ (tag0ListBytes idxs).size := by @@ -104,9 +103,8 @@ theorem tag0ListBytes_size_ge_length (idxs : List UInt64) : omega theorem tag4Bytes_size_pos (flag : UInt8) (size : UInt64) : - 0 < (tag4Bytes flag size).size := by - unfold tag4Bytes - split <;> simp <;> omega + 0 < (tag4Bytes flag size).size := + tagNBytes_size_pos 4 flag size theorem wireEncode_size_pos (e : Ixon.Expr) : 0 < (wireEncode e).size := by cases e with @@ -170,7 +168,7 @@ theorem indexVectorWF_count (idxs : Array UInt64) (h : IndexVectorWF idxs) : exact UInt64.toNat_ofNat_of_lt h def putTag0List (idxs : List UInt64) : Ixon.PutM Unit := - idxs.foldlM (fun _ idx => Ixon.putTag0 ⟨idx⟩) () + idxs.foldlM (fun _ idx => Ixon.putTagN 0 0 idx) () theorem putTag0List_writes (idxs : List UInt64) : Writes (putTag0List idxs) (tag0ListBytes idxs) := by @@ -185,22 +183,22 @@ theorem putTag0List_writes (idxs : List UInt64) : (putTag0_writes idx).bind ih theorem arrayPutTag0_eq_putTag0List (idxs : Array UInt64) : - (do for idx in idxs do Ixon.putTag0 ⟨idx⟩) = + (do for idx in idxs do Ixon.putTagN 0 0 idx) = putTag0List idxs.toList := by rw [← Array.forIn_toList] simp [putTag0List] theorem arrayPutTag0_writes (idxs : Array UInt64) : - Writes (do for idx in idxs do Ixon.putTag0 ⟨idx⟩) + Writes (do for idx in idxs do Ixon.putTagN 0 0 idx) (tag0ListBytes idxs.toList) := by rw [arrayPutTag0_eq_putTag0List] exact putTag0List_writes idxs.toList -theorem getTag0Sizes_reads (idxs : List UInt64) : - Reads (Ixon.getTag0Sizes idxs.length) (tag0ListBytes idxs) idxs := by +theorem getTagN0Values_reads (idxs : List UInt64) : + Reads (Ixon.getTagN0Values idxs.length) (tag0ListBytes idxs) idxs := by induction idxs with | nil => - simpa [Ixon.getTag0Sizes, tag0ListBytes] using + simpa [Ixon.getTagN0Values, tag0ListBytes] using (Reads.pure ([] : List UInt64)) | cons idx idxs ih => have hhead := getTag0_reads idx @@ -210,11 +208,11 @@ theorem getTag0Sizes_reads (idxs : List UInt64) : (pure (idx :: tail) : Ixon.GetM (List UInt64))) ih hreturn have hall := Reads.bind - (next := fun decoded : Ixon.Tag0 => do - let tail ← Ixon.getTag0Sizes idxs.length - return decoded.size :: tail) + (next := fun decoded : Ixon.TagN => do + let tail ← Ixon.getTagN0Values idxs.length + return decoded.value :: tail) hhead htail - simpa [Ixon.getTag0Sizes, tag0ListBytes] using hall + simpa [Ixon.getTagN0Values, tag0ListBytes] using hall end Ix.Compile.Verify.Codec.Ixon.Expr @@ -339,7 +337,7 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e) have htag := getTag4_reads Ixon.Expr.FLAG_REF univs.size.toUInt64 (by decide) have hidx := getTag0_reads refIdx - have hunivs := getTag0Sizes_reads univs.toList + have hunivs := getTagN0Values_reads univs.toList have hreturn : Reads (pure (Ixon.Expr.ref refIdx univs.toList.toArray) : Ixon.GetM Ixon.Expr) @@ -354,11 +352,11 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e) (by simpa [hcount] using tag0ListBytes_size_ge_length univs.toList) hafterUnivs have htail := Reads.bind - (next := fun decoded : Ixon.Tag0 => + (next := fun decoded : Ixon.TagN => (do Ixon.checkCount univs.size.toUInt64 - let decodedUnivs ← Ixon.getTag0Sizes univs.toList.length - return Ixon.Expr.ref decoded.size decodedUnivs.toArray)) + let decodedUnivs ← Ixon.getTagN0Values univs.toList.length + return Ixon.Expr.ref decoded.value decodedUnivs.toArray)) hidx hcheckedUnivs have hparsed : Reads (Ixon.getExprFromTag (Ixon.getExprFuel fuel) @@ -379,7 +377,7 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e) have htag := getTag4_reads Ixon.Expr.FLAG_REC univs.size.toUInt64 (by decide) have hidx := getTag0_reads recIdx - have hunivs := getTag0Sizes_reads univs.toList + have hunivs := getTagN0Values_reads univs.toList have hreturn : Reads (pure (Ixon.Expr.recur recIdx univs.toList.toArray) : Ixon.GetM Ixon.Expr) @@ -394,11 +392,11 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e) (by simpa [hcount] using tag0ListBytes_size_ge_length univs.toList) hafterUnivs have htail := Reads.bind - (next := fun decoded : Ixon.Tag0 => + (next := fun decoded : Ixon.TagN => (do Ixon.checkCount univs.size.toUInt64 - let decodedUnivs ← Ixon.getTag0Sizes univs.toList.length - return Ixon.Expr.recur decoded.size decodedUnivs.toArray)) + let decodedUnivs ← Ixon.getTagN0Values univs.toList.length + return Ixon.Expr.recur decoded.value decodedUnivs.toArray)) hidx hcheckedUnivs have hparsed : Reads (Ixon.getExprFromTag (Ixon.getExprFuel fuel) @@ -431,9 +429,9 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e) Ixon.GetM Ixon.Expr)) hval hreturn have htail := Reads.bind - (next := fun decodedIdx : Ixon.Tag0 => do + (next := fun decodedIdx : Ixon.TagN => do let decodedVal ← Ixon.getExprFuel fuel - return Ixon.Expr.prj decodedIdx.size fieldIdx decodedVal) + return Ixon.Expr.prj decodedIdx.value fieldIdx decodedVal) hidx hafterVal have hparsed : Reads (Ixon.getExprFromTag (Ixon.getExprFuel fuel) diff --git a/Ix/Compile/Verify/ExprSpineCodec.lean b/Ix/Compile/Verify/ExprSpineCodec.lean index 75eca0cca..ce258c2e6 100644 --- a/Ix/Compile/Verify/ExprSpineCodec.lean +++ b/Ix/Compile/Verify/ExprSpineCodec.lean @@ -975,7 +975,7 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF) have htag := getTag4_reads Ixon.Expr.FLAG_REF univs.size.toUInt64 (by decide) have hidx := getTag0_reads refIdx - have hunivs := getTag0Sizes_reads univs.toList + have hunivs := getTagN0Values_reads univs.toList have hreturn : Reads (pure (Ixon.Expr.ref refIdx univs.toList.toArray) : Ixon.GetM Ixon.Expr) @@ -989,10 +989,10 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF) (by simpa [hcount] using tag0ListBytes_size_ge_length univs.toList) hafterUnivs have htail0 := Reads.bind - (next := fun decoded : Ixon.Tag0 => do + (next := fun decoded : Ixon.TagN => do Ixon.checkCount univs.size.toUInt64 - let decodedUnivs ← Ixon.getTag0Sizes univs.toList.length - return Ixon.Expr.ref decoded.size decodedUnivs.toArray) + let decodedUnivs ← Ixon.getTagN0Values univs.toList.length + return Ixon.Expr.ref decoded.value decodedUnivs.toArray) hidx hcheckedUnivs have hparsed : Reads (Ixon.getExprFromTag (Ixon.getExprFuel fuel) @@ -1010,7 +1010,7 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF) have htag := getTag4_reads Ixon.Expr.FLAG_REC univs.size.toUInt64 (by decide) have hidx := getTag0_reads recIdx - have hunivs := getTag0Sizes_reads univs.toList + have hunivs := getTagN0Values_reads univs.toList have hreturn : Reads (pure (Ixon.Expr.recur recIdx univs.toList.toArray) : Ixon.GetM Ixon.Expr) @@ -1024,10 +1024,10 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF) (by simpa [hcount] using tag0ListBytes_size_ge_length univs.toList) hafterUnivs have htail0 := Reads.bind - (next := fun decoded : Ixon.Tag0 => do + (next := fun decoded : Ixon.TagN => do Ixon.checkCount univs.size.toUInt64 - let decodedUnivs ← Ixon.getTag0Sizes univs.toList.length - return Ixon.Expr.recur decoded.size decodedUnivs.toArray) + let decodedUnivs ← Ixon.getTagN0Values univs.toList.length + return Ixon.Expr.recur decoded.value decodedUnivs.toArray) hidx hcheckedUnivs have hparsed : Reads (Ixon.getExprFromTag (Ixon.getExprFuel fuel) @@ -1056,9 +1056,9 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF) (pure (Ixon.Expr.prj typeRefIdx fieldIdx decodedVal) : Ixon.GetM Ixon.Expr)) hval hreturn have htail0 := Reads.bind - (next := fun decodedIdx : Ixon.Tag0 => do + (next := fun decodedIdx : Ixon.TagN => do let decodedVal ← Ixon.getExprFuel fuel - return Ixon.Expr.prj decodedIdx.size fieldIdx decodedVal) + return Ixon.Expr.prj decodedIdx.value fieldIdx decodedVal) hidx hafterVal have hparsed : Reads (Ixon.getExprFromTag (Ixon.getExprFuel fuel) diff --git a/Ix/Compile/Verify/IxonValue.lean b/Ix/Compile/Verify/IxonValue.lean index 18f489ed7..3cf555f2c 100644 --- a/Ix/Compile/Verify/IxonValue.lean +++ b/Ix/Compile/Verify/IxonValue.lean @@ -3,7 +3,7 @@ import Lean4Lean.Theory.Literals import Lean4Lean.Theory.Typing.Env /-! -# Ixon v3 expressions and Lean4Lean values +# Ixon expressions and Lean4Lean values This is the first compiler-facing semantic boundary. It interprets an Ixon expression directly as a Lean4Lean `VExpr`; it does not run Ix.Tc and does not @@ -13,7 +13,7 @@ The relation is table-aware. It resolves universe, reference, mutual-member, sharing, and literal indices against an explicit immutable context. A cyclic sharing table has no finite derivation. Lambda usage and forall usage/ownership are intentionally absent from the semantic premises: ordinary -Lean compilation inhabits `.many`/`.shared`, while v3 contracts remain +Lean compilation inhabits `.many`/`.shared`, while Ixon contracts remain available to later substructural passes without changing the Lean meaning. -/ @@ -192,7 +192,7 @@ theorem mono {venv venv' : VEnv} (henv : venv ≤ venv') end IxonExprRel -/-- Erase v3 contracts into the conservative Lean fragment. -/ +/-- Erase Ixon contracts into the conservative Lean fragment. -/ def eraseBinderModes : Ixon.Expr → Ixon.Expr | .sort idx => .sort idx | .var idx => .var idx @@ -248,7 +248,7 @@ theorem eraseBinderModes_eq_self_of_leanFragment {expr : Ixon.Expr} namespace IxonExprRel -/-- Erasing v3 contracts preserves every direct Theory value derivation. -/ +/-- Erasing Ixon contracts preserves every direct Theory value derivation. -/ theorem eraseModes {venv : VEnv} {catalog : Catalog} {dctx : DecodeCtx} {trProj : ProjectionRel} {uvars : Nat} {locals : List VExpr} {expr : Ixon.Expr} {value : VExpr} @@ -273,7 +273,7 @@ theorem eraseModes {venv : VEnv} {catalog : Catalog} {dctx : DecodeCtx} | share href hexp _ => exact .share href hexp /-- A derivation for the conservative erasure can be decorated with the -original v3 contracts. No semantic evidence is invented or discarded. -/ +original Ixon contracts. No semantic evidence is invented or discarded. -/ theorem of_eraseModes {venv : VEnv} {catalog : Catalog} {dctx : DecodeCtx} {trProj : ProjectionRel} {uvars : Nat} {locals : List VExpr} {expr : Ixon.Expr} {value : VExpr} @@ -301,7 +301,7 @@ theorem of_eraseModes {venv : VEnv} {catalog : Catalog} {dctx : DecodeCtx} | letE hty hval hbody => exact .letE (ihty hty) (ihval hval) (ihbody hbody) -/-- V3 contracts are semantically inert at the Lean compiler boundary. -/ +/-- Ixon contracts are semantically inert at the Lean compiler boundary. -/ theorem eraseModes_iff {venv : VEnv} {catalog : Catalog} {dctx : DecodeCtx} {trProj : ProjectionRel} {uvars : Nat} {locals : List VExpr} {expr : Ixon.Expr} {value : VExpr} : diff --git a/Ix/Compile/Verify/MutualConstantCodec.lean b/Ix/Compile/Verify/MutualConstantCodec.lean index d3d001e8f..9f50dc967 100644 --- a/Ix/Compile/Verify/MutualConstantCodec.lean +++ b/Ix/Compile/Verify/MutualConstantCodec.lean @@ -70,41 +70,41 @@ theorem getConstructor_reads (constructor : Ixon.Constructor) Ixon.GetM Ixon.Constructor)) htyp hreturn have hafterFields := Reads.bind - (next := fun fields : Ixon.Tag0 => do + (next := fun fields : Ixon.TagN => do let typ ← Ixon.getExpr - return ({ constructor with fields := fields.size, typ } : + return ({ constructor with fields := fields.value, typ } : Ixon.Constructor)) hfields hafterTyp have hafterParams := Reads.bind - (next := fun params : Ixon.Tag0 => do - let fields := (← Ixon.getTag0).size + (next := fun params : Ixon.TagN => do + let fields := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr - return ({ constructor with params := params.size, fields, typ } : + return ({ constructor with params := params.value, fields, typ } : Ixon.Constructor)) hparams hafterFields have hafterCidx := Reads.bind - (next := fun cidx : Ixon.Tag0 => do - let params := (← Ixon.getTag0).size - let fields := (← Ixon.getTag0).size + (next := fun cidx : Ixon.TagN => do + let params := (← Ixon.getTagN 0).value + let fields := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr - return ({ constructor with cidx := cidx.size, params, fields, typ } : + return ({ constructor with cidx := cidx.value, params, fields, typ } : Ixon.Constructor)) hcidx hafterParams have hafterLvls := Reads.bind - (next := fun lvls : Ixon.Tag0 => do - let cidx := (← Ixon.getTag0).size - let params := (← Ixon.getTag0).size - let fields := (← Ixon.getTag0).size + (next := fun lvls : Ixon.TagN => do + let cidx := (← Ixon.getTagN 0).value + let params := (← Ixon.getTagN 0).value + let fields := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr - return (⟨constructor.isUnsafe, lvls.size, cidx, params, fields, typ⟩ : + return (⟨constructor.isUnsafe, lvls.value, cidx, params, fields, typ⟩ : Ixon.Constructor)) hlvls hafterCidx have hall := Reads.bind (next := fun isUnsafe : Bool => do - let lvls := (← Ixon.getTag0).size - let cidx := (← Ixon.getTag0).size - let params := (← Ixon.getTag0).size - let fields := (← Ixon.getTag0).size + let lvls := (← Ixon.getTagN 0).value + let cidx := (← Ixon.getTagN 0).value + let params := (← Ixon.getTagN 0).value + let fields := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr return (⟨isUnsafe, lvls, cidx, params, fields, typ⟩ : Ixon.Constructor)) @@ -169,7 +169,7 @@ theorem putInductive_writes (inductiveInfo : Ixon.Inductive) def getInductiveConstructors (isUnsafe : Bool) (lvls params indices : UInt64) (typ : Ixon.Expr) : Ixon.GetM Ixon.Inductive := do - let count := (← Ixon.getTag0).size.toNat + let count := (← Ixon.getTagN 0).value.toNat Ixon.checkCount count.toUInt64 6 let mut constructors : Array Ixon.Constructor := #[] for _ in [0:count] do @@ -177,9 +177,9 @@ def getInductiveConstructors (isUnsafe : Bool) (lvls params indices : UInt64) return ⟨isUnsafe, lvls, params, indices, typ, constructors⟩ def getInductiveAfterFlags (isUnsafe : Bool) : Ixon.GetM Ixon.Inductive := do - let lvls := (← Ixon.getTag0).size - let params := (← Ixon.getTag0).size - let indices := (← Ixon.getTag0).size + let lvls := (← Ixon.getTagN 0).value + let params := (← Ixon.getTagN 0).value + let indices := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr getInductiveConstructors isUnsafe lvls params indices typ @@ -222,10 +222,10 @@ theorem getInductiveConstructors_reads (inductiveInfo : Ixon.Inductive) constructorBytes_size_ge) simpa [getMany, hdecode] using hafterConstructors have hall := Reads.bind - (next := fun count : Ixon.Tag0 => do - Ixon.checkCount count.size.toNat.toUInt64 6 + (next := fun count : Ixon.TagN => do + Ixon.checkCount count.value.toNat.toUInt64 6 let mut constructors : Array Ixon.Constructor := #[] - for _ in [0:count.size.toNat] do + for _ in [0:count.value.toNat] do constructors := constructors.push (← Ixon.getConstructor) return ({ inductiveInfo with ctors := constructors } : Ixon.Inductive)) htag htail @@ -252,24 +252,24 @@ theorem getInductiveAfterFlags_reads (inductiveInfo : Ixon.Inductive) inductiveInfo.params inductiveInfo.indices typ) htyp hconstructors have hafterIndices := Reads.bind - (next := fun indices : Ixon.Tag0 => do + (next := fun indices : Ixon.TagN => do let typ ← Ixon.getExpr getInductiveConstructors inductiveInfo.isUnsafe inductiveInfo.lvls - inductiveInfo.params indices.size typ) + inductiveInfo.params indices.value typ) hindices hafterTyp have hafterParams := Reads.bind - (next := fun params : Ixon.Tag0 => do - let indices := (← Ixon.getTag0).size + (next := fun params : Ixon.TagN => do + let indices := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr getInductiveConstructors inductiveInfo.isUnsafe inductiveInfo.lvls - params.size indices typ) + params.value indices typ) hparams hafterIndices have hall := Reads.bind - (next := fun lvls : Ixon.Tag0 => do - let params := (← Ixon.getTag0).size - let indices := (← Ixon.getTag0).size + (next := fun lvls : Ixon.TagN => do + let params := (← Ixon.getTagN 0).value + let indices := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr - getInductiveConstructors inductiveInfo.isUnsafe lvls.size params indices + getInductiveConstructors inductiveInfo.isUnsafe lvls.value params indices typ) hlvls hafterParams simpa [getInductiveAfterFlags, ByteArray.append_assoc] using hall diff --git a/Ix/Compile/Verify/NonrecursiveConstantCodec.lean b/Ix/Compile/Verify/NonrecursiveConstantCodec.lean index 8864fb66e..53b97fa7e 100644 --- a/Ix/Compile/Verify/NonrecursiveConstantCodec.lean +++ b/Ix/Compile/Verify/NonrecursiveConstantCodec.lean @@ -79,7 +79,7 @@ theorem getQuotient_reads (quotient : Ixon.Quotient) rcases quotient with ⟨kind, lvls, typ⟩ have hpayload (decodedKind : QuotKind) : Reads (do - let decodedLvls := (← Ixon.getTag0).size + let decodedLvls := (← Ixon.getTagN 0).value let decodedTyp ← Ixon.getExpr return (⟨decodedKind, decodedLvls, decodedTyp⟩ : Ixon.Quotient)) (tag0Bytes lvls ++ @@ -102,9 +102,9 @@ theorem getQuotient_reads (quotient : Ixon.Quotient) ⟨decodedKind, lvls, typ⟩ := by simpa using hafterTyp exact Reads.bind - (next := fun decodedLvls : Ixon.Tag0 => do + (next := fun decodedLvls : Ixon.TagN => do let decodedTyp ← Ixon.getExpr - return (⟨decodedKind, decodedLvls.size, decodedTyp⟩ : Ixon.Quotient)) + return (⟨decodedKind, decodedLvls.value, decodedTyp⟩ : Ixon.Quotient)) hlvls hafterTyp' let next := fun encoded : UInt8 => do let decodedKind : QuotKind ← match encoded with @@ -113,7 +113,7 @@ theorem getQuotient_reads (quotient : Ixon.Quotient) | 2 => pure .lift | 3 => pure .ind | _ => throw s!"invalid QuotKind tag {encoded}" - let lvls := (← Ixon.getTag0).size + let lvls := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr return (⟨decodedKind, lvls, typ⟩ : Ixon.Quotient) have hget : Ixon.getQuotient = (Ixon.getU8 >>= next) := by @@ -173,9 +173,9 @@ theorem getInductiveProj_reads (projection : Ixon.InductiveProj) Ixon.GetM Ixon.InductiveProj)) hblockRead hreturn have hall := Reads.bind - (next := fun idx : Ixon.Tag0 => do + (next := fun idx : Ixon.TagN => do let block ← (Ixon.Serialize.get : Ixon.GetM Address) - return (⟨idx.size, block⟩ : Ixon.InductiveProj)) + return (⟨idx.value, block⟩ : Ixon.InductiveProj)) hidx hafterBlock simpa [Ixon.getInductiveProj, inductiveProjBytes] using hall @@ -202,16 +202,16 @@ theorem getConstructorProj_reads (projection : Ixon.ConstructorProj) Ixon.GetM Ixon.ConstructorProj)) hblockRead hreturn have hafterCidx := Reads.bind - (next := fun cidx : Ixon.Tag0 => do + (next := fun cidx : Ixon.TagN => do let block ← (Ixon.Serialize.get : Ixon.GetM Address) - return ({ projection with cidx := cidx.size, block } : + return ({ projection with cidx := cidx.value, block } : Ixon.ConstructorProj)) hcidx hafterBlock have hall := Reads.bind - (next := fun idx : Ixon.Tag0 => do - let cidx := (← Ixon.getTag0).size + (next := fun idx : Ixon.TagN => do + let cidx := (← Ixon.getTagN 0).value let block ← (Ixon.Serialize.get : Ixon.GetM Address) - return (⟨idx.size, cidx, block⟩ : Ixon.ConstructorProj)) + return (⟨idx.value, cidx, block⟩ : Ixon.ConstructorProj)) hidx hafterCidx simpa [Ixon.getConstructorProj, constructorProjBytes, ByteArray.append_assoc] using hall @@ -235,9 +235,9 @@ theorem getRecursorProj_reads (projection : Ixon.RecursorProj) Ixon.GetM Ixon.RecursorProj)) hblockRead hreturn have hall := Reads.bind - (next := fun idx : Ixon.Tag0 => do + (next := fun idx : Ixon.TagN => do let block ← (Ixon.Serialize.get : Ixon.GetM Address) - return (⟨idx.size, block⟩ : Ixon.RecursorProj)) + return (⟨idx.value, block⟩ : Ixon.RecursorProj)) hidx hafterBlock simpa [Ixon.getRecursorProj, recursorProjBytes] using hall @@ -260,9 +260,9 @@ theorem getDefinitionProj_reads (projection : Ixon.DefinitionProj) Ixon.GetM Ixon.DefinitionProj)) hblockRead hreturn have hall := Reads.bind - (next := fun idx : Ixon.Tag0 => do + (next := fun idx : Ixon.TagN => do let block ← (Ixon.Serialize.get : Ixon.GetM Address) - return (⟨idx.size, block⟩ : Ixon.DefinitionProj)) + return (⟨idx.value, block⟩ : Ixon.DefinitionProj)) hidx hafterBlock simpa [Ixon.getDefinitionProj, definitionProjBytes] using hall diff --git a/Ix/Compile/Verify/RecursorConstantCodec.lean b/Ix/Compile/Verify/RecursorConstantCodec.lean index fb251920c..763e2db2e 100644 --- a/Ix/Compile/Verify/RecursorConstantCodec.lean +++ b/Ix/Compile/Verify/RecursorConstantCodec.lean @@ -62,9 +62,9 @@ theorem getRecursorRule_reads (rule : Ixon.RecursorRule) Ixon.GetM Ixon.RecursorRule)) hrhs hreturn have hall := Reads.bind - (next := fun fields : Ixon.Tag0 => do + (next := fun fields : Ixon.TagN => do let rhs ← Ixon.getExpr - return (⟨fields.size, rhs⟩ : Ixon.RecursorRule)) + return (⟨fields.value, rhs⟩ : Ixon.RecursorRule)) hfields hafterRhs simpa [Ixon.getRecursorRule, recursorRuleBytes] using hall @@ -126,7 +126,7 @@ theorem putRecursor_writes (recursor : Ixon.Recursor) def getRecursorRules (k isUnsafe : Bool) (lvls params indices motives minors : UInt64) (typ : Ixon.Expr) : Ixon.GetM Ixon.Recursor := do - let count := (← Ixon.getTag0).size.toNat + let count := (← Ixon.getTagN 0).value.toNat Ixon.checkCount count.toUInt64 2 let mut rules : Array Ixon.RecursorRule := #[] for _ in [0:count] do @@ -134,11 +134,11 @@ def getRecursorRules (k isUnsafe : Bool) (lvls params indices motives minors : U return ⟨k, isUnsafe, lvls, params, indices, motives, minors, typ, rules⟩ def getRecursorAfterFlags (k isUnsafe : Bool) : Ixon.GetM Ixon.Recursor := do - let lvls := (← Ixon.getTag0).size - let params := (← Ixon.getTag0).size - let indices := (← Ixon.getTag0).size - let motives := (← Ixon.getTag0).size - let minors := (← Ixon.getTag0).size + let lvls := (← Ixon.getTagN 0).value + let params := (← Ixon.getTagN 0).value + let indices := (← Ixon.getTagN 0).value + let motives := (← Ixon.getTagN 0).value + let minors := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr getRecursorRules k isUnsafe lvls params indices motives minors typ @@ -184,10 +184,10 @@ theorem getRecursorRules_reads (recursor : Ixon.Recursor) recursorRuleBytes_size_ge) simpa [getMany, hdecode] using hafterRules have hall := Reads.bind - (next := fun count : Ixon.Tag0 => do - Ixon.checkCount count.size.toNat.toUInt64 2 + (next := fun count : Ixon.TagN => do + Ixon.checkCount count.value.toNat.toUInt64 2 let mut rules : Array Ixon.RecursorRule := #[] - for _ in [0:count.size.toNat] do + for _ in [0:count.value.toNat] do rules := rules.push (← Ixon.getRecursorRule) return ({ recursor with rules } : Ixon.Recursor)) htag htail @@ -217,43 +217,43 @@ theorem getRecursorAfterFlags_reads (recursor : Ixon.Recursor) recursor.params recursor.indices recursor.motives recursor.minors typ) htyp hrules have hafterMinors := Reads.bind - (next := fun minors : Ixon.Tag0 => do + (next := fun minors : Ixon.TagN => do let typ ← Ixon.getExpr getRecursorRules recursor.k recursor.isUnsafe recursor.lvls - recursor.params recursor.indices recursor.motives minors.size typ) + recursor.params recursor.indices recursor.motives minors.value typ) hminors hafterTyp have hafterMotives := Reads.bind - (next := fun motives : Ixon.Tag0 => do - let minors := (← Ixon.getTag0).size + (next := fun motives : Ixon.TagN => do + let minors := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr getRecursorRules recursor.k recursor.isUnsafe recursor.lvls - recursor.params recursor.indices motives.size minors typ) + recursor.params recursor.indices motives.value minors typ) hmotives hafterMinors have hafterIndices := Reads.bind - (next := fun indices : Ixon.Tag0 => do - let motives := (← Ixon.getTag0).size - let minors := (← Ixon.getTag0).size + (next := fun indices : Ixon.TagN => do + let motives := (← Ixon.getTagN 0).value + let minors := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr getRecursorRules recursor.k recursor.isUnsafe recursor.lvls - recursor.params indices.size motives minors typ) + recursor.params indices.value motives minors typ) hindices hafterMotives have hafterParams := Reads.bind - (next := fun params : Ixon.Tag0 => do - let indices := (← Ixon.getTag0).size - let motives := (← Ixon.getTag0).size - let minors := (← Ixon.getTag0).size + (next := fun params : Ixon.TagN => do + let indices := (← Ixon.getTagN 0).value + let motives := (← Ixon.getTagN 0).value + let minors := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr getRecursorRules recursor.k recursor.isUnsafe recursor.lvls - params.size indices motives minors typ) + params.value indices motives minors typ) hparams hafterIndices have hall := Reads.bind - (next := fun lvls : Ixon.Tag0 => do - let params := (← Ixon.getTag0).size - let indices := (← Ixon.getTag0).size - let motives := (← Ixon.getTag0).size - let minors := (← Ixon.getTag0).size + (next := fun lvls : Ixon.TagN => do + let params := (← Ixon.getTagN 0).value + let indices := (← Ixon.getTagN 0).value + let motives := (← Ixon.getTagN 0).value + let minors := (← Ixon.getTagN 0).value let typ ← Ixon.getExpr - getRecursorRules recursor.k recursor.isUnsafe lvls.size params indices + getRecursorRules recursor.k recursor.isUnsafe lvls.value params indices motives minors typ) hlvls hafterParams simpa [getRecursorAfterFlags, ByteArray.append_assoc] using hall diff --git a/Ix/Compile/Verify/Sharing.lean b/Ix/Compile/Verify/Sharing.lean deleted file mode 100644 index f41e3ca6e..000000000 --- a/Ix/Compile/Verify/Sharing.lean +++ /dev/null @@ -1,459 +0,0 @@ -import Ix.Compile.Verify.Catalog -import Ix.Sharing - -/-! -# Proof-visible production sharing rewrite - -The production rewrite replaces selected subterms by `share` leaves and -otherwise reconstructs the expression recursively. This module proves that -the rewrite cannot lengthen any encoded spine and therefore preserves the -expression codec's public wire domain. --/ - -namespace Ix.Compile.Verify - -local instance : LawfulBEq ByteArray where - eq_of_beq {left right} h := by - cases left - cases right - exact congrArg ByteArray.mk (eq_of_beq h) - rfl {bytes} := beq_self_eq_true bytes.data - -local instance : LawfulBEq Address where - eq_of_beq {left right} h := by - cases left - cases right - exact congrArg Address.mk (eq_of_beq h) - rfl {addr} := by - cases addr - exact beq_self_eq_true (α := ByteArray) _ - -local instance : LawfulHashable Address where - hash_eq left right h := by rw [eq_of_beq h] - -/-- Every representative stored by sharing analysis is in the expression -codec's public wire domain. -/ -def SharingInfoMapWireWF - (infoMap : Std.HashMap Address Ix.Sharing.SubtermInfo) : Prop := - ∀ ⦃hash info⦄, infoMap.get? hash = some info → info.expr.wireWF - -theorem SharingInfoMapWireWF.insert - {infoMap : Std.HashMap Address Ix.Sharing.SubtermInfo} - (hmap : SharingInfoMapWireWF infoMap) {hash info} - (hinfo : info.expr.wireWF) : - SharingInfoMapWireWF (infoMap.insert hash info) := by - intro queried found hfound - change (infoMap.insert hash info)[queried]? = some found at hfound - rw [Std.HashMap.getElem?_insert] at hfound - split at hfound - next => - have : found = info := (Option.some.inj hfound).symm - subst found - exact hinfo - next => exact hmap hfound - -/-- The wire-safety invariant carried by the sharing analyzer. -/ -def AnalyzeStateWireWF (state : Ix.Sharing.AnalyzeState) : Prop := - SharingInfoMapWireWF state.infoMap - -theorem recordAnalyzedNode_wireWF (expr : Ixon.Expr) - (childHashes : Array Address) (state : Ix.Sharing.AnalyzeState) - (hstate : AnalyzeStateWireWF state) (hexpr : expr.wireWF) : - AnalyzeStateWireWF - ((Ix.Sharing.recordAnalyzedNode expr childHashes).run state).2 := by - simp [Ix.Sharing.recordAnalyzedNode, StateT.run_bind, StateT.run_get, - StateT.run_set] - split - · exact hstate - · exact hstate.insert hexpr - -/-- Recursive Merkle analysis preserves wire-safe representatives. -/ -theorem hashAndAnalyze_wireWF (expr : Ixon.Expr) - (state : Ix.Sharing.AnalyzeState) (hstate : AnalyzeStateWireWF state) - (hexpr : expr.wireWF) : - AnalyzeStateWireWF ((Ix.Sharing.hashAndAnalyze expr).run state).2 := by - induction expr generalizing state with - | sort idx | var idx | ref idx refs | recur idx refs | str idx | nat idx | share idx => - simp [Ix.Sharing.hashAndAnalyze, StateT.run_bind, StateT.run_get] - split - · exact hstate - · exact recordAnalyzedNode_wireWF _ _ state hstate hexpr - | prj typeRefIdx fieldIdx value ih => - unfold Ix.Sharing.hashAndAnalyze - simp - split - · exact hstate - · simp [StateT.run_bind] - apply recordAnalyzedNode_wireWF - · exact ih _ hstate (by simpa [Ixon.Expr.wireWF] using hexpr) - · exact hexpr - | app fn arg ihfn iharg => - unfold Ix.Sharing.hashAndAnalyze - simp - split - · exact hstate - · simp [StateT.run_bind] - apply recordAnalyzedNode_wireWF - · apply iharg - · apply ihfn - · exact hstate - · exact hexpr.1 - · exact hexpr.2.1 - · exact hexpr - | lam uses ty body ihty ihbody => - unfold Ix.Sharing.hashAndAnalyze - simp - split - · exact hstate - · simp [StateT.run_bind] - apply recordAnalyzedNode_wireWF - · apply ihbody - · apply ihty - · exact hstate - · exact hexpr.1 - · exact hexpr.2.1 - · exact hexpr - | all uses owned ty body ihty ihbody => - unfold Ix.Sharing.hashAndAnalyze - simp - split - · exact hstate - · simp [StateT.run_bind] - apply recordAnalyzedNode_wireWF - · apply ihbody - · apply ihty - · exact hstate - · exact hexpr.1 - · exact hexpr.2.1 - · exact hexpr - | letE nonDep ty value body ihty ihvalue ihbody => - unfold Ix.Sharing.hashAndAnalyze - simp - split - · exact hstate - · simp [StateT.run_bind] - apply recordAnalyzedNode_wireWF - · apply ihbody - · apply ihvalue - · apply ihty - · exact hstate - · exact hexpr.1 - · exact hexpr.2.1 - · exact hexpr.2.2 - · exact hexpr - -/-- Every member of an expression array is in the expression codec's public -wire domain. -/ -def ExprArrayWireWF (exprs : Array Ixon.Expr) : Prop := - ∀ expr ∈ exprs, expr.wireWF - -/-- A safe array lookup remains safe when it falls back to a separately safe -expression. -/ -theorem ExprArrayWireWF.getElem?_getD {exprs : Array Ixon.Expr} - (hexprs : ExprArrayWireWF exprs) (idx : Nat) {fallback : Ixon.Expr} - (hfallback : fallback.wireWF) : - (exprs[idx]?.getD fallback).wireWF := by - by_cases hidx : idx < exprs.size - · rw [Array.getElem?_eq_getElem hidx, Option.getD_some] - exact hexprs _ (Array.getElem_mem hidx) - · rw [Array.getElem?_eq_none (Nat.le_of_not_gt hidx), Option.getD_none] - exact hfallback - -theorem SharingInfoMapWireWF.empty : - SharingInfoMapWireWF - ({} : Std.HashMap Address Ix.Sharing.SubtermInfo) := by - intro hash info hget - simp at hget - -theorem analyzeExprs_wireWF (exprs : Array Ixon.Expr) - (state : Ix.Sharing.AnalyzeState) (hstate : AnalyzeStateWireWF state) - (hexprs : ExprArrayWireWF exprs) : - AnalyzeStateWireWF (Ix.Sharing.analyzeExprs exprs state) := by - unfold Ix.Sharing.analyzeExprs - apply Array.foldl_induction - (motive := fun _ state => AnalyzeStateWireWF state) - · exact hstate - · intro i state hstate - apply hashAndAnalyze_wireWF - · exact hstate - · exact hexprs _ (Array.getElem_mem i.isLt) - -theorem addUsage_wireWF - (infoMap : Std.HashMap Address Ix.Sharing.SubtermInfo) - (hash : Address) (count : Nat) (hmap : SharingInfoMapWireWF infoMap) : - SharingInfoMapWireWF (Ix.Sharing.addUsage infoMap hash count) := by - unfold Ix.Sharing.addUsage - split - next info hget => - apply hmap.insert - exact hmap (info := info) hget - next => exact hmap - -theorem countRootUsages_wireWF (exprs : Array Ixon.Expr) - (ptrToHash : Std.HashMap USize Address) - (infoMap : Std.HashMap Address Ix.Sharing.SubtermInfo) - (hmap : SharingInfoMapWireWF infoMap) : - SharingInfoMapWireWF - (Ix.Sharing.countRootUsages exprs ptrToHash infoMap) := by - unfold Ix.Sharing.countRootUsages - apply Array.foldl_induction - (motive := fun _ infoMap => SharingInfoMapWireWF infoMap) - · exact hmap - · intro i infoMap hmap - split - · exact addUsage_wireWF _ _ _ hmap - · exact hmap - -theorem propagateUsage_wireWF - (infoMap : Std.HashMap Address Ix.Sharing.SubtermInfo) - (hash : Address) (hmap : SharingInfoMapWireWF infoMap) : - SharingInfoMapWireWF (Ix.Sharing.propagateUsage infoMap hash) := by - unfold Ix.Sharing.propagateUsage - split - next info hget => - apply Array.foldl_induction - (motive := fun _ infoMap => SharingInfoMapWireWF infoMap) - · exact hmap - · intro i infoMap hmap - exact addUsage_wireWF _ _ _ hmap - next => exact hmap - -theorem propagateUsageCounts_wireWF (topoOrder : Array Address) - (infoMap : Std.HashMap Address Ix.Sharing.SubtermInfo) - (hmap : SharingInfoMapWireWF infoMap) : - SharingInfoMapWireWF - (Ix.Sharing.propagateUsageCounts topoOrder infoMap) := by - unfold Ix.Sharing.propagateUsageCounts - apply Array.foldl_induction - (motive := fun _ infoMap => SharingInfoMapWireWF infoMap) - · exact hmap - · intro i infoMap hmap - exact propagateUsage_wireWF _ _ hmap - -/-- Both usage-counting phases preserve the representatives established by -the recursive analyzer. -/ -theorem analyzeBlock_wireWF (exprs : Array Ixon.Expr) - (hexprs : ExprArrayWireWF exprs) : - SharingInfoMapWireWF (Ix.Sharing.analyzeBlock exprs).infoMap := by - unfold Ix.Sharing.analyzeBlock - apply propagateUsageCounts_wireWF - apply countRootUsages_wireWF - apply analyzeExprs_wireWF - · exact SharingInfoMapWireWF.empty - · exact hexprs - -/-- Replacing selected subterms by sharing leaves cannot increase an -application, lambda, or forall spine exposed at the root. -/ -theorem rewriteWithSharing_spineCounts_le - (expr : Ixon.Expr) (hashToIdx : Std.HashMap Address Nat) - (ptrToHash : Std.HashMap USize Address) : - (Ix.Sharing.rewriteWithSharing expr hashToIdx ptrToHash).appCount ≤ - expr.appCount ∧ - (Ix.Sharing.rewriteWithSharing expr hashToIdx ptrToHash).lamCount ≤ - expr.lamCount ∧ - (Ix.Sharing.rewriteWithSharing expr hashToIdx ptrToHash).allCount ≤ - expr.allCount := by - induction expr <;> - rw [Ix.Sharing.rewriteWithSharing] <;> - split <;> - simp_all [Ixon.Expr.appCount, Ixon.Expr.lamCount, Ixon.Expr.allCount] - -/-- Production sharing rewriting preserves every structural count condition -required by the expression serializer. -/ -theorem rewriteWithSharing_wireWF - (expr : Ixon.Expr) (hashToIdx : Std.HashMap Address Nat) - (ptrToHash : Std.HashMap USize Address) (h : expr.wireWF) : - (Ix.Sharing.rewriteWithSharing expr hashToIdx ptrToHash).wireWF := by - induction expr with - | sort | var | str | nat | share => - rw [Ix.Sharing.rewriteWithSharing] - split <;> simp [Ixon.Expr.wireWF] - | ref refIdx indices | recur refIdx indices => - rw [Ix.Sharing.rewriteWithSharing] - split <;> simp_all [Ixon.Expr.wireWF] - | prj typeRefIdx fieldIdx value ih => - rw [Ix.Sharing.rewriteWithSharing] - split - · simp [Ixon.Expr.wireWF] - · simpa [Ixon.Expr.wireWF] using ih h - | app fn arg ihfn iharg => - rw [Ix.Sharing.rewriteWithSharing] - split - · simp [Ixon.Expr.wireWF] - · rcases h with ⟨hfn, harg, hcount⟩ - refine ⟨ihfn hfn, iharg harg, ?_⟩ - have hle := (rewriteWithSharing_spineCounts_le - fn hashToIdx ptrToHash).1 - omega - | lam uses ty body ihty ihbody => - rw [Ix.Sharing.rewriteWithSharing] - split - · simp [Ixon.Expr.wireWF] - · rcases h with ⟨hty, hbody, hcount⟩ - refine ⟨ihty hty, ihbody hbody, ?_⟩ - have hle := (rewriteWithSharing_spineCounts_le - body hashToIdx ptrToHash).2.1 - omega - | all uses owned ty body ihty ihbody => - rw [Ix.Sharing.rewriteWithSharing] - split - · simp [Ixon.Expr.wireWF] - · rcases h with ⟨hty, hbody, hcount⟩ - refine ⟨ihty hty, ihbody hbody, ?_⟩ - have hle := (rewriteWithSharing_spineCounts_le - body hashToIdx ptrToHash).2.2 - omega - | letE nonDep ty value body ihty ihvalue ihbody => - rw [Ix.Sharing.rewriteWithSharing] - split - · simp [Ixon.Expr.wireWF] - · rcases h with ⟨hty, hvalue, hbody⟩ - exact ⟨ihty hty, ihvalue hvalue, ihbody hbody⟩ - -/-- Every sharing entry accumulated so far is wire-safe. -/ -def SharingBuildStateWireWF (state : Ix.Sharing.SharingBuildState) : Prop := - ExprArrayWireWF state.sharingVec - -theorem SharingBuildStateWireWF.empty : - SharingBuildStateWireWF ({} : Ix.Sharing.SharingBuildState) := by - intro expr hmem - simp at hmem - -theorem addSharingEntry_wireWF - (infoMap : Std.HashMap Address Ix.Sharing.SubtermInfo) - (ptrToHash : Std.HashMap USize Address) - (state : Ix.Sharing.SharingBuildState) (hash : Address) - (hmap : SharingInfoMapWireWF infoMap) - (hstate : SharingBuildStateWireWF state) : - SharingBuildStateWireWF - (Ix.Sharing.addSharingEntry infoMap ptrToHash state hash) := by - unfold Ix.Sharing.addSharingEntry - split - next info hget => - intro expr hmem - rw [Array.mem_push] at hmem - rcases hmem with hmem | rfl - · exact hstate _ hmem - · apply rewriteWithSharing_wireWF - exact hmap hget - next => exact hstate - -theorem buildSharingEntries_wireWF (hashes : Array Address) - (infoMap : Std.HashMap Address Ix.Sharing.SubtermInfo) - (ptrToHash : Std.HashMap USize Address) - (hmap : SharingInfoMapWireWF infoMap) : - SharingBuildStateWireWF - (Ix.Sharing.buildSharingEntries hashes infoMap ptrToHash) := by - unfold Ix.Sharing.buildSharingEntries - apply Array.foldl_induction - (motive := fun _ state => SharingBuildStateWireWF state) - · exact SharingBuildStateWireWF.empty - · intro i state hstate - exact addSharingEntry_wireWF _ _ _ _ hmap hstate - -theorem rewriteExprs_wireWF (exprs : Array Ixon.Expr) - (hashToIdx : Std.HashMap Address Nat) - (ptrToHash : Std.HashMap USize Address) - (hexprs : ExprArrayWireWF exprs) : - ExprArrayWireWF - (Ix.Sharing.rewriteExprs exprs hashToIdx ptrToHash) := by - intro rewritten hmem - unfold Ix.Sharing.rewriteExprs at hmem - obtain ⟨expr, hexprMem, rfl⟩ := Array.mem_map.mp hmem - apply rewriteWithSharing_wireWF - exact hexprs _ hexprMem - -/-- Nonempty sharing construction preserves the wire domain for both block -roots and every emitted sharing-table entry. -/ -theorem buildSharingVec_wireWF (exprs : Array Ixon.Expr) - (sharedHashes : Array Address) - (infoMap : Std.HashMap Address Ix.Sharing.SubtermInfo) - (ptrToHash : Std.HashMap USize Address) - (hexprs : ExprArrayWireWF exprs) - (hmap : SharingInfoMapWireWF infoMap) : - ExprArrayWireWF - (Ix.Sharing.buildSharingVec - exprs sharedHashes infoMap ptrToHash).1 ∧ - ExprArrayWireWF - (Ix.Sharing.buildSharingVec - exprs sharedHashes infoMap ptrToHash).2 := by - unfold Ix.Sharing.buildSharingVec - dsimp only - constructor - · apply rewriteExprs_wireWF - exact hexprs - · exact buildSharingEntries_wireWF _ _ _ hmap - -theorem ExprArrayWireWF.empty : ExprArrayWireWF #[] := by - intro expr hmem - simp at hmem - -theorem finishSharing_wireWF (exprs : Array Ixon.Expr) - (result : Ix.Sharing.AnalyzeResult) (sharedHashes : Array Address) - (hexprs : ExprArrayWireWF exprs) - (hmap : SharingInfoMapWireWF result.infoMap) : - ExprArrayWireWF - (Ix.Sharing.finishSharing exprs result sharedHashes).1 ∧ - ExprArrayWireWF - (Ix.Sharing.finishSharing exprs result sharedHashes).2 := by - unfold Ix.Sharing.finishSharing - split - · exact ⟨hexprs, ExprArrayWireWF.empty⟩ - · dsimp only - split - · exact buildSharingVec_wireWF _ _ _ _ hexprs hmap - · exact ⟨hexprs, ExprArrayWireWF.empty⟩ - -/-- The production overflow fallback makes the sharing-table count lossless -for the constant codec, independently of the logical `Array` model. -/ -theorem finishSharing_capacity (exprs : Array Ixon.Expr) - (result : Ix.Sharing.AnalyzeResult) (sharedHashes : Array Address) : - (Ix.Sharing.finishSharing exprs result sharedHashes).2.size < - UInt64.size := by - unfold Ix.Sharing.finishSharing - split - · change 0 < UInt64.size - exact UInt64.toNat_lt 0 - · dsimp only - split - · assumption - · change 0 < UInt64.size - exact UInt64.toNat_lt 0 - -/-- The default, non-debug production entry point reduces to the -proof-visible sharing core. -/ -theorem applySharing_eq_core (exprs : Array Ixon.Expr) : - Ix.Sharing.applySharing exprs = Ix.Sharing.applySharingCore exprs := by - rw [Ix.Sharing.applySharing] - simp - -theorem applySharingCore_wireWF (exprs : Array Ixon.Expr) - (hexprs : ExprArrayWireWF exprs) : - ExprArrayWireWF (Ix.Sharing.applySharingCore exprs).1 ∧ - ExprArrayWireWF (Ix.Sharing.applySharingCore exprs).2 := by - unfold Ix.Sharing.applySharingCore - exact finishSharing_wireWF _ _ _ hexprs - (analyzeBlock_wireWF _ hexprs) - -theorem applySharingCore_capacity (exprs : Array Ixon.Expr) : - (Ix.Sharing.applySharingCore exprs).2.size < UInt64.size := by - unfold Ix.Sharing.applySharingCore - exact finishSharing_capacity _ _ _ - -/-- Production sharing preserves the expression wire domain for rewritten -roots and for the complete sharing vector, including the nonempty branch. -/ -theorem applySharing_wireWF (exprs : Array Ixon.Expr) - (hexprs : ExprArrayWireWF exprs) : - ExprArrayWireWF (Ix.Sharing.applySharing exprs).1 ∧ - ExprArrayWireWF (Ix.Sharing.applySharing exprs).2 := by - rw [applySharing_eq_core] - exact applySharingCore_wireWF _ hexprs - -/-- The sharing vector returned by the default production entry point always -has a losslessly serializable `UInt64` count. -/ -theorem applySharing_capacity (exprs : Array Ixon.Expr) : - (Ix.Sharing.applySharing exprs).2.size < UInt64.size := by - rw [applySharing_eq_core] - exact applySharingCore_capacity _ - -end Ix.Compile.Verify diff --git a/Ix/Compile/Verify/SharingExact.lean b/Ix/Compile/Verify/SharingExact.lean new file mode 100644 index 000000000..71d02cc86 --- /dev/null +++ b/Ix/Compile/Verify/SharingExact.lean @@ -0,0 +1,1226 @@ +import Ix.Compile.Verify.ExprSpineCodec +import Ix.Compile.Verify.TagN +import Ix.Compile.Verify.Catalog +import Ix.Compile.Verify.MutualConstantCodec +import Ix.Sharing.Exact + +/-! +# Exact minimum sharing: foundational facts + +Proofs about the executable exact-sharing core (`Ix.Sharing.Exact`): + +* the integer widths `tag0Size`, `tag4Size`, `shareWidth` are the sizes of + the production TagN encodings (`f = 0`, `f = 4`; `Ix.Compile.Verify.Codec`); + `tagNWidth` is the length of the `f = 4` TagN encoding and is monotone with + the stated rung ends; +* `exprSize` is the length of the production expression encoding for every + expression in the codec's wire domain (telescope rule included), and the + complete-Constant length decomposes as `fixedConstantBytes` plus the + variable parts; +* the §3.2 key comparisons are lawful total orders, and sorting distinct + keys does not depend on the input order. +-/ + +namespace Ix.Compile.Verify.SharingExact + +open Ix.Sharing.Exact +open Ix.Compile.Verify.Codec +open Ix.Compile.Verify.Codec.Ixon.Expr + +/-! ## TagN (`f = 0`, `f = 4`) lengths -/ + +theorem trimmedBytes_size (x : UInt64) (len : Nat) : (trimmedBytes x len).size = len := + Codec.trimmedBytes_size x len + +/-- `tag4Size` is the length of the production TagN (`f = 4`) bytes. -/ +theorem tag4Bytes_size (flag : UInt8) (size : UInt64) : + (Codec.tag4Bytes flag size).size = tag4Size size.toNat := + Codec.tagNBytes_size 4 flag size + +/-- `tag0Size` is the length of the production TagN (`f = 0`) bytes. -/ +theorem tag0Bytes_size (size : UInt64) : + (tag0Bytes size).size = tag0Size size.toNat := + Codec.tagNBytes_size 0 0 size + +/-- `tag4Size` is the size of what `putTagN 4` writes. -/ +theorem putTag4_size (flag : UInt8) (size : UInt64) : + (Ixon.runPut (Ixon.putTagN 4 flag size)).size = tag4Size size.toNat := + Codec.runPut_putTagN_size 4 flag size + +/-- `tag0Size` is the size of what `putTagN 0` writes. -/ +theorem putTag0_size (size : UInt64) : + (Ixon.runPut (Ixon.putTagN 0 0 size)).size = tag0Size size.toNat := + Codec.runPut_putTagN_size 0 0 size + +/-- The Share width is the size of the serialized `Share`. -/ +theorem shareWidth_eq_putTag4 (idx : UInt64) : + shareWidth idx.toNat = + (Ixon.runPut (Ixon.putTagN 4 Ixon.Expr.FLAG_SHARE idx)).size := + (putTag4_size Ixon.Expr.FLAG_SHARE idx).symm + +/-! ## TagN widths -/ + +theorem tagNRung1End_eq : tagNRung1End = 8 := TagN.tagNEnd1_eq_4 +theorem tagNRung2End_eq : tagNRung2End = 1032 := TagN.tagNEnd2_eq_4 +theorem tagNRung3End_eq : tagNRung3End = 66568 := TagN.tagNEnd3_eq_4 +/-- `66568 + 2^24`. -/ +theorem tagNRung4End_eq : tagNRung4End = 16843784 := TagN.tagNEnd4_eq_4 +/-- `66568 + 2^24 + 2^32`. -/ +theorem tagNRung5End_eq : tagNRung5End = 4311811080 := TagN.tagNEnd5_eq_4 +/-- `66568 + 2^24 + 2^32 + 2^64`. -/ +theorem tagNRung6End_eq : tagNRung6End = 18446744078021362696 := by + unfold tagNRung6End Ixon.tagNEnd6; rw [TagN.tagNEnd5_eq_4] + +/-- `tagNWidth` with the rung ends evaluated. -/ +theorem tagNWidth_eq (i : Nat) : + tagNWidth i = + if i < 8 then 1 else if i < 1032 then 2 else if i < 66568 then 3 + else if i < 16843784 then 4 else if i < 4311811080 then 5 else 9 := by + unfold tagNWidth Ixon.tagNByteWidth + rw [TagN.tagNEnd1_eq_4, TagN.tagNEnd2_eq_4, TagN.tagNEnd3_eq_4, TagN.tagNEnd4_eq_4, + TagN.tagNEnd5_eq_4] + +theorem tagNWidth_pos (i : Nat) : 1 ≤ tagNWidth i := by + rw [tagNWidth_eq] + repeat' split + all_goals omega + +/-- TagN widths never decrease with the index. -/ +theorem tagNWidth_mono {i j : Nat} (h : i ≤ j) : tagNWidth i ≤ tagNWidth j := by + rw [tagNWidth_eq, tagNWidth_eq] + repeat' split + all_goals omega + +theorem tagNWidth_rung1 {i : Nat} (h : i < tagNRung1End) : tagNWidth i = 1 := by + rw [tagNRung1End_eq] at h + rw [tagNWidth_eq, if_pos h] + +theorem tagNWidth_rung2 {i : Nat} (h1 : tagNRung1End ≤ i) (h2 : i < tagNRung2End) : + tagNWidth i = 2 := by + rw [tagNRung1End_eq] at h1 + rw [tagNRung2End_eq] at h2 + rw [tagNWidth_eq, if_neg (by omega), if_pos h2] + +theorem tagNWidth_rung3 {i : Nat} (h1 : tagNRung2End ≤ i) (h2 : i < tagNRung3End) : + tagNWidth i = 3 := by + rw [tagNRung2End_eq] at h1 + rw [tagNRung3End_eq] at h2 + rw [tagNWidth_eq, if_neg (by omega), if_neg (by omega), if_pos h2] + +theorem tagNWidth_rung4 {i : Nat} (h1 : tagNRung3End ≤ i) (h2 : i < tagNRung4End) : + tagNWidth i = 4 := by + rw [tagNRung3End_eq] at h1 + rw [tagNRung4End_eq] at h2 + rw [tagNWidth_eq, if_neg (by omega), if_neg (by omega), if_neg (by omega), if_pos h2] + +theorem tagNWidth_rung5 {i : Nat} (h1 : tagNRung4End ≤ i) (h2 : i < tagNRung5End) : + tagNWidth i = 5 := by + rw [tagNRung4End_eq] at h1 + rw [tagNRung5End_eq] at h2 + rw [tagNWidth_eq, if_neg (by omega), if_neg (by omega), if_neg (by omega), + if_neg (by omega), if_pos h2] + +theorem tagNWidth_rung6 {i : Nat} (h1 : tagNRung5End ≤ i) : tagNWidth i = 9 := by + rw [tagNRung5End_eq] at h1 + rw [tagNWidth_eq, if_neg (by omega), if_neg (by omega), if_neg (by omega), + if_neg (by omega), if_neg (by omega)] + +/-- The Share width is the `f = 4` instance of the TagN width function. -/ +theorem tagNWidth_eq_byteWidth : tagNWidth = Ixon.tagNByteWidth 4 := rfl + +/-- `tagNWidth` is the length of the `f = 4` TagN encoding of the index +(the Share code, flag `0xB`), which the decoder reads back exactly. -/ +theorem tagNWidth_eq_encoded (i : UInt64) : + tagNWidth i.toNat = (Ixon.runPut (Ixon.putTagN 4 0xB i)).size ∧ + Ixon.runGetExact (Ixon.getTagN 4) (Ixon.runPut (Ixon.putTagN 4 0xB i)) = + .ok ⟨0xB, i⟩ := + ⟨(Codec.runPut_putTagN_size 4 0xB i).symm, + Codec.runGetExact_getTagN_putTagN 4 (by decide) 0xB (by decide) i⟩ + +/-! ## Expression length -/ + +/-- Length of the production encoding of an expression. -/ +def S (e : Ixon.Expr) : Nat := (spineWireEncode e).size + +theorem exprListBytes_size (enc : Ixon.Expr → ByteArray) (xs : List Ixon.Expr) : + (exprListBytes enc xs).size = (xs.map fun e => (enc e).size).sum := by + induction xs with + | nil => rfl + | cons x xs ih => simp [exprListBytes, ih] + +theorem lamBinderListBytes_size (enc : Ixon.Expr → ByteArray) + (bs : List (Ixon.BinderContract × Ixon.Expr)) : + (lamBinderListBytes enc bs).size = (bs.map fun b => 1 + (enc b.2).size).sum := by + induction bs with + | nil => rfl + | cons b bs ih => + obtain ⟨u, ty⟩ := b + simp [lamBinderListBytes, ih] + all_goals omega + +theorem allBinderListBytes_size (enc : Ixon.Expr → ByteArray) + (bs : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr)) : + (allBinderListBytes enc bs).size = (bs.map fun b => 1 + (enc b.2.2).size).sum := by + induction bs with + | nil => rfl + | cons b bs ih => + obtain ⟨u, o, ty⟩ := b + simp [allBinderListBytes, ih] + all_goals omega + +theorem tag0ListBytes_size (xs : List UInt64) : + (tag0ListBytes xs).size = (xs.map fun u => tag0Size u.toNat).sum := by + induction xs with + | nil => rfl + | cons x xs ih => simp [tag0ListBytes, ih, tag0Bytes_size] + +theorem univIdxsSize_eq (us : Array UInt64) : + univIdxsSize us = (us.toList.map fun u => tag0Size u.toNat).sum := by + unfold univIdxsSize + rw [← Array.foldl_toList] + generalize us.toList = xs + suffices h : ∀ acc, xs.foldl (fun acc u => acc + tag0Size u.toNat) acc = + acc + (xs.map fun u => tag0Size u.toNat).sum by simpa using h 0 + induction xs with + | nil => simp + | cons x xs ih => intro acc; simp [ih]; omega + +/-- What `sizeInfo` computes for an expression: its full length and the +three telescope continuations. -/ +def Spec (i : SizeInfo) (e : Ixon.Expr) : Prop := + i.full = S e ∧ + i.appCont = (e.collectAppArgs.1.length, + S e.collectAppArgs.2 + (e.collectAppArgs.1.map S).sum) ∧ + i.lamCont = (e.collectLamBinders.1.length, + (e.collectLamBinders.1.map fun b => 1 + S b.2).sum + S e.collectLamBinders.2) ∧ + i.allCont = (e.collectAllBinders.1.length, + (e.collectAllBinders.1.map fun b => 1 + S b.2.2).sum + S e.collectAllBinders.2) + +/-- A node that continues no telescope satisfies the spec once its length +is right. -/ +theorem spec_plain (e : Ixon.Expr) (n : Nat) (hn : n = S e) + (ha : e.collectAppArgs = ([], e)) (hl : e.collectLamBinders = ([], e)) + (hal : e.collectAllBinders = ([], e)) : Spec (.plain n) e := by + simp [Spec, SizeInfo.plain, ha, hl, hal, hn] + +theorem toNat_toUInt64_of_lt {n : Nat} (h : n < UInt64.size) : n.toUInt64.toNat = n := by + simp [Nat.toUInt64, Nat.mod_eq_of_lt h] + +theorem exprListBytes_size_S (xs : List Ixon.Expr) : + (exprListBytes spineWireEncode xs).size = (xs.map S).sum := + exprListBytes_size spineWireEncode xs + +theorem lamBinderListBytes_size_S (bs : List (Ixon.BinderContract × Ixon.Expr)) : + (lamBinderListBytes spineWireEncode bs).size = (bs.map fun b => 1 + S b.2).sum := + lamBinderListBytes_size spineWireEncode bs + +theorem allBinderListBytes_size_S + (bs : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr)) : + (allBinderListBytes spineWireEncode bs).size = (bs.map fun b => 1 + S b.2.2).sum := + allBinderListBytes_size spineWireEncode bs + +theorem S_def (e : Ixon.Expr) : S e = (spineWireEncode e).size := rfl + +theorem map_S_eq (l : List Ixon.Expr) : + l.map S = l.map fun e => (spineWireEncode e).size := rfl + +theorem sum_map_const_one {α : Type} (l : List α) : (l.map fun _ => 1).sum = l.length := by + induction l with + | nil => rfl + | cons x xs ih => simp [ih]; omega + +/-- The size facts of a telescope node keep their full length in the +continuations of the other families. -/ +theorem sizeInfoWith_app_lamCont (sc : Nat → Nat) (f a : Ixon.Expr) : + (sizeInfoWith sc (.app f a)).lamCont = (0, (sizeInfoWith sc (.app f a)).full) := rfl +theorem sizeInfoWith_app_allCont (sc : Nat → Nat) (f a : Ixon.Expr) : + (sizeInfoWith sc (.app f a)).allCont = (0, (sizeInfoWith sc (.app f a)).full) := rfl +theorem sizeInfoWith_lam_appCont (sc : Nat → Nat) (c : Ixon.BinderContract) (t b : Ixon.Expr) : + (sizeInfoWith sc (.lam c t b)).appCont = (0, (sizeInfoWith sc (.lam c t b)).full) := rfl +theorem sizeInfoWith_lam_allCont (sc : Nat → Nat) (c : Ixon.BinderContract) (t b : Ixon.Expr) : + (sizeInfoWith sc (.lam c t b)).allCont = (0, (sizeInfoWith sc (.lam c t b)).full) := rfl +theorem sizeInfoWith_all_appCont (sc : Nat → Nat) (c : Ixon.BinderContract) + (r : Ixon.ValueContract) (t b : Ixon.Expr) : + (sizeInfoWith sc (.all c r t b)).appCont = (0, (sizeInfoWith sc (.all c r t b)).full) := rfl +theorem sizeInfoWith_all_lamCont (sc : Nat → Nat) (c : Ixon.BinderContract) + (r : Ixon.ValueContract) (t b : Ixon.Expr) : + (sizeInfoWith sc (.all c r t b)).lamCont = (0, (sizeInfoWith sc (.all c r t b)).full) := rfl + +theorem sizeInfoWith_app_full (sc : Nat → Nat) (f a : Ixon.Expr) : + (sizeInfoWith sc (.app f a)).full = + tag4Size ((sizeInfoWith sc f).appCont.1 + 1) + + ((sizeInfoWith sc f).appCont.2 + (sizeInfoWith sc a).full) := rfl +theorem sizeInfoWith_app_appCont (sc : Nat → Nat) (f a : Ixon.Expr) : + (sizeInfoWith sc (.app f a)).appCont = + ((sizeInfoWith sc f).appCont.1 + 1, + (sizeInfoWith sc f).appCont.2 + (sizeInfoWith sc a).full) := rfl +theorem sizeInfoWith_lam_full (sc : Nat → Nat) (c : Ixon.BinderContract) (t b : Ixon.Expr) : + (sizeInfoWith sc (.lam c t b)).full = + tag4Size ((sizeInfoWith sc b).lamCont.1 + 1) + + (1 + (sizeInfoWith sc t).full + (sizeInfoWith sc b).lamCont.2) := rfl +theorem sizeInfoWith_lam_lamCont (sc : Nat → Nat) (c : Ixon.BinderContract) (t b : Ixon.Expr) : + (sizeInfoWith sc (.lam c t b)).lamCont = + ((sizeInfoWith sc b).lamCont.1 + 1, + 1 + (sizeInfoWith sc t).full + (sizeInfoWith sc b).lamCont.2) := rfl +theorem sizeInfoWith_all_full (sc : Nat → Nat) (c : Ixon.BinderContract) + (r : Ixon.ValueContract) (t b : Ixon.Expr) : + (sizeInfoWith sc (.all c r t b)).full = + tag4Size ((sizeInfoWith sc b).allCont.1 + 1) + + (1 + (sizeInfoWith sc t).full + (sizeInfoWith sc b).allCont.2) := rfl +theorem sizeInfoWith_all_allCont (sc : Nat → Nat) (c : Ixon.BinderContract) + (r : Ixon.ValueContract) (t b : Ixon.Expr) : + (sizeInfoWith sc (.all c r t b)).allCont = + ((sizeInfoWith sc b).allCont.1 + 1, + 1 + (sizeInfoWith sc t).full + (sizeInfoWith sc b).allCont.2) := rfl + +theorem sizeInfo_spec (e : Ixon.Expr) (h : e.wireWF) : Spec (sizeInfoWith tag4Size e) e := by + induction e with + | sort i => + exact spec_plain _ _ (by simp [S, spineWireEncode, tag4Bytes_size]) rfl rfl rfl + | var i => + exact spec_plain _ _ (by simp [S, spineWireEncode, tag4Bytes_size]) rfl rfl rfl + | str i => + exact spec_plain _ _ (by simp [S, spineWireEncode, tag4Bytes_size]) rfl rfl rfl + | nat i => + exact spec_plain _ _ (by simp [S, spineWireEncode, tag4Bytes_size]) rfl rfl rfl + | share i => + exact spec_plain _ _ (by simp [S, spineWireEncode, tag4Bytes_size]) rfl rfl rfl + | ref r us => + have hus : us.size < UInt64.size := h + exact spec_plain _ _ (by + simp [S, spineWireEncode, tag4Bytes_size, tag0Bytes_size, tag0ListBytes_size, + univIdxsSize_eq, toNat_toUInt64_of_lt hus] + all_goals omega) rfl rfl rfl + | recur r us => + have hus : us.size < UInt64.size := h + exact spec_plain _ _ (by + simp [S, spineWireEncode, tag4Bytes_size, tag0Bytes_size, tag0ListBytes_size, + univIdxsSize_eq, toNat_toUInt64_of_lt hus] + all_goals omega) rfl rfl rfl + | prj t f v ih => + have hv : (sizeInfoWith tag4Size v).full = (spineWireEncode v).size := (ih h).1 + exact spec_plain _ _ (by + simp only [hv, S, spineWireEncode, ByteArray.size_append, + tag4Bytes_size, tag0Bytes_size]) rfl rfl rfl + | letE c ty v body iht ihv ihb => + have h1 : (sizeInfoWith tag4Size ty).full = (spineWireEncode ty).size := (iht h.1).1 + have h2 : (sizeInfoWith tag4Size v).full = (spineWireEncode v).size := (ihv h.2.1).1 + have h3 : (sizeInfoWith tag4Size body).full = (spineWireEncode body).size := (ihb h.2.2).1 + exact spec_plain _ _ (by + simp only [h1, h2, h3, S, spineWireEncode, ByteArray.size_append, + tag4Bytes_size, List.size_toByteArray, List.length_singleton] + omega) rfl rfl rfl + | app f a ihf iha => + obtain ⟨hf, ha, hcount⟩ := h + obtain ⟨_, hfApp, _, _⟩ := ihf hf + have haFull : (sizeInfoWith tag4Size a).full = S a := (iha ha).1 + have hlenLt : f.collectAppArgs.1.length + 1 < UInt64.size := by + rw [collectAppArgs_length]; exact hcount + have hS : S (.app f a) = tag4Size (f.collectAppArgs.1.length + 1) + + (S f.collectAppArgs.2 + ((f.collectAppArgs.1.map S).sum + S a)) := by + rw [S_def, spineWireEncode_app] + simp only [← S_def, ByteArray.size_append, tag4Bytes_size, exprListBytes_size_S, Ixon.Expr.collectAppArgs, List.length_append, + List.length_singleton, toNat_toUInt64_of_lt hlenLt, List.map_append, + List.sum_append, List.map_cons, List.map_nil, List.sum_cons, List.sum_nil] + omega + have hfull : (sizeInfoWith tag4Size (.app f a)).full = S (.app f a) := by + rw [sizeInfoWith_app_full] + simp only [hfApp, haFull, hS] + omega + refine ⟨hfull, ?_, ?_, ?_⟩ + · rw [sizeInfoWith_app_appCont, hfApp, haFull] + simp only [Ixon.Expr.collectAppArgs, List.length_append, List.length_singleton, + List.map_append, List.sum_append, List.map_cons, List.map_nil, List.sum_cons, + List.sum_nil, Prod.mk.injEq] + constructor <;> first | trivial | omega + · rw [sizeInfoWith_app_lamCont, hfull] + simp [Ixon.Expr.collectLamBinders] + · rw [sizeInfoWith_app_allCont, hfull] + simp [Ixon.Expr.collectAllBinders] + | lam c ty body iht ihb => + obtain ⟨ht, hb, hcount⟩ := h + have htFull : (sizeInfoWith tag4Size ty).full = S ty := (iht ht).1 + obtain ⟨_, _, hbLam, _⟩ := ihb hb + have hlenLt : body.collectLamBinders.1.length + 1 < UInt64.size := by + rw [collectLamBinders_length]; exact hcount + have hS : S (.lam c ty body) = tag4Size (body.collectLamBinders.1.length + 1) + + (1 + S ty + ((body.collectLamBinders.1.map fun b => 1 + S b.2).sum + + S body.collectLamBinders.2)) := by + rw [S_def, spineWireEncode_lam] + simp only [← S_def, ByteArray.size_append, tag4Bytes_size, lamBinderListBytes_size_S, Ixon.Expr.collectLamBinders, List.length_cons, + toNat_toUInt64_of_lt hlenLt, List.map_cons, List.sum_cons] + omega + have hfull : (sizeInfoWith tag4Size (.lam c ty body)).full = S (.lam c ty body) := by + rw [sizeInfoWith_lam_full, hbLam, htFull, hS] + refine ⟨hfull, ?_, ?_, ?_⟩ + · rw [sizeInfoWith_lam_appCont, hfull] + simp [Ixon.Expr.collectAppArgs] + · rw [sizeInfoWith_lam_lamCont, hbLam, htFull] + simp only [Ixon.Expr.collectLamBinders, List.length_cons, List.map_cons, + List.sum_cons, Prod.mk.injEq] + constructor <;> first | trivial | omega + · rw [sizeInfoWith_lam_allCont, hfull] + simp [Ixon.Expr.collectAllBinders] + | all c r ty body iht ihb => + obtain ⟨ht, hb, hcount⟩ := h + have htFull : (sizeInfoWith tag4Size ty).full = S ty := (iht ht).1 + obtain ⟨_, _, _, hbAll⟩ := ihb hb + have hlenLt : body.collectAllBinders.1.length + 1 < UInt64.size := by + rw [collectAllBinders_length]; exact hcount + have hS : S (.all c r ty body) = tag4Size (body.collectAllBinders.1.length + 1) + + (1 + S ty + ((body.collectAllBinders.1.map fun b => 1 + S b.2.2).sum + + S body.collectAllBinders.2)) := by + rw [S_def, spineWireEncode_all] + simp only [← S_def, ByteArray.size_append, tag4Bytes_size, allBinderListBytes_size_S, Ixon.Expr.collectAllBinders, List.length_cons, + toNat_toUInt64_of_lt hlenLt, List.map_cons, List.sum_cons] + omega + have hfull : (sizeInfoWith tag4Size (.all c r ty body)).full = S (.all c r ty body) := by + rw [sizeInfoWith_all_full, hbAll, htFull, hS] + refine ⟨hfull, ?_, ?_, ?_⟩ + · rw [sizeInfoWith_all_appCont, hfull] + simp [Ixon.Expr.collectAppArgs] + · rw [sizeInfoWith_all_lamCont, hfull] + simp [Ixon.Expr.collectLamBinders] + · rw [sizeInfoWith_all_allCont, hbAll, htFull] + simp only [Ixon.Expr.collectAllBinders, List.length_cons, List.map_cons, + List.sum_cons, Prod.mk.injEq] + constructor <;> first | trivial | omega + +/-- `exprSize` is the length of the production expression encoding, for +every expression in the codec's wire domain. -/ +theorem exprSize_eq_spineWireEncode (e : Ixon.Expr) (h : e.wireWF) : + exprSize e = (spineWireEncode e).size := + (sizeInfo_spec e h).1 + +/-- `exprSize` is the length of what `putExpr` writes. -/ +theorem exprSize_eq_serExpr (e : Ixon.Expr) (h : e.wireWF) : + exprSize e = (Ixon.runPut (Ixon.putExpr e)).size := by + rw [exprSize_eq_spineWireEncode e h, ← serExpr_eq_spineWireEncode e h] + rfl + +/-! ## Complete-Constant length -/ + +section ConstantLength + +open Ix.Compile.Verify.Codec.Ixon.Constant +open Ix.Compile.Verify.Codec.Ixon.ConstantTables +open Ix.Compile.Verify.Codec.Ixon.NonrecursiveConstant +open Ix.Compile.Verify.Codec.Ixon.RecursorConstant +open Ix.Compile.Verify.Codec.Ixon.MutualConstant + +theorem listBytes_size {α : Type} (enc : α → ByteArray) (xs : List α) : + (listBytes enc xs).size = (xs.map fun x => (enc x).size).sum := by + induction xs with + | nil => rfl + | cons x xs ih => simp [listBytes, ih] + +theorem sum_map_add {α : Type} (xs : List α) (f g : α → Nat) : + (xs.map fun x => f x + g x).sum = (xs.map f).sum + (xs.map g).sum := by + induction xs with + | nil => rfl + | cons x xs ih => simp [ih]; omega + +/-- Root-free bytes of a recursor rule, constructor, recursor, inductive. -/ +def ruleFixed (rl : Ixon.RecursorRule) : Nat := tag0Size rl.fields.toNat + +def ctorFixed (c : Ixon.Constructor) : Nat := + 1 + tag0Size c.lvls.toNat + tag0Size c.cidx.toNat + tag0Size c.params.toNat + + tag0Size c.fields.toNat + +def recFixed (r : Ixon.Recursor) : Nat := + 1 + tag0Size r.lvls.toNat + tag0Size r.params.toNat + tag0Size r.indices.toNat + + tag0Size r.motives.toNat + tag0Size r.minors.toNat + + tag0Size r.rules.size.toUInt64.toNat + (r.rules.toList.map ruleFixed).sum + +def indFixed (i : Ixon.Inductive) : Nat := + 1 + tag0Size i.lvls.toNat + tag0Size i.params.toNat + tag0Size i.indices.toNat + + tag0Size i.ctors.size.toUInt64.toNat + (i.ctors.toList.map ctorFixed).sum + +def memberFixed : Ixon.MutConst → Nat + | .defn d => 1 + (1 + tag0Size d.lvls.toNat) + | .indc i => 1 + indFixed i + | .recr r => 1 + recFixed r + +/-- Bytes of a `ConstantInfo` encoding that are not expression roots. -/ +def infoFixed : Ixon.ConstantInfo → Nat + | .defn d => tag4Size 0 + (1 + tag0Size d.lvls.toNat) + | .recr r => tag4Size 1 + recFixed r + | .axio a => tag4Size 2 + (1 + tag0Size a.lvls.toNat) + | .quot q => tag4Size 3 + (1 + tag0Size q.lvls.toNat) + | .muts ms => tag4Size ms.size.toUInt64.toNat + (ms.toList.map memberFixed).sum + | info => (constantInfoBytes info).size + +theorem rules_bytes (f : Ixon.Expr → Ixon.Expr) (rules : Array Ixon.RecursorRule) : + (listBytes recursorRuleBytes (rules.map fun rl => { rl with rhs := f rl.rhs }).toList).size = + (rules.toList.map ruleFixed).sum + ((rules.toList.map (·.rhs)).map fun r => S (f r)).sum := by + rw [listBytes_size, Array.toList_map, List.map_map, List.map_map] + simp only [Function.comp_def, recursorRuleBytes, ByteArray.size_append, tag0Bytes_size] + rw [sum_map_add] + rfl + +theorem ctors_bytes (f : Ixon.Expr → Ixon.Expr) (ctors : Array Ixon.Constructor) : + (listBytes constructorBytes (ctors.map fun c => { c with typ := f c.typ }).toList).size = + (ctors.toList.map ctorFixed).sum + ((ctors.toList.map (·.typ)).map fun r => S (f r)).sum := by + rw [listBytes_size, Array.toList_map, List.map_map, List.map_map] + simp only [Function.comp_def, constructorBytes, ByteArray.size_append, tag0Bytes_size, + List.size_toByteArray, List.length_singleton] + rw [← sum_map_add] + congr 1 + +theorem recursorBytes_map (f : Ixon.Expr → Ixon.Expr) (r : Ixon.Recursor) : + (recursorBytes + { r with + typ := f r.typ, + rules := r.rules.map fun rl => { rl with rhs := f rl.rhs } }).size = + recFixed r + (((r.typ :: r.rules.toList.map (·.rhs))).map fun e => S (f e)).sum := by + simp only [recursorBytes, ByteArray.size_append, tag0Bytes_size, List.size_toByteArray, + List.length_singleton, Array.size_map, rules_bytes, recFixed, List.map_cons, List.sum_cons] + simp only [S] + omega + +theorem inductiveBytes_map (f : Ixon.Expr → Ixon.Expr) (i : Ixon.Inductive) : + (inductiveBytes + { i with + typ := f i.typ, + ctors := i.ctors.map fun c => { c with typ := f c.typ } }).size = + indFixed i + (((i.typ :: i.ctors.toList.map (·.typ))).map fun e => S (f e)).sum := by + simp only [inductiveBytes, ByteArray.size_append, tag0Bytes_size, List.size_toByteArray, + List.length_singleton, Array.size_map, ctors_bytes, indFixed, List.map_cons, List.sum_cons] + simp only [S] + omega + +theorem memberBytes_map (f : Ixon.Expr → Ixon.Expr) (m : Ixon.MutConst) : + (mutConstBytes (mapMutConstRoots f m)).size = + memberFixed m + ((mutConstRoots m).map fun e => S (f e)).sum := by + cases m with + | defn d => + simp only [mapMutConstRoots, mutConstBytes, definitionBytes, ByteArray.size_append, + List.size_toByteArray, List.length_singleton, tag0Bytes_size, memberFixed, mutConstRoots, + List.map_cons, List.map_nil, List.sum_cons, List.sum_nil] + simp only [S] + omega + | indc i => + simp only [mapMutConstRoots, mutConstBytes, ByteArray.size_append, List.size_toByteArray, + List.length_singleton, inductiveBytes_map, memberFixed, mutConstRoots] + simp only [List.map_cons, List.map_map, Function.comp_def] + omega + | recr r => + simp only [mapMutConstRoots, mutConstBytes, ByteArray.size_append, List.size_toByteArray, + List.length_singleton, recursorBytes_map, memberFixed, mutConstRoots] + simp only [List.map_cons, List.map_map, Function.comp_def] + omega + +theorem members_bytes (f : Ixon.Expr → Ixon.Expr) (ms : List Ixon.MutConst) : + (listBytes mutConstBytes (ms.map (mapMutConstRoots f))).size = + (ms.map memberFixed).sum + ((ms.flatMap mutConstRoots).map fun e => S (f e)).sum := by + induction ms with + | nil => rfl + | cons m ms ih => + simp only [List.map_cons, listBytes, ByteArray.size_append, memberBytes_map, ih, + List.flatMap_cons, List.map_append, List.sum_append, List.sum_cons] + omega + +/-- The info bytes are the root-free bytes plus the roots' encodings, for any +map applied to the roots. -/ +theorem infoBytes_mapRoots (f : Ixon.Expr → Ixon.Expr) (info : Ixon.ConstantInfo) : + (constantInfoBytes (mapRoots f info)).size = + infoFixed info + ((constantInfoRoots info).toList.map fun e => S (f e)).sum := by + cases info with + | defn d => + simp only [mapRoots, constantInfoBytes, standaloneInfoBytes, nonrecursiveInfoBytes, + definitionBytes, Ixon.ConstantInfo.CONST_DEFN, UInt64.reduceToNat, ByteArray.size_append, tag4Bytes_size, List.size_toByteArray, + List.length_singleton, tag0Bytes_size, infoFixed, constantInfoRoots, mutConstRoots, + List.toList_toArray, List.map_cons, List.map_nil, List.sum_cons, List.sum_nil] + simp only [S] + omega + | recr r => + simp only [mapRoots, constantInfoBytes, standaloneInfoBytes, ByteArray.size_append, + Ixon.ConstantInfo.CONST_RECR, UInt64.reduceToNat, tag4Bytes_size, recursorBytes_map, infoFixed, constantInfoRoots, mutConstRoots, + List.toList_toArray] + omega + | axio a => + simp only [mapRoots, constantInfoBytes, standaloneInfoBytes, nonrecursiveInfoBytes, + axiomBytes, Ixon.ConstantInfo.CONST_AXIO, UInt64.reduceToNat, ByteArray.size_append, tag4Bytes_size, List.size_toByteArray, + List.length_singleton, tag0Bytes_size, infoFixed, constantInfoRoots, + List.toList_toArray, List.map_cons, List.map_nil, List.sum_cons, List.sum_nil] + simp only [S] + omega + | quot q => + simp only [mapRoots, constantInfoBytes, standaloneInfoBytes, nonrecursiveInfoBytes, + quotientBytes, Ixon.ConstantInfo.CONST_QUOT, UInt64.reduceToNat, ByteArray.size_append, tag4Bytes_size, List.size_toByteArray, + List.length_singleton, tag0Bytes_size, infoFixed, constantInfoRoots, + List.toList_toArray, List.map_cons, List.map_nil, List.sum_cons, List.sum_nil] + simp only [S] + omega + | cPrj p => simp [mapRoots, infoFixed, constantInfoRoots] + | rPrj p => simp [mapRoots, infoFixed, constantInfoRoots] + | iPrj p => simp [mapRoots, infoFixed, constantInfoRoots] + | dPrj p => simp [mapRoots, infoFixed, constantInfoRoots] + | muts ms => + simp only [mapRoots, constantInfoBytes, ByteArray.size_append, tag4Bytes_size, + Array.size_map, Array.toList_map, members_bytes, infoFixed, constantInfoRoots, + List.toList_toArray] + omega + +theorem mapMutConstRoots_id (m : Ixon.MutConst) : mapMutConstRoots (fun e => e) m = m := by + cases m <;> simp [mapMutConstRoots] + +theorem mapRoots_id (info : Ixon.ConstantInfo) : mapRoots (fun e => e) info = info := by + have hm : (mapMutConstRoots fun e => e) = id := funext mapMutConstRoots_id + cases info <;> simp [mapRoots, hm] + +/-- The info bytes are the root-free bytes plus the roots' encodings. -/ +theorem infoBytes_size (info : Ixon.ConstantInfo) : + (constantInfoBytes info).size = infoFixed info + ((constantInfoRoots info).toList.map S).sum := by + have h := infoBytes_mapRoots (fun e => e) info + rw [mapRoots_id] at h + exact h + +theorem mutConstRoots_wireWF (m : Ixon.MutConst) (h : m.wireWF) : + ∀ e ∈ mutConstRoots m, e.wireWF := by + cases m with + | defn d => + obtain ⟨ht, hv⟩ := h + intro e he + simp only [mutConstRoots, List.mem_cons, List.not_mem_nil, or_false] at he + rcases he with rfl | rfl <;> assumption + | indc i => + obtain ⟨ht, _, hc⟩ := h + intro e he + simp only [mutConstRoots, List.mem_cons, List.mem_map] at he + rcases he with rfl | ⟨c, hcm, rfl⟩ + · exact ht + · exact hc c (Array.mem_toList_iff.mp hcm) + | recr r => + obtain ⟨ht, _, hr⟩ := h + intro e he + simp only [mutConstRoots, List.mem_cons, List.mem_map] at he + rcases he with rfl | ⟨rl, hrl, rfl⟩ + · exact ht + · exact hr rl (Array.mem_toList_iff.mp hrl) + +/-- Every root of a wire-well-formed `ConstantInfo` is wire-well-formed. -/ +theorem constantInfoRoots_wireWF (info : Ixon.ConstantInfo) (h : info.wireWF) : + ∀ e ∈ (constantInfoRoots info).toList, e.wireWF := by + cases info with + | defn d => exact mutConstRoots_wireWF (.defn d) h + | recr r => exact mutConstRoots_wireWF (.recr r) h + | axio a => + intro e he + simp only [constantInfoRoots, List.toList_toArray, List.mem_cons, List.not_mem_nil, + or_false] at he + subst he; exact h + | quot q => + intro e he + simp only [constantInfoRoots, List.toList_toArray, List.mem_cons, List.not_mem_nil, + or_false] at he + subst he; exact h + | cPrj p | rPrj p | iPrj p | dPrj p => intro e he; simp [constantInfoRoots] at he + | muts ms => + obtain ⟨_, hms⟩ := h + intro e he + simp only [constantInfoRoots, List.toList_toArray, List.mem_flatMap] at he + obtain ⟨m, hm, he⟩ := he + exact mutConstRoots_wireWF m (hms m (Array.mem_toList_iff.mp hm)) e he + +theorem mapMutConstRoots_wireWF (f : Ixon.Expr → Ixon.Expr) (hf : ∀ e, (f e).wireWF) + (m : Ixon.MutConst) (h : m.wireWF) : (mapMutConstRoots f m).wireWF := by + cases m with + | defn d => exact ⟨hf _, hf _⟩ + | indc i => + obtain ⟨_, hsize, _⟩ := h + refine ⟨hf _, by simpa using hsize, ?_⟩ + intro c hc + obtain ⟨c0, _, rfl⟩ := Array.mem_map.mp hc + exact hf _ + | recr r => + obtain ⟨_, hsize, _⟩ := h + refine ⟨hf _, by simpa using hsize, ?_⟩ + intro rl hrl + obtain ⟨rl0, _, rfl⟩ := Array.mem_map.mp hrl + exact hf _ + +theorem mapRoots_wireWF (f : Ixon.Expr → Ixon.Expr) (hf : ∀ e, (f e).wireWF) + (info : Ixon.ConstantInfo) (h : info.wireWF) : (mapRoots f info).wireWF := by + cases info with + | defn d => exact mapMutConstRoots_wireWF f hf (.defn d) h + | recr r => exact mapMutConstRoots_wireWF f hf (.recr r) h + | axio a => exact hf _ + | quot q => exact hf _ + | cPrj p | rPrj p | iPrj p | dPrj p => exact h + | muts ms => + obtain ⟨hsize, hms⟩ := h + refine ⟨by simpa using hsize, ?_⟩ + intro m hm + obtain ⟨m0, hm0, rfl⟩ := Array.mem_map.mp hm + exact mapMutConstRoots_wireWF f hf m0 (hms m0 hm0) + +theorem exprsSize_eq (es : Array Ixon.Expr) (h : ∀ e ∈ es, e.wireWF) : + exprsSize es = (es.toList.map S).sum := by + unfold exprsSize + rw [← Array.foldl_toList] + have h' : ∀ e ∈ es.toList, e.wireWF := fun e he => h e (Array.mem_toList_iff.mp he) + generalize es.toList = xs at h' + suffices hs : ∀ acc, xs.foldl (fun acc e => acc + exprSize e) acc = acc + (xs.map S).sum by + simpa using hs 0 + induction xs with + | nil => simp + | cons x xs ih => + intro acc + simp only [List.foldl_cons, List.map_cons, List.sum_cons] + rw [ih (fun e he => h' e (List.mem_cons_of_mem x he)), + exprSize_eq_spineWireEncode x (h' x (List.mem_cons_self))] + simp only [S] + omega + +/-- `putConstant` writes `constantBytes` for every wire-well-formed Constant. -/ +theorem serConstant_eq_constantBytes (c : Ixon.Constant) (h : c.wireWF) : + Ixon.serConstant c = Ix.Compile.Verify.Codec.Ixon.MutualConstant.constantBytes c := by + have hw := putConstant_writes c ((constantWireWF_iff_catalog c).mpr h) ByteArray.empty + simp only [Ixon.serConstant, Ixon.runPut, hw, ByteArray.empty_append] + +theorem constantBytes_size (c : Ixon.Constant) : + (Ix.Compile.Verify.Codec.Ixon.MutualConstant.constantBytes c).size = + (constantInfoBytes c.info).size + tag0Size c.sharing.size.toUInt64.toNat + + (c.sharing.toList.map S).sum + + ((tag0Bytes c.refs.size.toUInt64).size + (listBytes Address.hash c.refs.toList).size + + (tag0Bytes c.univs.size.toUInt64).size + + (listBytes Ix.Compile.Verify.Codec.Ixon.Univ.wireEncode c.univs.toList).size) := by + simp only [Ix.Compile.Verify.Codec.Ixon.MutualConstant.constantBytes, ByteArray.size_append, + tag0Bytes_size, listBytes_size] + rw [map_S_eq] + omega + +theorem S_var_zero : S (.var 0) = 1 := by + simp [S, spineWireEncode, tag4Bytes_size, tag4Size, Ixon.tagNByteWidth, TagN.tagNEnd1_eq_4] + +/-- The complete-Constant length decomposes into the root-free bytes +(`fixedConstantBytes`), the roots, the table count and the table bodies. -/ +theorem serConstant_size_decomposition (c : Ixon.Constant) (h : c.wireWF) : + (Ixon.serConstant c).size = + fixedConstantBytes c + exprsSize (constantInfoRoots c.info) + tag0Size c.sharing.size + + exprsSize c.sharing := by + obtain ⟨hinfo, hsharingSize, hsharing, hrefsSize, hrefs, hunivsSize, hunivs⟩ := h + let c' : Ixon.Constant := + { c with info := mapRoots (fun _ => Ixon.Expr.var 0) c.info, sharing := #[] } + have h' : c'.wireWF := by + refine ⟨mapRoots_wireWF (fun _ => Ixon.Expr.var 0) + (fun _ => by unfold Ixon.Expr.wireWF; trivial) _ hinfo, + by simp [c'], ?_, hrefsSize, hrefs, + hunivsSize, hunivs⟩ + intro e he + simp [c'] at he + have hc := serConstant_eq_constantBytes c + ⟨hinfo, hsharingSize, hsharing, hrefsSize, hrefs, hunivsSize, hunivs⟩ + have hc' := serConstant_eq_constantBytes c' h' + have hfixed : fixedConstantBytes c = (Ixon.serConstant c').size - + (constantInfoRoots c.info).size - tag0Size 0 := rfl + have hroots := exprsSize_eq (constantInfoRoots c.info) + (fun e he => constantInfoRoots_wireWF c.info hinfo e (Array.mem_toList_iff.mpr he)) + have hshare := exprsSize_eq c.sharing hsharing + have hmap := infoBytes_mapRoots (fun _ => Ixon.Expr.var 0) c.info + have hbase := infoBytes_size c.info + have hlen : ((constantInfoRoots c.info).toList.map fun _ => S (.var 0)).sum = + (constantInfoRoots c.info).size := by + rw [show (fun (_ : Ixon.Expr) => S (.var 0)) = fun _ => 1 from funext fun _ => S_var_zero, + sum_map_const_one, Array.length_toList] + rw [hlen] at hmap + rw [hfixed, hroots, hshare, hc, hc', constantBytes_size, constantBytes_size] + have hz : (Nat.toUInt64 0).toNat = 0 := rfl + simp only [c', toNat_toUInt64_of_lt hsharingSize, List.map_nil, List.sum_nil, + Array.size_empty, hmap, hbase, hz] + omega + + +end ConstantLength + + +/-! ## Key orders (§3.2, §3.3) -/ + +section Orders + +instance lexCompare_trans : Std.TransCmp lexCompare := + inferInstanceAs (Std.TransCmp (List.compareLex (compare : Nat → Nat → Ordering))) + +instance lexCompare_lawfulEq : Std.LawfulEqCmp lexCompare := + inferInstanceAs (Std.LawfulEqCmp (List.compareLex (compare : Nat → Nat → Ordering))) + +/-- `lexCompare` is `eq` exactly on equal vectors. -/ +theorem lexCompare_eq_iff (a b : List Nat) : lexCompare a b = .eq ↔ a = b := + ⟨Std.LawfulEqCmp.eq_of_compare, fun h => h ▸ Std.ReflCmp.compare_self⟩ + +/-- Swapping the arguments of `lexCompare` swaps the outcome. -/ +theorem lexCompare_swap (a b : List Nat) : lexCompare a b = (lexCompare b a).swap := + Std.OrientedCmp.eq_swap + +/-- `lexCompare` is transitive. -/ +theorem lexCompare_lt_trans {a b c : List Nat} (h₁ : lexCompare a b = .lt) + (h₂ : lexCompare b c = .lt) : lexCompare a c = .lt := + Std.TransCmp.lt_trans h₁ h₂ + +/-- Comparing by a projection under a transitive comparison is transitive. -/ +theorem transCmp_on {α β : Type} (cmp : β → β → Ordering) [Std.TransCmp cmp] (f : α → β) : + Std.TransCmp (fun a b => cmp (f a) (f b)) where + eq_swap := Std.OrientedCmp.eq_swap (cmp := cmp) + isLE_trans h₁ h₂ := Std.TransCmp.isLE_trans (cmp := cmp) h₁ h₂ + +instance compareBytes_trans : Std.TransCmp compareBytes := + transCmp_on (List.compareLex (compare : UInt8 → UInt8 → Ordering)) (fun b : ByteArray => b.data.toList) + +instance compareBytes_lawfulEq : Std.LawfulEqCmp compareBytes where + compare_self {a} := Std.ReflCmp.compare_self (cmp := List.compareLex (compare : UInt8 → UInt8 → Ordering)) + eq_of_compare {a b} h := by + have hl : a.data.toList = b.data.toList := + Std.LawfulEqCmp.eq_of_compare (cmp := List.compareLex (compare : UInt8 → UInt8 → Ordering)) h + cases a; cases b + simp only [ByteArray.mk.injEq] + exact Array.toList_inj.mp hl + +/-! ### Structural keys -/ + +theorem BinderContract.toBits_inj {a b : Ixon.BinderContract} (h : a.toBits = b.toBits) : + a = b := by + have := congrArg Ixon.BinderContract.ofBits? h + simpa using this + +theorem packAllContract_inj {c c' : Ixon.BinderContract} {r r' : Ixon.ValueContract} + (h : Ixon.packAllContract c r = Ixon.packAllContract c' r') : c = c' ∧ r = r' := by + have := congrArg Ixon.unpackAllContract? h + simpa using this + +theorem LetContract.eq_of_flags {c c' : Ixon.LetContract} (hf : c.flags = c'.flags) + (hb : c.binder = c'.binder) : c = c' := by + have h1 := Ixon.LetContract.ofFlags?_flags c + have h2 := Ixon.LetContract.ofFlags?_flags c' + rw [hf, hb, h2] at h1 + exact (Option.some.inj h1).symm + +theorem map_toNat_inj : ∀ {xs ys : List UInt64}, + xs.map UInt64.toNat = ys.map UInt64.toNat → xs = ys + | [], [], _ => rfl + | [], _ :: _, h => by simp at h + | _ :: _, [], h => by simp at h + | x :: xs, y :: ys, h => by + simp only [List.map_cons, List.cons.injEq] at h + rw [UInt64.toNat_inj.mp h.1, map_toNat_inj h.2] + +/-- Heads with equal §3.2 tag and scalar vector are equal. -/ +theorem Head.eq_of_tag_scalars {h₁ h₂ : Head} (ht : h₁.tag = h₂.tag) + (hs : h₁.scalars = h₂.scalars) : h₁ = h₂ := by + cases h₁ <;> cases h₂ <;> simp only [Head.tag] at ht <;> + first + | exact absurd ht (by decide) + | simp only [Head.scalars, List.cons.injEq, and_true] at hs + case sort.sort i j => rw [UInt64.toNat_inj.mp hs] + case var.var i j => rw [UInt64.toNat_inj.mp hs] + case str.str i j => rw [UInt64.toNat_inj.mp hs] + case nat.nat i j => rw [UInt64.toNat_inj.mp hs] + case ref.ref r us r' vs => + obtain ⟨hr, _, hu⟩ := hs + rw [UInt64.toNat_inj.mp hr, Array.toList_inj.mp (map_toNat_inj hu)] + case recur.recur r us r' vs => + obtain ⟨hr, _, hu⟩ := hs + rw [UInt64.toNat_inj.mp hr, Array.toList_inj.mp (map_toNat_inj hu)] + case prj.prj t f t' f' => + obtain ⟨h1, h2⟩ := hs + rw [UInt64.toNat_inj.mp h1, UInt64.toNat_inj.mp h2] + case app.app => rfl + case lam.lam c c' => rw [BinderContract.toBits_inj (UInt8.toNat_inj.mp hs)] + case all.all c r c' r' => + obtain ⟨h1, h2⟩ := packAllContract_inj (UInt8.toNat_inj.mp hs) + rw [h1, h2] + case letE.letE c c' => + obtain ⟨h1, h2⟩ := hs + rw [LetContract.eq_of_flags (UInt64.toNat_inj.mp h1) + (BinderContract.toBits_inj (UInt8.toNat_inj.mp h2))] + +/-- Structural keys determine nodes: `compareKey` is `eq` exactly on equal +nodes (collision-free identity). -/ +theorem compareKey_eq_iff (x y : Node) : Node.compareKey x y = .eq ↔ x = y := by + constructor + · intro h + simp only [Node.compareKey, Ordering.then_eq_eq] at h + obtain ⟨ht, hs, hc⟩ := h + have ht' : x.head.tag = y.head.tag := Std.LawfulEqOrd.eq_of_compare ht + have hs' : x.head.scalars = y.head.scalars := (lexCompare_eq_iff _ _).mp hs + have hc' : x.children.toList = y.children.toList := (lexCompare_eq_iff _ _).mp hc + cases x; cases y + simp only [Node.mk.injEq] + exact ⟨Head.eq_of_tag_scalars ht' hs', Array.toList_inj.mp hc'⟩ + · intro h; subst h + simp only [Node.compareKey, Ordering.then_eq_eq] + exact ⟨Std.ReflOrd.compare_self, (lexCompare_eq_iff _ _).mpr rfl, + (lexCompare_eq_iff _ _).mpr rfl⟩ + +instance compareKey_trans : Std.TransCmp Node.compareKey := + have : Std.TransCmp (fun x y : Node => compare x.head.tag y.head.tag) := + transCmp_on (compare : Nat → Nat → Ordering) (fun n : Node => n.head.tag) + have : Std.TransCmp (fun x y : Node => lexCompare x.head.scalars y.head.scalars) := + transCmp_on lexCompare (fun n : Node => n.head.scalars) + have : Std.TransCmp (fun x y : Node => lexCompare x.children.toList y.children.toList) := + transCmp_on lexCompare (fun n : Node => n.children.toList) + inferInstanceAs (Std.TransCmp (_root_.compareLex + (fun x y : Node => compare x.head.tag y.head.tag) + (_root_.compareLex (fun x y : Node => lexCompare x.head.scalars y.head.scalars) + (fun x y : Node => lexCompare x.children.toList y.children.toList)))) + +instance compareKey_lawfulEq : Std.LawfulEqCmp Node.compareKey where + compare_self {a} := (compareKey_eq_iff a a).mpr rfl + eq_of_compare {a b} h := (compareKey_eq_iff a b).mp h + +/-! ### Canonical order of a height bucket -/ + +/-- The bucket comparison of `canonicalize` (`compareKey x y != .gt`). -/ +def keyLe (x y : Node) : Bool := (Node.compareKey x y).isLE + +theorem keyLe_eq (x y : Node) : (Node.compareKey x y != .gt) = keyLe x y := by + unfold keyLe; cases Node.compareKey x y <;> rfl + +theorem keyLe_trans (a b c : Node) (h₁ : keyLe a b) (h₂ : keyLe b c) : keyLe a c := + Std.TransCmp.isLE_trans h₁ h₂ + +theorem keyLe_total (a b : Node) : keyLe a b || keyLe b a := by + unfold keyLe + rw [Std.OrientedCmp.eq_swap (cmp := Node.compareKey) (a := b) (b := a)] + cases Node.compareKey a b <;> rfl + +theorem keyLe_antisymm (a b : Node) (h₁ : keyLe a b) (h₂ : keyLe b a) : a = b := by + unfold keyLe at h₁ h₂ + rw [Std.OrientedCmp.eq_swap (cmp := Node.compareKey) (a := b) (b := a)] at h₂ + apply (compareKey_eq_iff a b).mp + revert h₁ h₂ + cases Node.compareKey a b <;> simp [Ordering.isLE, Ordering.swap] + +/-- Sorting by the §3.2 key order gives the same list for any two +arrangements of the same nodes: the order of a height bucket, and hence the +IDs assigned to it, depend only on the bucket's keys. -/ +theorem keySort_eq_of_perm {l₁ l₂ : List Node} (hp : l₁.Perm l₂) : + l₁.mergeSort keyLe = l₂.mergeSort keyLe := by + apply List.Perm.eq_of_pairwise (le := fun a b => keyLe a b = true) + · intro a b _ _ h₁ h₂; exact keyLe_antisymm a b h₁ h₂ + · exact List.pairwise_mergeSort keyLe_trans keyLe_total l₁ + · exact List.pairwise_mergeSort keyLe_trans keyLe_total l₂ + · exact (List.mergeSort_perm l₁ keyLe).trans (hp.trans (List.mergeSort_perm l₂ keyLe).symm) + +end Orders + + + +/-! ## Expansion correctness of materialization -/ + +section Materialize + +/-- Replace every `Share(i)` by `σ i`: the expansion of an encoding whose +table entry `i` expands to `σ i`. -/ +def substShares (σ : Nat → Ixon.Expr) : Ixon.Expr → Ixon.Expr + | .share i => σ i.toNat + | .prj t f v => .prj t f (substShares σ v) + | .app f a => .app (substShares σ f) (substShares σ a) + | .lam c t b => .lam c (substShares σ t) (substShares σ b) + | .all c r t b => .all c r (substShares σ t) (substShares σ b) + | .letE c t v b => .letE c (substShares σ t) (substShares σ v) (substShares σ b) + | e => e + +/-- `E` interprets every term of the DAG as the expression its node +describes. -/ +def DagModel (dag : Dag) (E : Nat → Ixon.Expr) : Prop := + ∀ u, E u = (dag.node u).toExpr E + +/-- Every index of the dictionary names a table entry (`σ`) whose expansion +is the term's interpretation. -/ +def IndexModel (index : Array (Option Nat)) (E σ : Nat → Ixon.Expr) : Prop := + ∀ u i, index[u]?.getD none = some i → i < UInt64.size ∧ σ i = E u + +theorem bind_eq_ok {ε α β : Type} {x : Except ε α} {f : α → Except ε β} {b : β} + (h : (x >>= f) = .ok b) : ∃ a, x = .ok a ∧ f a = .ok b := by + cases x with + | error e => cases h + | ok a => exact ⟨a, rfl, h⟩ + +theorem share_subst {index : Array (Option Nat)} {E σ : Nat → Ixon.Expr} + (hσ : IndexModel index E σ) {u i : Nat} (h : index[u]?.getD none = some i) : + substShares σ (.share i.toUInt64) = E u := by + obtain ⟨hi, he⟩ := hσ u i h + simp only [substShares, toNat_toUInt64_of_lt hi, he] + +/-- Rebuilding a spine collected by `spineWalk` around correct pieces +gives the interpretation of the spine's top. -/ +theorem spineFold_correct (p : Prep) (E σ : Nat → Ixon.Expr) (hE : DagModel p.dag E) + (buildSide : Node → Except SharingError Ixon.Expr) + (hside : ∀ n e, buildSide n = .ok e → substShares σ e = E n.sideChild) : + ∀ (j t : Nat) (tail res : Ixon.Expr), + substShares σ tail = E (p.spineWalk j t).2 → + (p.spineWalk j t).1.foldrM + (fun n acc => do let side ← buildSide n; rebuildSpineNode n acc side) tail = .ok res → + substShares σ res = E t := by + intro j + induction j with + | zero => + intro t tail res htail h + simp only [Prep.spineWalk, List.foldrM_nil] at htail h + cases h + exact htail + | succ j ih => + intro t tail res htail h + simp only [Prep.spineWalk] at htail h + rw [List.foldrM_cons] at h + obtain ⟨acc, hacc, hstep⟩ := bind_eq_ok h + have hinner := ih (p.dag.node t).spineNext tail acc htail hacc + obtain ⟨side, hs, hre⟩ := bind_eq_ok hstep + have hside' := hside _ side hs + rw [hE t] + generalize hn : p.dag.node t = n at hinner hside' hre + cases hh : n.head with + | app => + simp only [rebuildSpineNode, hh] at hre + cases hre + simp only [substShares, hinner, hside', Node.toExpr, hh, Node.spineNext, Node.sideChild] + | lam bc => + simp only [rebuildSpineNode, hh] at hre + cases hre + simp only [substShares, hinner, hside', Node.toExpr, hh, Node.spineNext, Node.sideChild] + | all bc r => + simp only [rebuildSpineNode, hh] at hre + cases hre + simp only [substShares, hinner, hside', Node.toExpr, hh, Node.spineNext, Node.sideChild] + | _ => simp [rebuildSpineNode, hh] at hre + +/-- Every successful materialization is correct: replacing each `Share(i)` +of the built expression by the expansion `σ i` of table entry `i` gives the +interpretation of the requested term. -/ +theorem build_correct (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (E σ : Nat → Ixon.Expr) (hE : DagModel p.dag E) (hσ : IndexModel index E σ) : + ∀ (fuel : Nat) (entry : Bool) (t : Nat) (e : Ixon.Expr), + p.build ev index width entry fuel t = .ok e → substShares σ e = E t := by + intro fuel + induction fuel with + | zero => intro entry t e h; simp [Prep.build] at h + | succ fuel ih => + intro entry t e h + have hside : ∀ (n : Node) (e' : Ixon.Expr), + p.build ev index width false fuel n.sideChild = .ok e' → + substShares σ e' = E n.sideChild := fun n e' h' => ih false n.sideChild e' h' + simp only [Prep.build] at h + split at h + · split at h + · split at h + · -- Share + split at h + · rename_i i hi + cases h + exact share_subst hσ hi + · cases h + · -- inline node + rw [hE t] + cases hh : (p.dag.node t).head <;> simp only [hh] at h + case prj ti f => + obtain ⟨v, hv, hpure⟩ := bind_eq_ok h + cases hpure + simp only [substShares, Node.toExpr, hh, ih false _ v hv] + case letE lc => + obtain ⟨ty, hty, h2⟩ := bind_eq_ok h + obtain ⟨v, hv, h3⟩ := bind_eq_ok h2 + obtain ⟨b, hb, hpure⟩ := bind_eq_ok h3 + cases hpure + simp only [substShares, Node.toExpr, hh, ih false _ ty hty, ih false _ v hv, + ih false _ b hb] + all_goals first + | (cases h; simp only [substShares, Node.toExpr, hh]) + | cases h + · -- telescope cut + split at h + · cases h + split at h + · split at h + · rename_i i hi + simp only [pure_bind] at h + exact spineFold_correct p E σ hE _ hside _ _ _ _ (share_subst hσ hi) h + · cases h + · obtain ⟨tail, htail, hfold⟩ := bind_eq_ok h + exact spineFold_correct p E σ hE _ hside _ _ _ _ (ih false _ tail htail) hfold + · cases h + · cases h + + +/-- Every `Share` index of an expression satisfies `P`. -/ +def SharesIn (P : Nat → Prop) : Ixon.Expr → Prop + | .share i => P i.toNat + | .prj _ _ v => SharesIn P v + | .app f a => SharesIn P f ∧ SharesIn P a + | .lam _ t b => SharesIn P t ∧ SharesIn P b + | .all _ _ t b => SharesIn P t ∧ SharesIn P b + | .letE _ t v b => SharesIn P t ∧ SharesIn P v ∧ SharesIn P b + | _ => True + +theorem spineFold_shares (P : Nat → Prop) (buildSide : Node → Except SharingError Ixon.Expr) + (hside : ∀ n e, buildSide n = .ok e → SharesIn P e) : + ∀ (ns : List Node) (tail res : Ixon.Expr), SharesIn P tail → + ns.foldrM (fun n acc => do let side ← buildSide n; rebuildSpineNode n acc side) tail = + .ok res → SharesIn P res := by + intro ns + induction ns with + | nil => intro tail res ht h; simp only [List.foldrM_nil] at h; cases h; exact ht + | cons n ns ih => + intro tail res ht h + rw [List.foldrM_cons] at h + obtain ⟨acc, hacc, hstep⟩ := bind_eq_ok h + have hinner := ih tail acc ht hacc + obtain ⟨side, hs, hre⟩ := bind_eq_ok hstep + have hside' := hside n side hs + cases hh : n.head <;> simp only [rebuildSpineNode, hh] at hre <;> cases hre <;> + exact ⟨by assumption, by assumption⟩ + +/-- Every `Share` that a successful materialization emits is the index of +some term in its dictionary (so it satisfies any property all those indices +have). -/ +theorem build_shares (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (P : Nat → Prop) + (hP : ∀ (u i : Nat), index[u]?.getD none = some i → i < UInt64.size ∧ P i) : + ∀ (fuel : Nat) (entry : Bool) (t : Nat) (e : Ixon.Expr), + p.build ev index width entry fuel t = .ok e → SharesIn P e := by + intro fuel + induction fuel with + | zero => intro entry t e h; simp [Prep.build] at h + | succ fuel ih => + intro entry t e h + have hside : ∀ (n : Node) (e' : Ixon.Expr), + p.build ev index width false fuel n.sideChild = .ok e' → SharesIn P e' := + fun n e' h' => ih false n.sideChild e' h' + have hshare : ∀ (u i : Nat), index[u]?.getD none = some i → + SharesIn P (.share i.toUInt64) := by + intro u i hi + obtain ⟨hlt, hp⟩ := hP u i hi + simp only [SharesIn, toNat_toUInt64_of_lt hlt, hp] + simp only [Prep.build] at h + split at h + · split at h + · split at h + · split at h + · rename_i i hi + cases h + exact hshare _ _ hi + · cases h + · cases hh : (p.dag.node t).head <;> simp only [hh] at h + case prj ti f => + obtain ⟨v, hv, hpure⟩ := bind_eq_ok h + cases hpure + exact ih false _ v hv + case letE lc => + obtain ⟨ty, hty, h2⟩ := bind_eq_ok h + obtain ⟨v, hv, h3⟩ := bind_eq_ok h2 + obtain ⟨b, hb, hpure⟩ := bind_eq_ok h3 + cases hpure + exact ⟨ih false _ ty hty, ih false _ v hv, ih false _ b hb⟩ + all_goals first + | (cases h; simp only [SharesIn, Node.toExpr, hh]) + | cases h + · split at h + · cases h + split at h + · split at h + · rename_i i hi + simp only [pure_bind] at h + exact spineFold_shares P _ hside _ _ _ (hshare _ _ hi) h + · cases h + · obtain ⟨tail, htail, hfold⟩ := bind_eq_ok h + exact spineFold_shares P _ hside _ _ _ (ih false _ tail htail) hfold + · cases h + · cases h + +theorem indexOfPairs_bound (size k : Nat) (pairs : List (Nat × Nat)) + (h : ∀ x ∈ pairs, x.2 < k) : + ∀ (u i : Nat), (indexOfPairs size pairs)[u]?.getD none = some i → i < k := by + unfold indexOfPairs + suffices hs : ∀ (acc : Array (Option Nat)), + (∀ (u i : Nat), acc[u]?.getD none = some i → i < k) → + ∀ (u i : Nat), (pairs.foldl (fun acc (t, i) => acc.set! t (some i)) acc)[u]?.getD none = + some i → i < k by + refine hs _ (fun u i hu => ?_) + simp only [Array.getElem?_replicate] at hu + split at hu <;> simp at hu + induction pairs with + | nil => intro acc hacc; simpa using hacc + | cons x xs ih => + intro acc hacc + rw [List.foldl_cons] + apply ih (fun y hy => h y (List.mem_cons_of_mem x hy)) + intro u i hu + obtain ⟨t, j⟩ := x + simp only [Array.set!, Array.getElem?_setIfInBounds] at hu + split at hu + · split at hu + · simp at hu + subst hu + exact h (t, j) List.mem_cons_self + · simp at hu + · exact hacc u i hu + +/-- The dictionary of the first `k` table entries only holds indices below +`k`. -/ +theorem indexOfPrefix_bound (size : Nat) (table : Array Nat) (k : Nat) : + ∀ (u i : Nat), (indexOfPrefix size table k)[u]?.getD none = some i → i < k := by + unfold indexOfPrefix + apply indexOfPairs_bound + intro x hx + obtain ⟨_, hlt, _⟩ := List.mem_zipIdx hx + simp only [List.length_take, Nat.zero_add] at hlt + omega + +/-- Backward references: building with the dictionary of the first `k` +entries emits only `Share` indices below `k` (for a table entry `k` that +is "strictly earlier", for roots `k` is the table size). -/ +theorem build_prefix_backward (p : Prep) (ev : DictEval) (table : Array Nat) (k : Nat) + (hk : k ≤ UInt64.size) (width : Array (Option Nat)) : + ∀ (fuel : Nat) (entry : Bool) (t : Nat) (e : Ixon.Expr), + p.build ev (indexOfPrefix p.dag.size table k) width entry fuel t = .ok e → + SharesIn (· < k) e := + build_shares p ev _ width (· < k) fun u i hi => + have := indexOfPrefix_bound p.dag.size table k u i hi + ⟨by omega, this⟩ + +theorem forall₂_imp {α β : Type} {R S : α → β → Prop} (hRS : ∀ a b, R a b → S a b) : + ∀ {xs : List α} {ys : List β}, List.Forall₂ R xs ys → List.Forall₂ S xs ys + | _, _, .nil => .nil + | _, _, .cons h hs => .cons (hRS _ _ h) (forall₂_imp hRS hs) + +theorem mapM_ok_forall₂ {α β ε : Type} (f : α → Except ε β) : + ∀ (xs : List α) (ys : List β), xs.mapM f = .ok ys → List.Forall₂ (fun x y => f x = .ok y) xs ys + | [], ys, h => by simp only [List.mapM_nil] at h; cases h; exact .nil + | x :: xs, ys, h => by + rw [List.mapM_cons] at h + obtain ⟨y, hy, h2⟩ := bind_eq_ok h + obtain ⟨ys', hys, h3⟩ := bind_eq_ok h2 + cases h3 + exact .cons hy (mapM_ok_forall₂ f xs ys' hys) + +/-- Every expression returned by a successful `materializeWith` expands to +its target term. -/ +theorem materializeWith_correct (p : Prep) (index width : Array (Option Nat)) + (targets : Array Nat) (limits : Limits) (out : Array Ixon.Expr) (cost : Array Nat) (work : Nat) + (h : p.materializeWith index width targets limits = .ok (out, cost, work)) + (E σ : Nat → Ixon.Expr) (hE : DagModel p.dag E) (hσ : IndexModel index E σ) : + List.Forall₂ (fun t e => substShares σ e = E t) targets.toList out.toList := by + unfold Prep.materializeWith at h + obtain ⟨_, _, h⟩ := bind_eq_ok h + simp only at h + split at h + · cases h + · obtain ⟨out', hout, hret⟩ := bind_eq_ok h + cases hret + rw [Array.mapM_eq_mapM_toList] at hout + cases hm : List.mapM (fun t => p.build (p.evalAll width) index width false (p.dag.size + 1) t) + targets.toList with + | error err => rw [hm] at hout; cases hout + | ok l => + rw [hm] at hout + have hout' : out = l.toArray := by + cases hout; rfl + subst hout' + exact forall₂_imp (fun t e he => build_correct p _ index width E σ hE hσ _ false t e he) + (mapM_ok_forall₂ _ _ _ hm) + + +end Materialize + + +end Ix.Compile.Verify.SharingExact diff --git a/Ix/Compile/Verify/SharingExactCanon.lean b/Ix/Compile/Verify/SharingExactCanon.lean new file mode 100644 index 000000000..8d19fa19a --- /dev/null +++ b/Ix/Compile/Verify/SharingExactCanon.lean @@ -0,0 +1,997 @@ +import Ix.Compile.Verify.SharingExactPasses + +/-! +# Exact sharing: determinism of canonical structural IDs + +`canonicalize` renumbers the reachable nodes of a hash-consed temporary DAG +by height, then by the §3.2 key. The theorem `canonicalize_det` states that +its result depends only on the root terms: two temporary DAGs (any IDs, any +unreachable nodes) whose roots denote the same terms canonicalize to the +same DAG and root IDs. +-/ + +namespace Ix.Compile.Verify.SharingExact + +open Ix.Sharing.Exact + +section Canon + +/-! ## Temporary DAGs -/ + +/-- Children precede their parents. -/ +def CP (temp : Array Node) : Prop := + ∀ t, t < temp.size → ∀ c ∈ (temp[t]!).children, c < t + +/-- Every node has exactly `head.arity` children. -/ +def NodeArity (temp : Array Node) : Prop := + ∀ t, t < temp.size → (temp[t]!).children.size = (temp[t]!).head.arity + +theorem getElem!_eq_getElem {α : Type} [Inhabited α] (a : Array α) (i : Nat) (h : i < a.size) : + a[i]! = a[i] := by + simp [h] + +theorem cp_of_childrenPrecede {temp : Array Node} (h : childrenPrecede temp = true) : + CP temp := by + intro t ht c hc + unfold childrenPrecede at h + rw [Array.all_eq_true] at h + have := h t (by simpa using ht) + simp only [Array.getElem_zipIdx, Nat.zero_add] at this + rw [Array.all_eq_true] at this + rw [getElem!_eq_getElem temp t ht] at hc + obtain ⟨k, hk, rfl⟩ := Array.mem_iff_getElem.mp hc + simpa using this k hk + +/-- The term a temporary node denotes. -/ +def termOf (temp : Array Node) (t : Nat) : Ixon.Expr := + (temp[t]!).toExpr fun c => if _h : c < t then termOf temp c else default +termination_by t +decreasing_by assumption + +theorem termOf_eq (temp : Array Node) (t : Nat) : + termOf temp t = (temp[t]!).toExpr fun c => if c < t then termOf temp c else default := by + rw [termOf] + simp only [dite_eq_ite] + +/-- A node is determined, up to its children's terms, by the expression it +builds. -/ +theorem toExpr_inj {n₁ n₂ : Node} {f₁ f₂ : Nat → Ixon.Expr} + (h : n₁.toExpr f₁ = n₂.toExpr f₂) : + n₁.head = n₂.head ∧ ∀ k, k < n₁.head.arity → f₁ (n₁.child k) = f₂ (n₂.child k) := by + unfold Node.toExpr at h + cases h1 : n₁.head <;> cases h2 : n₂.head <;> simp only [h1, h2] at h <;> simp at h + all_goals (refine ⟨by simp_all, fun k hk => ?_⟩; simp only [Head.arity] at hk) + all_goals (rcases k with _ | _ | _ | k <;> first | omega | simp_all) + +theorem child_eq_getElem (n : Node) (k : Nat) (hk : k < n.children.size) : + n.child k = n.children[k] := by + simp [Node.child, Array.getD_eq_getD_getElem?, hk] + +/-- Nodes denoting the same term have the same head and children denoting +the same terms. -/ +theorem children_corr {temp₁ temp₂ : Array Node} (hcp₁ : CP temp₁) (hcp₂ : CP temp₂) + (har₁ : NodeArity temp₁) (har₂ : NodeArity temp₂) {t s : Nat} + (ht : t < temp₁.size) (hs : s < temp₂.size) (h : termOf temp₁ t = termOf temp₂ s) : + (temp₁[t]!).head = (temp₂[s]!).head ∧ + (temp₁[t]!).children.size = (temp₂[s]!).children.size ∧ + ∀ (k : Nat) (hk₁ : k < (temp₁[t]!).children.size) (hk₂ : k < (temp₂[s]!).children.size), + termOf temp₁ (temp₁[t]!).children[k] = termOf temp₂ (temp₂[s]!).children[k] := by + rw [termOf_eq, termOf_eq temp₂] at h + obtain ⟨hhead, hk⟩ := toExpr_inj h + have hsize : (temp₁[t]!).children.size = (temp₂[s]!).children.size := by + rw [har₁ t ht, har₂ s hs, hhead] + refine ⟨hhead, hsize, fun k hk₁ hk₂ => ?_⟩ + have := hk k (by rw [← har₁ t ht]; exact hk₁) + rw [child_eq_getElem _ k hk₁, child_eq_getElem _ k hk₂] at this + rw [if_pos (hcp₁ t ht _ (Array.getElem_mem hk₁)), + if_pos (hcp₂ s hs _ (Array.getElem_mem hk₂))] at this + exact this + +/-! ## Reachability -/ + +/-- `t` is reachable from `roots` through child edges. -/ +inductive Reach (temp : Array Node) (roots : Array Nat) : Nat → Prop + | root {t : Nat} : t ∈ roots → Reach temp roots t + | child {t c : Nat} : Reach temp roots t → c ∈ (temp[t]!).children → Reach temp roots c + +theorem reach_lt {temp : Array Node} {roots : Array Nat} (hcp : CP temp) + (hin : ∀ r ∈ roots, r < temp.size) {t : Nat} (h : Reach temp roots t) : t < temp.size := by + induction h with + | root hr => exact hin _ hr + | child _ hc ih => exact Nat.lt_trans (hcp _ ih _ hc) ih + +/-- Reachable terms of one DAG are reachable terms of any other DAG whose +roots denote the same terms. -/ +theorem reach_transfer {temp₁ temp₂ : Array Node} {roots₁ roots₂ : Array Nat} + (hcp₁ : CP temp₁) (hcp₂ : CP temp₂) (har₁ : NodeArity temp₁) (har₂ : NodeArity temp₂) + (hin₁ : ∀ r ∈ roots₁, r < temp₁.size) (hin₂ : ∀ r ∈ roots₂, r < temp₂.size) + (hroots : roots₁.map (termOf temp₁) = roots₂.map (termOf temp₂)) {t : Nat} + (h : Reach temp₁ roots₁ t) : + ∃ s, Reach temp₂ roots₂ s ∧ termOf temp₁ t = termOf temp₂ s := by + induction h with + | root hr => + obtain ⟨i, hi, rfl⟩ := Array.mem_iff_getElem.mp hr + have hsz : roots₁.size = roots₂.size := by + simpa using congrArg Array.size hroots + refine ⟨roots₂[i], .root (Array.getElem_mem _), ?_⟩ + have := congrArg (·[i]?) hroots + simp only [Array.getElem?_map, Array.getElem?_eq_getElem hi, + Array.getElem?_eq_getElem (hsz ▸ hi), Option.map_some, Option.some.injEq] at this + exact this + | @child t c hreach hc ih => + obtain ⟨s, hs, hts⟩ := ih + have ht := reach_lt hcp₁ hin₁ hreach + have hs' := reach_lt hcp₂ hin₂ hs + obtain ⟨_, hsize, hk⟩ := children_corr hcp₁ hcp₂ har₁ har₂ ht hs' hts + obtain ⟨k, hk₁, rfl⟩ := Array.mem_iff_getElem.mp hc + exact ⟨_, .child hs (Array.getElem_mem (hsize ▸ hk₁)), hk k hk₁ (hsize ▸ hk₁)⟩ + +theorem getElem!_bool_iff (a : Array Bool) (i : Nat) : a[i]! = true ↔ a[i]? = some true := by + rw [getElem!_def] + cases a[i]? with + | none => simp + | some b => simp + +theorem foldl_setTrue_size (l : List Nat) (arr : Array Bool) : + (l.foldl (fun r c => r.set! c true) arr).size = arr.size := by + induction l generalizing arr with + | nil => rfl + | cons x xs ih => rw [List.foldl_cons, ih]; simp [Array.set!] + +theorem foldl_setTrue_getElem (l : List Nat) (arr : Array Bool) (t : Nat) : + (l.foldl (fun r c => r.set! c true) arr)[t]! = true ↔ + arr[t]! = true ∨ (t ∈ l ∧ t < arr.size) := by + induction l generalizing arr with + | nil => simp + | cons x xs ih => + rw [List.foldl_cons, ih] + simp only [Array.set!, Array.size_setIfInBounds, List.mem_cons, getElem!_bool_iff, + Array.getElem?_setIfInBounds] + by_cases hx : x = t + · subst hx + by_cases hlt : x < arr.size <;> simp [hlt] + · simp only [hx, if_false] + constructor + · rintro (h | ⟨h1, h2⟩) + · exact Or.inl h + · exact Or.inr ⟨Or.inr h1, h2⟩ + · rintro (h | ⟨h1 | h1, h2⟩) + · exact Or.inl h + · exact absurd h1.symm hx + · exact Or.inr ⟨h1, h2⟩ + +/-- The marking step of `reachMarks` for node `t`. -/ +def markStep (temp : Array Node) (t : Nat) (reach : Array Bool) : Array Bool := + if reach[t]! then temp[t]!.children.foldl (fun r c => r.set! c true) reach else reach + +theorem markStep_size (temp : Array Node) (t : Nat) (reach : Array Bool) : + (markStep temp t reach).size = reach.size := by + unfold markStep + split + · rw [← Array.foldl_toList, foldl_setTrue_size] + · rfl + +/-- The marks after visiting the IDs from `m` up. -/ +def marksFrom (temp : Array Node) (roots : Array Nat) (m : Nat) : Array Bool := + (List.range' m (temp.size - m)).foldr (markStep temp) + (roots.foldl (fun r t => r.set! t true) (Array.replicate temp.size false)) + +theorem reachMarks_eq (temp : Array Node) (roots : Array Nat) : + reachMarks temp roots = marksFrom temp roots 0 := by + unfold reachMarks marksFrom + rw [List.range_eq_range', Nat.sub_zero] + rfl + +theorem marksFrom_succ (temp : Array Node) (roots : Array Nat) (m : Nat) (hm : m < temp.size) : + marksFrom temp roots m = markStep temp m (marksFrom temp roots (m + 1)) := by + unfold marksFrom + rw [show temp.size - m = (temp.size - (m + 1)) + 1 by omega, List.range'_succ] + rfl + +theorem marksFrom_size (temp : Array Node) (roots : Array Nat) (m : Nat) : + (marksFrom temp roots m).size = temp.size := by + unfold marksFrom + generalize List.range' m (temp.size - m) = l + induction l with + | nil => + simp only [List.foldr_nil] + rw [← Array.foldl_toList, foldl_setTrue_size, Array.size_replicate] + | cons x xs ih => rw [List.foldr_cons, markStep_size, ih] + +/-- The marks are exactly the reachable nodes. -/ +theorem reachMarks_spec {temp : Array Node} {roots : Array Nat} (hcp : CP temp) + (hin : ∀ r ∈ roots, r < temp.size) (t : Nat) (ht : t < temp.size) : + (reachMarks temp roots)[t]! = true ↔ Reach temp roots t := by + let Q (m t : Nat) : Prop := + t ∈ roots ∨ ∃ p, m ≤ p ∧ Reach temp roots p ∧ t ∈ (temp[p]!).children + have hinv : ∀ k, k ≤ temp.size → ∀ t, t < temp.size → + ((marksFrom temp roots (temp.size - k))[t]! = true ↔ Q (temp.size - k) t) := by + intro k + induction k with + | zero => + intro _ t ht + unfold marksFrom + simp only [Nat.sub_zero, Nat.sub_self, List.range'_zero, List.foldr_nil] + rw [← Array.foldl_toList, foldl_setTrue_getElem] + have hf : ¬ (Array.replicate temp.size false)[t]! = true := by + rw [getElem!_bool_iff, Array.getElem?_replicate]; simp + simp only [Array.size_replicate, Array.mem_toList_iff] + constructor + · rintro (h | ⟨h, _⟩) + · exact absurd h hf + · exact Or.inl h + · rintro (h | ⟨p, hp, hr, _⟩) + · exact Or.inr ⟨h, ht⟩ + · exact absurd (reach_lt hcp hin hr) (by omega) + | succ k ih => + intro hk t ht + have hm : temp.size - (k + 1) < temp.size := by omega + have hm1 : temp.size - (k + 1) + 1 = temp.size - k := by omega + rw [marksFrom_succ temp roots _ hm, hm1] + have hreach : (marksFrom temp roots (temp.size - k))[temp.size - (k + 1)]! = true ↔ + Reach temp roots (temp.size - (k + 1)) := by + rw [ih (by omega) _ hm] + constructor + · rintro (h | ⟨p, _, hp, hc⟩) + · exact .root h + · exact .child hp hc + · intro h + cases h with + | root h => exact Or.inl h + | @child p _ hp hc => + exact Or.inr ⟨p, by have := hcp p (reach_lt hcp hin hp) _ hc; omega, hp, hc⟩ + unfold markStep + split + · rename_i hmark + rw [← Array.foldl_toList, foldl_setTrue_getElem, ih (by omega) t ht, marksFrom_size, + Array.mem_toList_iff] + have hr := hreach.mp hmark + constructor + · rintro (h | ⟨hc, _⟩) + · rcases h with h | ⟨p, hp, hpr, hc⟩ + · exact Or.inl h + · exact Or.inr ⟨p, by omega, hpr, hc⟩ + · exact Or.inr ⟨_, Nat.le_refl _, hr, hc⟩ + · rintro (h | ⟨p, hp, hpr, hc⟩) + · exact Or.inl (Or.inl h) + · by_cases hpe : p = temp.size - (k + 1) + · subst hpe + exact Or.inr ⟨hc, ht⟩ + · exact Or.inl (Or.inr ⟨p, by omega, hpr, hc⟩) + · rename_i hmark + rw [ih (by omega) t ht] + constructor + · rintro (h | ⟨p, hp, hpr, hc⟩) + · exact Or.inl h + · exact Or.inr ⟨p, by omega, hpr, hc⟩ + · rintro (h | ⟨p, hp, hpr, hc⟩) + · exact Or.inl h + · by_cases hpe : p = temp.size - (k + 1) + · subst hpe + exact absurd (hreach.mpr hpr) hmark + · exact Or.inr ⟨p, by omega, hpr, hc⟩ + rw [reachMarks_eq] + have := hinv temp.size (Nat.le_refl _) t ht + rw [Nat.sub_self] at this + rw [this] + constructor + · rintro (h | ⟨p, _, hp, hc⟩) + · exact .root h + · exact .child hp hc + · intro h + cases h with + | root h => exact Or.inl h + | @child p _ hp hc => exact Or.inr ⟨p, Nat.zero_le _, hp, hc⟩ + +/-! ## Heights -/ + +theorem setBang_getElem! {α : Type} [Inhabited α] (a : Array α) (i j : Nat) (v : α) : + (a.set! i v)[j]! = if i = j ∧ i < a.size then v else a[j]! := by + simp only [Array.set!, getElem!_def, Array.getElem?_setIfInBounds] + by_cases hij : i = j + · subst hij + by_cases hi : i < a.size <;> simp [hi] + · simp [hij] + +/-- One height step: one more than the highest child, `0` for a leaf. -/ +def heightOf (temp : Array Node) (height : Array Nat) (t : Nat) : Nat := + (temp[t]!).children.foldl (fun acc c => max acc (height[c]! + 1)) 0 + +theorem heightOf_eq_map (temp : Array Node) (height : Array Nat) (t : Nat) : + heightOf temp height t = + (((temp[t]!).children.toList.map (height[·]!)).foldl (fun acc x => max acc (x + 1)) 0) := by + unfold heightOf + rw [← Array.foldl_toList, List.foldl_map] + +theorem heightOf_congr (temp : Array Node) (h₁ h₂ : Array Nat) (t : Nat) + (h : ∀ c ∈ (temp[t]!).children, h₁[c]! = h₂[c]!) : + heightOf temp h₁ t = heightOf temp h₂ t := by + rw [heightOf_eq_map, heightOf_eq_map] + congr 1 + apply List.map_congr_left + intro c hc + exact h c (Array.mem_toList_iff.mp hc) + +theorem foldl_max_ge (l : List Nat) (acc : Nat) : + acc ≤ l.foldl (fun acc x => max acc (x + 1)) acc ∧ + ∀ x ∈ l, x + 1 ≤ l.foldl (fun acc x => max acc (x + 1)) acc := by + induction l generalizing acc with + | nil => simp + | cons y ys ih => + obtain ⟨h1, h2⟩ := ih (max acc (y + 1)) + refine ⟨by simp only [List.foldl_cons]; omega, fun x hx => ?_⟩ + simp only [List.foldl_cons] + rcases List.mem_cons.mp hx with rfl | hx + · omega + · exact h2 x hx + +theorem child_height_lt (temp : Array Node) (height : Array Nat) (t c : Nat) + (hc : c ∈ (temp[t]!).children) : height[c]! < heightOf temp height t := by + rw [heightOf_eq_map] + have := (foldl_max_ge ((temp[t]!).children.toList.map (height[·]!)) 0).2 (height[c]!) + (List.mem_map_of_mem (f := (height[·]!)) (Array.mem_toList_iff.mpr hc)) + omega + +/-- Each stored height is the height step of its node. -/ +theorem nodeHeights_spec {temp : Array Node} (hcp : CP temp) (t : Nat) (ht : t < temp.size) : + (nodeHeights temp)[t]! = heightOf temp (nodeHeights temp) t := by + let step := fun (height : Array Nat) (t : Nat) => height.set! t (heightOf temp height t) + have hinv : ∀ m, m ≤ temp.size → + ((List.range m).foldl step (Array.replicate temp.size 0)).size = temp.size ∧ + ∀ t, t < m → ((List.range m).foldl step (Array.replicate temp.size 0))[t]! = + heightOf temp ((List.range m).foldl step (Array.replicate temp.size 0)) t := by + intro m + induction m with + | zero => simp + | succ m ih => + intro hm + obtain ⟨hsize, hprev⟩ := ih (by omega) + rw [List.range_succ, List.foldl_append, List.foldl_cons, List.foldl_nil] + generalize hH : List.foldl step (Array.replicate temp.size 0) (List.range m) = H at hsize hprev + have hsame : ∀ c, c < m → (step H m)[c]! = H[c]! := by + intro c hc + simp only [step, setBang_getElem!] + rw [if_neg (by omega)] + refine ⟨by simp [step, hsize], fun t' ht' => ?_⟩ + have hcongr : heightOf temp (step H m) t' = heightOf temp H t' := + heightOf_congr temp _ _ t' fun c hc => + hsame c (by have := hcp t' (by omega) c hc; omega) + rw [hcongr] + by_cases htm : t' = m + · subst htm + simp only [step, setBang_getElem!, hsize] + rw [if_pos (by simp; omega)] + · rw [hsame t' (by omega)] + exact hprev t' (by omega) + have := (hinv temp.size (Nat.le_refl _)).2 t ht + exact this + +/-! ## Two inputs denoting the same roots -/ + +/-- The hypotheses on one `canonicalize` input: children precede parents (as +checked), the arity invariant, roots in range, and hash-consing (distinct +reachable nodes denote distinct terms). -/ +structure Run (temp : Array Node) (roots : Array Nat) : Prop where + precede : childrenPrecede temp = true + arity : NodeArity temp + inRange : ∀ r ∈ roots, r < temp.size + hashConsed : ∀ s t, Reach temp roots s → Reach temp roots t → + termOf temp s = termOf temp t → s = t + +theorem Run.cp {temp : Array Node} {roots : Array Nat} (h : Run temp roots) : CP temp := + cp_of_childrenPrecede h.precede + +/-- Reachable nodes of the two inputs that denote the same term. -/ +def Corr (temp₁ temp₂ : Array Node) (roots₁ roots₂ : Array Nat) (t s : Nat) : Prop := + Reach temp₁ roots₁ t ∧ Reach temp₂ roots₂ s ∧ termOf temp₁ t = termOf temp₂ s + +variable {temp₁ temp₂ : Array Node} {roots₁ roots₂ : Array Nat} + +theorem Corr.symm {t s : Nat} (h : Corr temp₁ temp₂ roots₁ roots₂ t s) : + Corr temp₂ temp₁ roots₂ roots₁ s t := + ⟨h.2.1, h.1, h.2.2.symm⟩ + +theorem corr_total (h₁ : Run temp₁ roots₁) (h₂ : Run temp₂ roots₂) + (hroots : roots₁.map (termOf temp₁) = roots₂.map (termOf temp₂)) {t : Nat} + (ht : Reach temp₁ roots₁ t) : ∃ s, Corr temp₁ temp₂ roots₁ roots₂ t s := by + obtain ⟨s, hs, he⟩ := reach_transfer h₁.cp h₂.cp h₁.arity h₂.arity h₁.inRange h₂.inRange + hroots ht + exact ⟨s, ht, hs, he⟩ + +theorem corr_func (h₂ : Run temp₂ roots₂) {t s s' : Nat} + (h : Corr temp₁ temp₂ roots₁ roots₂ t s) (h' : Corr temp₁ temp₂ roots₁ roots₂ t s') : + s = s' := + h₂.hashConsed s s' h.2.1 h'.2.1 (h.2.2.symm.trans h'.2.2) + +theorem corr_inj (h₁ : Run temp₁ roots₁) {t t' s : Nat} + (h : Corr temp₁ temp₂ roots₁ roots₂ t s) (h' : Corr temp₁ temp₂ roots₁ roots₂ t' s) : + t = t' := + h₁.hashConsed t t' h.1 h'.1 (h.2.2.trans h'.2.2.symm) + +theorem corr_children (h₁ : Run temp₁ roots₁) (h₂ : Run temp₂ roots₂) {t s : Nat} + (hc : Corr temp₁ temp₂ roots₁ roots₂ t s) : + (temp₁[t]!).head = (temp₂[s]!).head ∧ + (temp₁[t]!).children.size = (temp₂[s]!).children.size ∧ + ∀ (k : Nat) (hk₁ : k < (temp₁[t]!).children.size) (hk₂ : k < (temp₂[s]!).children.size), + Corr temp₁ temp₂ roots₁ roots₂ (temp₁[t]!).children[k] (temp₂[s]!).children[k] := by + have ht := reach_lt h₁.cp h₁.inRange hc.1 + have hs := reach_lt h₂.cp h₂.inRange hc.2.1 + obtain ⟨hhead, hsize, hk⟩ := children_corr h₁.cp h₂.cp h₁.arity h₂.arity ht hs hc.2.2 + exact ⟨hhead, hsize, fun k hk₁ hk₂ => + ⟨.child hc.1 (Array.getElem_mem hk₁), .child hc.2.1 (Array.getElem_mem hk₂), hk k hk₁ hk₂⟩⟩ + +/-- Corresponding nodes have the same height. -/ +theorem corr_height (h₁ : Run temp₁ roots₁) (h₂ : Run temp₂ roots₂) : + ∀ t s, Corr temp₁ temp₂ roots₁ roots₂ t s → + (nodeHeights temp₁)[t]! = (nodeHeights temp₂)[s]! := by + intro t + induction t using Nat.strongRecOn with + | _ t ih => + intro s hc + have ht := reach_lt h₁.cp h₁.inRange hc.1 + have hs := reach_lt h₂.cp h₂.inRange hc.2.1 + rw [nodeHeights_spec h₁.cp t ht, nodeHeights_spec h₂.cp s hs, heightOf_eq_map, + heightOf_eq_map] + congr 1 + obtain ⟨_, hsize, hk⟩ := corr_children h₁ h₂ hc + apply List.ext_getElem (by simp [hsize]) + intro k hk₁ hk₂ + simp only [List.getElem_map, Array.getElem_toList] + simp only [List.length_map, Array.length_toList] at hk₁ hk₂ + exact ih _ (h₁.cp t ht _ (Array.getElem_mem hk₁)) _ (hk k hk₁ hk₂) + +/-! ## Maximum height and buckets -/ + +/-- The largest height of a marked node (the `maxH` of `canonicalize`). -/ +def maxHeight (reach : Array Bool) (height : Array Nat) (n : Nat) : Nat := + (List.range n).foldl (fun acc t => if reach[t]! then max acc height[t]! else acc) 0 + +theorem maxHeight_spec (reach : Array Bool) (height : Array Nat) (n : Nat) : + (∀ t, t < n → reach[t]! = true → height[t]! ≤ maxHeight reach height n) ∧ + (maxHeight reach height n = 0 ∨ + ∃ t, t < n ∧ reach[t]! = true ∧ height[t]! = maxHeight reach height n) := by + induction n with + | zero => simp [maxHeight] + | succ n ih => + obtain ⟨hge, hatt⟩ := ih + have hstep : maxHeight reach height (n + 1) = + if reach[n]! then max (maxHeight reach height n) height[n]! + else maxHeight reach height n := by + unfold maxHeight + rw [List.range_succ, List.foldl_append, List.foldl_cons, List.foldl_nil] + rw [hstep] + split + · rename_i hn + refine ⟨fun t ht hr => ?_, ?_⟩ + · by_cases htn : t = n + · subst htn; omega + · have := hge t (by omega) hr; omega + · by_cases hle : maxHeight reach height n ≤ height[n]! + · exact Or.inr ⟨n, by omega, hn, by omega⟩ + · rcases hatt with h0 | ⟨t, ht, hr, he⟩ + · omega + · exact Or.inr ⟨t, by omega, hr, by omega⟩ + · rename_i hn + refine ⟨fun t ht hr => ?_, ?_⟩ + · by_cases htn : t = n + · subst htn; exact absurd hr hn + · exact hge t (by omega) hr + · rcases hatt with h0 | ⟨t, ht, hr, he⟩ + · exact Or.inl h0 + · exact Or.inr ⟨t, by omega, hr, he⟩ + +theorem modify_getElem! {α : Type} [Inhabited α] (a : Array α) (i j : Nat) (f : α → α) + (hi : i < a.size) : (a.modify i f)[j]! = if i = j then f a[j]! else a[j]! := by + simp only [getElem!_def, Array.getElem?_modify] + by_cases hij : i = j + · subst hij + simp [Array.getElem?_eq_getElem hi] + · simp [hij] + +theorem heightBuckets_spec (reach : Array Bool) (height : Array Nat) (maxH n : Nat) + (hle : ∀ t, t < n → reach[t]! = true → height[t]! ≤ maxH) : + (heightBuckets reach height maxH n).size = maxH + 1 ∧ + ∀ h, h ≤ maxH → ((heightBuckets reach height maxH n)[h]!).toList = + (List.range n).filter (fun t => reach[t]! && height[t]! == h) := by + induction n with + | zero => + unfold heightBuckets + refine ⟨by simp, fun h hh => ?_⟩ + simp [getElem!_def, show h < maxH + 1 by omega] + | succ n ih => + obtain ⟨hsize, hlist⟩ := ih (fun t ht hr => hle t (by omega) hr) + have hstep : heightBuckets reach height maxH (n + 1) = + if reach[n]! then (heightBuckets reach height maxH n).modify height[n]! (·.push n) + else heightBuckets reach height maxH n := by + unfold heightBuckets + rw [List.range_succ, List.foldl_append, List.foldl_cons, List.foldl_nil] + rw [hstep] + split + · rename_i hn + have hnle := hle n (by omega) hn + refine ⟨by simp [hsize], fun h hh => ?_⟩ + rw [List.range_succ, List.filter_append, ← hlist h hh, + modify_getElem! _ _ _ _ (by omega)] + by_cases hhn : height[n]! = h + · subst hhn + simp [hn] + · simp [hhn] + · rename_i hn + refine ⟨hsize, fun h hh => ?_⟩ + rw [List.range_succ, List.filter_append, hlist h hh] + simp [hn] + +/-! ## Placing a sorted group -/ + +/-- The key check of `placeSorted`: keys strictly increase (after `prev`). -/ +def keysIncreasing : Option Node → List Node → Bool + | _, [] => true + | prev, n :: ns => + (match prev with + | some p => Node.compareKey p n == .lt + | none => true) && keysIncreasing (some n) ns + +/-- The assignments of `placeSorted`. -/ +def placeFold (l : List (Nat × Node)) (st : Array Nat × Array Node) : Array Nat × Array Node := + l.foldl (fun st x => (st.1.set! x.1 st.2.size, st.2.push x.2)) st + +theorem placeSorted_eq (l : List (Nat × Node)) (prev : Option Node) + (st : Array Nat × Array Node) : + placeSorted l prev st = + if keysIncreasing prev (l.map (·.2)) then .ok (placeFold l st) + else .error (.internal "structural keys not strictly increasing within a height") := by + induction l generalizing prev st with + | nil => simp [placeSorted, keysIncreasing, placeFold]; rfl + | cons x rest ih => + obtain ⟨t, node⟩ := x + obtain ⟨canon, out⟩ := st + have hfold : placeFold ((t, node) :: rest) (canon, out) = + placeFold rest (canon.set! t out.size, out.push node) := rfl + cases prev with + | none => + simp only [placeSorted, List.map_cons, keysIncreasing, Bool.true_and, hfold] + exact ih _ _ + | some p => + simp only [placeSorted, List.map_cons, keysIncreasing, hfold] + by_cases hlt : Node.compareKey p node = .lt + · simp only [hlt] + exact ih _ _ + · have hne : (Node.compareKey p node == .lt) = false := by + cases h : Node.compareKey p node with + | lt => exact absurd h hlt + | eq => rfl + | gt => rfl + simp only [hne, Bool.false_and] + rfl + +theorem keysIncreasing_pairwise (ns : List Node) : + ∀ (prev : Option Node), keysIncreasing prev ns = true → + (∀ p, prev = some p → ∀ x ∈ ns, Node.compareKey p x = .lt) ∧ + ns.Pairwise (fun a b => Node.compareKey a b = .lt) := by + induction ns with + | nil => intro _ _; exact ⟨fun _ _ _ h => by simp at h, List.Pairwise.nil⟩ + | cons n ns ih => + intro prev h + simp only [keysIncreasing, Bool.and_eq_true] at h + obtain ⟨hhead, hrest⟩ := h + obtain ⟨hfirst, hpw⟩ := ih (some n) hrest + have hn : ∀ x ∈ ns, Node.compareKey n x = .lt := hfirst n rfl + refine ⟨fun p hp x hx => ?_, .cons hn hpw⟩ + subst hp + have hpn : Node.compareKey p n = .lt := by + simp only at hhead + revert hhead + cases Node.compareKey p n <;> intro h <;> first | rfl | exact absurd h (by decide) + rcases List.mem_cons.mp hx with rfl | hx + · exact hpn + · exact Std.TransCmp.lt_trans hpn (hn x hx) + +theorem keysIncreasing_nodup {ns : List Node} (h : keysIncreasing none ns = true) : ns.Nodup := by + have hpw := (keysIncreasing_pairwise ns none h).2 + refine hpw.imp ?_ + intro a b hab heq + subst heq + rw [Std.ReflCmp.compare_self (cmp := Node.compareKey)] at hab + cases hab + +theorem placeFold_spec : + ∀ (l : List (Nat × Node)) (canon : Array Nat) (out : Array Node), + (l.map (·.1)).Nodup → (∀ x ∈ l, x.1 < canon.size) → + (placeFold l (canon, out)).2 = out ++ (l.map (·.2)).toArray ∧ + (placeFold l (canon, out)).1.size = canon.size ∧ + (∀ t, t ∉ l.map (·.1) → (placeFold l (canon, out)).1[t]! = canon[t]!) ∧ + ∀ (i : Nat) (hi : i < l.length), (placeFold l (canon, out)).1[l[i].1]! = out.size + i := by + intro l + induction l with + | nil => intro canon out _ _; simp [placeFold] + | cons x rest ih => + intro canon out hnd hlt + obtain ⟨t, node⟩ := x + have hfold : placeFold ((t, node) :: rest) (canon, out) = + placeFold rest (canon.set! t out.size, out.push node) := rfl + simp only [List.map_cons, List.nodup_cons] at hnd + obtain ⟨htnot, hnd⟩ := hnd + have hlt' : ∀ y ∈ rest, y.1 < (canon.set! t out.size).size := by + intro y hy + simpa [Array.set!] using hlt y (List.mem_cons_of_mem _ hy) + obtain ⟨hout, hsize, hother, hpos⟩ := ih (canon.set! t out.size) (out.push node) hnd hlt' + have ht : t < canon.size := hlt (t, node) List.mem_cons_self + rw [hfold] + refine ⟨?_, by simp only [Array.set!] at hsize ⊢; rw [hsize]; simp, fun u hu => ?_, + fun i hi => ?_⟩ + · rw [hout] + simp + · simp only [List.map_cons, List.mem_cons, not_or] at hu + rw [hother u hu.2, setBang_getElem!, if_neg (by intro h; exact hu.1 h.1.symm)] + · cases i with + | zero => + simp only [List.getElem_cons_zero] + rw [hother t htnot, setBang_getElem!, if_pos ⟨rfl, ht⟩] + simp + | succ i => + simp only [List.getElem_cons_succ] + rw [hpos i (by simpa using hi)] + simp only [Array.size_push] + omega + +/-! ## One height group -/ + +/-- The key of node `t` under the canonical IDs `canon`, as `placeBucket` +builds it. -/ +def keyOf (temp : Array Node) (canon : Array Nat) (t : Nat) : Node := + { temp[t]! with children := (temp[t]!).children.map (canon[·]!) } + +/-- The key-sorted group of `placeBucket`. -/ +def sortedGroup (temp : Array Node) (canon : Array Nat) (bucket : Array Nat) : + List (Nat × Node) := + (bucket.toList.map fun t => (t, keyOf temp canon t)).mergeSort + fun x y => Node.compareKey x.2 y.2 != .gt + +theorem placeBucket_eq (temp : Array Node) (st : Array Nat × Array Node) (bucket : Array Nat) : + placeBucket temp st bucket = placeSorted (sortedGroup temp st.1 bucket) none st := rfl + +theorem sortedGroup_perm (temp : Array Node) (canon : Array Nat) (bucket : Array Nat) : + (sortedGroup temp canon bucket).Perm (bucket.toList.map fun t => (t, keyOf temp canon t)) := + List.mergeSort_perm _ _ + +theorem sortedGroup_nodes (temp : Array Node) (canon : Array Nat) (bucket : Array Nat) : + (sortedGroup temp canon bucket).map (·.2) = + (bucket.toList.map (keyOf temp canon)).mergeSort keyLe := by + unfold sortedGroup + rw [List.map_mergeSort (s := keyLe) (fun a _ b _ => keyLe_eq a.2 b.2), List.map_map] + rfl + +theorem sortedGroup_fst_perm (temp : Array Node) (canon : Array Nat) (bucket : Array Nat) : + ((sortedGroup temp canon bucket).map (·.1)).Perm bucket.toList := by + have := (sortedGroup_perm temp canon bucket).map (·.1) + rw [List.map_map] at this + have hid : List.map ((fun x : Nat × Node => x.fst) ∘ fun t => (t, keyOf temp canon t)) + bucket.toList = bucket.toList := by simp [Function.comp_def] + rw [hid] at this + exact this + +/-- Canonical IDs agree on corresponding nodes below height `h`, and the +outputs agree. -/ +def CanonInv (temp₁ temp₂ : Array Node) (roots₁ roots₂ : Array Nat) (h : Nat) + (st₁ st₂ : Array Nat × Array Node) : Prop := + st₁.2 = st₂.2 ∧ st₁.1.size = temp₁.size ∧ st₂.1.size = temp₂.size ∧ + ∀ t s, Corr temp₁ temp₂ roots₁ roots₂ t s → (nodeHeights temp₁)[t]! < h → + st₁.1[t]! = st₂.1[s]! + +/-- The `canonicalize` group of height `h`. -/ +def BucketAt (temp : Array Node) (roots : Array Nat) (h : Nat) (B : Array Nat) : Prop := + B.toList = (List.range temp.size).filter + (fun t => (reachMarks temp roots)[t]! && (nodeHeights temp)[t]! == h) + +theorem mem_bucket {temp : Array Node} {roots : Array Nat} (hrun : Run temp roots) {h : Nat} + {B : Array Nat} (hB : BucketAt temp roots h B) (t : Nat) : + t ∈ B.toList ↔ Reach temp roots t ∧ (nodeHeights temp)[t]! = h := by + unfold BucketAt at hB + rw [hB, List.mem_filter, List.mem_range, Bool.and_eq_true, beq_iff_eq] + constructor + · rintro ⟨ht, hr, hh⟩ + exact ⟨(reachMarks_spec hrun.cp hrun.inRange t ht).mp hr, hh⟩ + · rintro ⟨hr, hh⟩ + have ht := reach_lt hrun.cp hrun.inRange hr + exact ⟨ht, (reachMarks_spec hrun.cp hrun.inRange t ht).mpr hr, hh⟩ + +theorem bucket_nodup {temp : Array Node} {roots : Array Nat} {h : Nat} {B : Array Nat} + (hB : BucketAt temp roots h B) : B.toList.Nodup := by + unfold BucketAt at hB + rw [hB] + exact List.nodup_range.filter _ + +theorem corr_key (h₁ : Run temp₁ roots₁) (h₂ : Run temp₂ roots₂) {h : Nat} + {st₁ st₂ : Array Nat × Array Node} (hinv : CanonInv temp₁ temp₂ roots₁ roots₂ h st₁ st₂) + {t s : Nat} (hc : Corr temp₁ temp₂ roots₁ roots₂ t s) (ht : (nodeHeights temp₁)[t]! = h) : + keyOf temp₁ st₁.1 t = keyOf temp₂ st₂.1 s := by + obtain ⟨hhead, hsize, hk⟩ := corr_children h₁ h₂ hc + have htlt := reach_lt h₁.cp h₁.inRange hc.1 + unfold keyOf + simp only [Node.mk.injEq] + refine ⟨hhead, Array.ext (by simp [hsize]) fun k hk₁ hk₂ => ?_⟩ + simp only [Array.size_map] at hk₁ hk₂ + simp only [Array.getElem_map] + refine hinv.2.2.2 _ _ (hk k hk₁ hk₂) ?_ + have := child_height_lt temp₁ (nodeHeights temp₁) t _ (Array.getElem_mem hk₁) + rw [← nodeHeights_spec h₁.cp t htlt, ht] at this + exact this + +theorem nodup_map_on {α β : Type} {f : α → β} : + ∀ {l : List α}, (∀ x ∈ l, ∀ y ∈ l, f x = f y → x = y) → l.Nodup → (l.map f).Nodup + | [], _, _ => List.nodup_nil + | a :: l, H, d => by + rw [List.nodup_cons] at d + rw [List.map_cons, List.nodup_cons] + refine ⟨fun hm => ?_, nodup_map_on (fun x hx y hy => + H x (List.mem_cons_of_mem _ hx) y (List.mem_cons_of_mem _ hy)) d.2⟩ + obtain ⟨b, hb, hfb⟩ := List.mem_map.mp hm + have := H b (List.mem_cons_of_mem _ hb) a List.mem_cons_self hfb + subst this + exact d.1 hb + +theorem bucket_perm + (h₁ : Run temp₁ roots₁) (h₂ : Run temp₂ roots₂) + (hroots : roots₁.map (termOf temp₁) = roots₂.map (termOf temp₂)) {h : Nat} + {st₁ st₂ : Array Nat × Array Node} (hinv : CanonInv temp₁ temp₂ roots₁ roots₂ h st₁ st₂) + {B₁ B₂ : Array Nat} (hB₁ : BucketAt temp₁ roots₁ h B₁) (hB₂ : BucketAt temp₂ roots₂ h B₂) : + (B₂.toList.map (keyOf temp₂ st₂.1)).Perm (B₁.toList.map (keyOf temp₁ st₁.1)) := by + classical + let φ : Nat → Nat := fun t => + if hex : ∃ s, Corr temp₁ temp₂ roots₁ roots₂ t s then hex.choose else 0 + have hφ : ∀ t, Reach temp₁ roots₁ t → Corr temp₁ temp₂ roots₁ roots₂ t (φ t) := by + intro t ht + have hex := corr_total h₁ h₂ hroots ht + simp only [φ, dif_pos hex] + exact hex.choose_spec + have hnd : (B₁.toList.map φ).Nodup := by + refine nodup_map_on ?_ (bucket_nodup hB₁) + intro a ha b hb hab + have hca := hφ a ((mem_bucket h₁ hB₁ a).mp ha).1 + have hcb := hφ b ((mem_bucket h₁ hB₁ b).mp hb).1 + rw [hab] at hca + exact corr_inj h₁ hca hcb + have hperm : B₂.toList.Perm (B₁.toList.map φ) := by + rw [List.perm_ext_iff_of_nodup (bucket_nodup hB₂) hnd] + intro s + constructor + · intro hs + obtain ⟨hreach₂, hh₂⟩ := (mem_bucket h₂ hB₂ s).mp hs + obtain ⟨t, hct⟩ := corr_total h₂ h₁ hroots.symm hreach₂ + have hc := hct.symm + have hht : (nodeHeights temp₁)[t]! = h := by rw [corr_height h₁ h₂ t s hc, hh₂] + exact List.mem_map.mpr ⟨t, (mem_bucket h₁ hB₁ t).mpr ⟨hc.1, hht⟩, + corr_func h₂ (hφ t hc.1) hc⟩ + · intro hs + obtain ⟨t, ht, rfl⟩ := List.mem_map.mp hs + obtain ⟨hreach, hh⟩ := (mem_bucket h₁ hB₁ t).mp ht + have hc := hφ t hreach + exact (mem_bucket h₂ hB₂ _).mpr ⟨hc.2.1, by rw [← corr_height h₁ h₂ t _ hc, hh]⟩ + have := hperm.map (keyOf temp₂ st₂.1) + rw [List.map_map] at this + refine this.trans (List.Perm.of_eq ?_) + apply List.map_congr_left + intro t ht + obtain ⟨hreach, hh⟩ := (mem_bucket h₁ hB₁ t).mp ht + exact (corr_key h₁ h₂ hinv (hφ t hreach) hh).symm + +theorem sortedGroup_fst_lt {temp : Array Node} {roots : Array Nat} (hrun : Run temp roots) + {h : Nat} {B : Array Nat} (hB : BucketAt temp roots h B) (canon : Array Nat) + (hsize : canon.size = temp.size) : + ∀ x ∈ sortedGroup temp canon B, x.1 < canon.size := by + intro x hx + have hm : x.1 ∈ B.toList := + (sortedGroup_fst_perm temp canon B).subset (List.mem_map_of_mem hx) + rw [hsize] + exact reach_lt hrun.cp hrun.inRange ((mem_bucket hrun hB _).mp hm).1 + +theorem mem_sortedGroup (temp : Array Node) {B : Array Nat} (canon : Array Nat) {t : Nat} + (ht : t ∈ B.toList) : + ∃ (i : Nat) (hi : i < (sortedGroup temp canon B).length), + (sortedGroup temp canon B)[i] = (t, keyOf temp canon t) := by + have hm : (t, keyOf temp canon t) ∈ sortedGroup temp canon B := + (sortedGroup_perm temp canon B).symm.subset + (List.mem_map.mpr ⟨t, ht, rfl⟩) + obtain ⟨i, hi, he⟩ := List.mem_iff_getElem.mp hm + exact ⟨i, hi, he⟩ + +/-- One height group: both inputs fail with the same error, or both succeed +and the canonical IDs agree up to height `h + 1`. -/ +theorem bucket_step (h₁ : Run temp₁ roots₁) (h₂ : Run temp₂ roots₂) + (hroots : roots₁.map (termOf temp₁) = roots₂.map (termOf temp₂)) {h : Nat} + {B₁ B₂ : Array Nat} (hB₁ : BucketAt temp₁ roots₁ h B₁) (hB₂ : BucketAt temp₂ roots₂ h B₂) + {st₁ st₂ : Array Nat × Array Node} (hinv : CanonInv temp₁ temp₂ roots₁ roots₂ h st₁ st₂) : + (∃ e, placeBucket temp₁ st₁ B₁ = .error e ∧ placeBucket temp₂ st₂ B₂ = .error e) ∨ + ∃ st₁' st₂', placeBucket temp₁ st₁ B₁ = .ok st₁' ∧ placeBucket temp₂ st₂ B₂ = .ok st₂' ∧ + CanonInv temp₁ temp₂ roots₁ roots₂ (h + 1) st₁' st₂' := by + have hnodes : (sortedGroup temp₁ st₁.1 B₁).map (·.2) = (sortedGroup temp₂ st₂.1 B₂).map (·.2) := by + rw [sortedGroup_nodes, sortedGroup_nodes] + exact keySort_eq_of_perm (bucket_perm h₁ h₂ hroots hinv hB₁ hB₂).symm + rw [placeBucket_eq, placeBucket_eq, placeSorted_eq, placeSorted_eq, ← hnodes] + by_cases hk : keysIncreasing none ((sortedGroup temp₁ st₁.1 B₁).map (·.2)) = true + · right + rw [if_pos hk, if_pos hk] + refine ⟨_, _, rfl, rfl, ?_⟩ + obtain ⟨hout, hs₁, hs₂, hagree⟩ := hinv + obtain ⟨canon₁, out₁⟩ := st₁ + obtain ⟨canon₂, out₂⟩ := st₂ + simp only at hout hs₁ hs₂ hagree hk hnodes ⊢ + subst hout + have hnd := keysIncreasing_nodup hk + have hnd₁ : ((sortedGroup temp₁ canon₁ B₁).map (·.1)).Nodup := + (sortedGroup_fst_perm temp₁ canon₁ B₁).nodup_iff.mpr (bucket_nodup hB₁) + have hnd₂ : ((sortedGroup temp₂ canon₂ B₂).map (·.1)).Nodup := + (sortedGroup_fst_perm temp₂ canon₂ B₂).nodup_iff.mpr (bucket_nodup hB₂) + obtain ⟨ho₁, hz₁, hu₁, hp₁⟩ := placeFold_spec _ canon₁ out₁ hnd₁ + (sortedGroup_fst_lt h₁ hB₁ canon₁ hs₁) + obtain ⟨ho₂, hz₂, hu₂, hp₂⟩ := placeFold_spec _ canon₂ out₁ hnd₂ + (sortedGroup_fst_lt h₂ hB₂ canon₂ hs₂) + refine ⟨by rw [ho₁, ho₂, hnodes], by rw [hz₁, hs₁], by rw [hz₂, hs₂], ?_⟩ + intro t s hc hlt + have hhs : (nodeHeights temp₂)[s]! = (nodeHeights temp₁)[t]! := + (corr_height h₁ h₂ t s hc).symm + by_cases hlow : (nodeHeights temp₁)[t]! < h + · have ht : t ∉ (sortedGroup temp₁ canon₁ B₁).map (·.1) := by + intro hm + have := ((mem_bucket h₁ hB₁ t).mp + ((sortedGroup_fst_perm temp₁ canon₁ B₁).subset hm)).2 + omega + have hs : s ∉ (sortedGroup temp₂ canon₂ B₂).map (·.1) := by + intro hm + have := ((mem_bucket h₂ hB₂ s).mp + ((sortedGroup_fst_perm temp₂ canon₂ B₂).subset hm)).2 + omega + rw [hu₁ t ht, hu₂ s hs] + exact hagree t s hc hlow + · have hth : (nodeHeights temp₁)[t]! = h := by omega + obtain ⟨i, hi, hgi⟩ := mem_sortedGroup temp₁ canon₁ + ((mem_bucket h₁ hB₁ t).mpr ⟨hc.1, hth⟩) + obtain ⟨j, hj, hgj⟩ := mem_sortedGroup temp₂ canon₂ + ((mem_bucket h₂ hB₂ s).mpr ⟨hc.2.1, by rw [hhs, hth]⟩) + have hkey := corr_key (st₁ := (canon₁, out₁)) (st₂ := (canon₂, out₁)) h₁ h₂ + ⟨rfl, hs₁, hs₂, hagree⟩ hc hth + simp only at hkey + have hij : i = j := by + have hni : ((sortedGroup temp₁ canon₁ B₁).map (·.2))[i]'(by simpa using hi) = + keyOf temp₁ canon₁ t := by simp [hgi] + have hnj : ((sortedGroup temp₂ canon₂ B₂).map (·.2))[j]'(by simpa using hj) = + keyOf temp₂ canon₂ s := by simp [hgj] + have hj' : j < ((sortedGroup temp₁ canon₁ B₁).map (·.2)).length := by + rw [hnodes]; simpa using hj + have : ((sortedGroup temp₁ canon₁ B₁).map (·.2))[i]'(by simpa using hi) = + ((sortedGroup temp₁ canon₁ B₁).map (·.2))[j]'hj' := by + rw [hni, hkey, ← hnj] + simp only [hnodes] + exact (List.getElem_inj hnd).mp this + subst hij + have e₁ := hp₁ i hi + have e₂ := hp₂ i hj + rw [hgi] at e₁ + rw [hgj] at e₂ + simp only at e₁ e₂ + rw [e₁, e₂] + · left + rw [if_neg hk, if_neg hk] + exact ⟨_, rfl, rfl⟩ + +/-! ## All height groups -/ + +theorem foldlM_sim {σ₁ σ₂ ε : Type} (f₁ : σ₁ → Nat → Except ε σ₁) (f₂ : σ₂ → Nat → Except ε σ₂) + (Inv : Nat → σ₁ → σ₂ → Prop) (bound : Nat) + (hstep : ∀ h st₁ st₂, h < bound → Inv h st₁ st₂ → + (∃ e, f₁ st₁ h = .error e ∧ f₂ st₂ h = .error e) ∨ + ∃ st₁' st₂', f₁ st₁ h = .ok st₁' ∧ f₂ st₂ h = .ok st₂' ∧ Inv (h + 1) st₁' st₂') : + ∀ (k a : Nat) (st₁ : σ₁) (st₂ : σ₂), a + k ≤ bound → Inv a st₁ st₂ → + (∃ e, (List.range' a k).foldlM f₁ st₁ = .error e ∧ + (List.range' a k).foldlM f₂ st₂ = .error e) ∨ + ∃ st₁' st₂', (List.range' a k).foldlM f₁ st₁ = .ok st₁' ∧ + (List.range' a k).foldlM f₂ st₂ = .ok st₂' ∧ Inv (a + k) st₁' st₂' := by + intro k + induction k with + | zero => + intro a st₁ st₂ _ hinv + exact Or.inr ⟨st₁, st₂, rfl, rfl, by simpa using hinv⟩ + | succ k ih => + intro a st₁ st₂ hle hinv + rw [List.range'_succ, List.foldlM_cons, List.foldlM_cons] + rcases hstep a st₁ st₂ (by omega) hinv with ⟨e, he₁, he₂⟩ | ⟨st₁', st₂', hs₁, hs₂, hinv'⟩ + · left + rw [he₁, he₂] + exact ⟨e, rfl, rfl⟩ + · rw [hs₁, hs₂] + have := ih (a + 1) st₁' st₂' (by omega) hinv' + rw [show a + 1 + k = a + (k + 1) by omega] at this + exact this + +theorem maxHeight_le (h₁ : Run temp₁ roots₁) (h₂ : Run temp₂ roots₂) + (hroots : roots₁.map (termOf temp₁) = roots₂.map (termOf temp₂)) : + maxHeight (reachMarks temp₁ roots₁) (nodeHeights temp₁) temp₁.size ≤ + maxHeight (reachMarks temp₂ roots₂) (nodeHeights temp₂) temp₂.size := by + rcases (maxHeight_spec (reachMarks temp₁ roots₁) (nodeHeights temp₁) temp₁.size).2 with + h0 | ⟨t, ht, hr, he⟩ + · rw [h0]; exact Nat.zero_le _ + · have hreach := (reachMarks_spec h₁.cp h₁.inRange t ht).mp hr + obtain ⟨s, hc⟩ := corr_total h₁ h₂ hroots hreach + have hs := reach_lt h₂.cp h₂.inRange hc.2.1 + have hs' := (reachMarks_spec h₂.cp h₂.inRange s hs).mpr hc.2.1 + rw [← he, corr_height h₁ h₂ t s hc] + exact (maxHeight_spec _ _ _).1 s hs hs' + +/-- `canonicalize` on an input that passes its checks. -/ +theorem canonicalize_eq {temp : Array Node} {roots : Array Nat} (hrun : Run temp roots) : + canonicalize temp roots = + ((List.range (maxHeight (reachMarks temp roots) (nodeHeights temp) temp.size + 1)).foldlM + (fun st h => placeBucket temp st + (heightBuckets (reachMarks temp roots) (nodeHeights temp) + (maxHeight (reachMarks temp roots) (nodeHeights temp) temp.size) temp.size)[h]!) + (Array.replicate temp.size 0, #[])) >>= fun st => + pure ((⟨st.2⟩ : Dag), roots.map (st.1[·]!)) := by + have hall : roots.all (· < temp.size) = true := by + rw [Array.all_eq_true] + intro i hi + simpa using hrun.inRange _ (Array.getElem_mem hi) + unfold canonicalize + simp only [hrun.precede, hall, ↓reduceIte] + rfl + +/-- **ID determinism of `canonicalize`.** Two inputs that pass the +interner's checks (children precede parents, arity, roots in range) and are +hash-consed, whose roots denote the same terms, canonicalize to the same DAG +and root IDs: the canonical IDs depend only on the root terms, not on the +temporary IDs or on unreachable nodes. -/ +theorem canonicalize_det (h₁ : Run temp₁ roots₁) (h₂ : Run temp₂ roots₂) + (hroots : roots₁.map (termOf temp₁) = roots₂.map (termOf temp₂)) : + canonicalize temp₁ roots₁ = canonicalize temp₂ roots₂ := by + have hM : maxHeight (reachMarks temp₁ roots₁) (nodeHeights temp₁) temp₁.size = + maxHeight (reachMarks temp₂ roots₂) (nodeHeights temp₂) temp₂.size := + Nat.le_antisymm (maxHeight_le h₁ h₂ hroots) (maxHeight_le h₂ h₁ hroots.symm) + have hle₁ := (maxHeight_spec (reachMarks temp₁ roots₁) (nodeHeights temp₁) temp₁.size).1 + have hle₂ := (maxHeight_spec (reachMarks temp₂ roots₂) (nodeHeights temp₂) temp₂.size).1 + rw [canonicalize_eq h₁, canonicalize_eq h₂, ← hM] + rw [← hM] at hle₂ + generalize maxHeight (reachMarks temp₁ roots₁) (nodeHeights temp₁) temp₁.size = M at hle₁ hle₂ ⊢ + rw [List.range_eq_range'] + have hstep : ∀ h st₁ st₂, h < M + 1 → CanonInv temp₁ temp₂ roots₁ roots₂ h st₁ st₂ → + (∃ e, placeBucket temp₁ st₁ (heightBuckets (reachMarks temp₁ roots₁) + (nodeHeights temp₁) M temp₁.size)[h]! = .error e ∧ + placeBucket temp₂ st₂ (heightBuckets (reachMarks temp₂ roots₂) + (nodeHeights temp₂) M temp₂.size)[h]! = .error e) ∨ + ∃ st₁' st₂', placeBucket temp₁ st₁ (heightBuckets (reachMarks temp₁ roots₁) + (nodeHeights temp₁) M temp₁.size)[h]! = .ok st₁' ∧ + placeBucket temp₂ st₂ (heightBuckets (reachMarks temp₂ roots₂) + (nodeHeights temp₂) M temp₂.size)[h]! = .ok st₂' ∧ + CanonInv temp₁ temp₂ roots₁ roots₂ (h + 1) st₁' st₂' := by + intro h st₁ st₂ hh hinv + exact bucket_step h₁ h₂ hroots + ((heightBuckets_spec _ _ M temp₁.size hle₁).2 h (by omega)) + ((heightBuckets_spec _ _ M temp₂.size hle₂).2 h (by omega)) hinv + have hinit : CanonInv temp₁ temp₂ roots₁ roots₂ 0 (Array.replicate temp₁.size 0, #[]) + (Array.replicate temp₂.size 0, #[]) := + ⟨rfl, by simp, by simp, fun _ _ _ h => absurd h (Nat.not_lt_zero _)⟩ + rcases foldlM_sim _ _ _ (M + 1) hstep (M + 1) 0 _ _ (by omega) hinit with + ⟨e, he₁, he₂⟩ | ⟨st₁, st₂, hs₁, hs₂, hinv⟩ + · rw [he₁, he₂] + rfl + · rw [hs₁, hs₂] + obtain ⟨hout, _, _, hagree⟩ := hinv + have hsz : roots₁.size = roots₂.size := by simpa using congrArg Array.size hroots + have hroots' : roots₁.map (st₁.1[·]!) = roots₂.map (st₂.1[·]!) := by + apply Array.ext (by simp [hsz]) + intro i hi₁ hi₂ + simp only [Array.size_map] at hi₁ hi₂ + simp only [Array.getElem_map] + have hterm := congrArg (·[i]?) hroots + simp only [Array.getElem?_map, Array.getElem?_eq_getElem hi₁, + Array.getElem?_eq_getElem hi₂, Option.map_some, Option.some.injEq] at hterm + have hc : Corr temp₁ temp₂ roots₁ roots₂ roots₁[i] roots₂[i] := + ⟨.root (Array.getElem_mem hi₁), .root (Array.getElem_mem hi₂), hterm⟩ + have hlt := reach_lt h₁.cp h₁.inRange hc.1 + have hmark := (reachMarks_spec h₁.cp h₁.inRange _ hlt).mpr hc.1 + exact hagree _ _ hc (by have := hle₁ _ hlt hmark; omega) + change (pure ((⟨st₁.2⟩ : Dag), roots₁.map (st₁.1[·]!)) : Except SharingError _) = + pure ((⟨st₂.2⟩ : Dag), roots₂.map (st₂.1[·]!)) + rw [hout, hroots'] + +end Canon + +end Ix.Compile.Verify.SharingExact diff --git a/Ix/Compile/Verify/SharingExactPasses.lean b/Ix/Compile/Verify/SharingExactPasses.lean new file mode 100644 index 000000000..6622b091f --- /dev/null +++ b/Ix/Compile/Verify/SharingExactPasses.lean @@ -0,0 +1,762 @@ +import Ix.Compile.Verify.SharingExact + +/-! +# Exact sharing: tie order and table materialization + +* The uniform optimizer's tie order `setPrec` is a strict total order. +* Loop-level backwardness and expansion correctness of `materializeTable` + (each entry built against the dictionary of the entries before it) and of + `Prep.materializeDependent` (one dictionary, table in dependency order): + entry `k` only references Share indices below `k`, the roots only indices + below the table size (the Share part of `DecodeCtx.SharingWF`), and every + output expands to its term. +-/ + +namespace Ix.Compile.Verify.SharingExact + +open Ix.Sharing.Exact + +/-! ## The uniform tie order -/ + +section TieOrder + +instance compareDesc_trans : Std.TransCmp compareDesc := + inferInstanceAs (Std.TransCmp fun x y : Nat => compare y x) + +instance compareDesc_lawfulEq : Std.LawfulEqCmp compareDesc := + inferInstanceAs (Std.LawfulEqCmp fun x y : Nat => compare y x) + +theorem setPrec_iff (a b : Array Nat) : + setPrec a b = true ↔ Array.compareLex compareDesc a b = .lt := by + unfold setPrec + cases Array.compareLex compareDesc a b <;> decide + +/-- `setPrec` is irreflexive. -/ +theorem setPrec_irrefl (a : Array Nat) : setPrec a a = false := by + unfold setPrec + rw [Std.ReflCmp.compare_self (cmp := Array.compareLex compareDesc)] + rfl + +/-- `setPrec` is asymmetric. -/ +theorem setPrec_asymm {a b : Array Nat} (h : setPrec a b = true) : setPrec b a = false := by + rw [setPrec_iff] at h + unfold setPrec + rw [Std.OrientedCmp.eq_swap (cmp := Array.compareLex compareDesc), h] + rfl + +/-- `setPrec` is transitive. -/ +theorem setPrec_trans {a b c : Array Nat} (h₁ : setPrec a b = true) + (h₂ : setPrec b c = true) : setPrec a c = true := by + rw [setPrec_iff] at * + exact Std.TransCmp.lt_trans h₁ h₂ + +/-- `setPrec` is total on distinct arrays. -/ +theorem setPrec_total {a b : Array Nat} (h : a ≠ b) : + setPrec a b = true ∨ setPrec b a = true := by + rw [setPrec_iff, setPrec_iff] + cases hc : Array.compareLex compareDesc a b + · exact Or.inl rfl + · exact absurd (Std.LawfulEqCmp.eq_of_compare hc) h + · right + rw [Std.OrientedCmp.eq_swap (cmp := Array.compareLex compareDesc), hc] + rfl + +end TieOrder + +/-! ## Helpers -/ + +section Helpers + +theorem SharesIn.mono {P Q : Nat → Prop} (hPQ : ∀ i, P i → Q i) (e : Ixon.Expr) + (h : SharesIn P e) : SharesIn Q e := by + induction e with + | share i => exact hPQ _ h + | prj _ _ v ih => exact ih h + | app f a ihf iha => exact ⟨ihf h.1, iha h.2⟩ + | lam _ t b iht ihb => exact ⟨iht h.1, ihb h.2⟩ + | all _ _ t b iht ihb => exact ⟨iht h.1, ihb h.2⟩ + | letE _ t v b iht ihv ihb => exact ⟨iht h.1, ihv h.2.1, ihb h.2.2⟩ + | _ => trivial + +theorem foldl_some_mem {α : Type} (f : Option α → α → Option α) + (hf : ∀ b o r, f b o = some r → r = o ∨ b = some r) : + ∀ (l : List α) (init : Option α) (r : α), + l.foldl f init = some r → r ∈ l ∨ init = some r := by + intro l + induction l with + | nil => intro init r h; exact Or.inr h + | cons x xs ih => + intro init r h + rcases ih (f init x) r h with hm | hm + · exact Or.inl (List.mem_cons_of_mem x hm) + · rcases hf init x r hm with rfl | h' + · exact Or.inl List.mem_cons_self + · exact Or.inr h' + +/-- `pickOption` picks one of the offered options. -/ +theorem pickOption_mem (opts : Array (Choice × Nat × ByteArray)) {ch : Choice} {c : Nat} + (h : pickOption opts = some (ch, c)) : ∃ b, (ch, c, b) ∈ opts.toList := by + unfold pickOption at h + rw [← Array.foldl_toList] at h + cases hr : List.foldl _ none opts.toList with + | none => rw [hr] at h; cases h + | some o => + rw [hr] at h + obtain ⟨ch', c', b'⟩ := o + simp only [Option.map_some, Option.some.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + refine ⟨b', ?_⟩ + have key := foldl_some_mem _ (by + intro b o r hb + cases b with + | none => simp only [Option.some.injEq] at hb; exact Or.inl hb.symm + | some b => + simp only at hb + split at hb + · simp only [Option.some.injEq] at hb; exact Or.inl hb.symm + · split at hb + · simp only [Option.some.injEq] at hb; exact Or.inl hb.symm + · exact Or.inr hb) _ _ _ hr + rcases key with hm | hm + · exact hm + · cases hm + +/-- With the `Share` options filtered out, the pick is not a `Share`. -/ +theorem pickOption_filter_ne_share (opts : Array (Choice × Nat × ByteArray)) + {ch : Choice} {c : Nat} + (h : pickOption (opts.filter (·.1 != .share)) = some (ch, c)) : ch ≠ .share := by + obtain ⟨b, hb⟩ := pickOption_mem _ h + rw [Array.toList_filter, List.mem_filter] at hb + intro hch + subst hch + have h2 : ((Choice.share, c, b).1 != Choice.share) = false := rfl + rw [h2] at hb + exact Bool.false_ne_true hb.2 + +end Helpers + +/-! ## Descendants in the DAG -/ + +section Desc + +/-- Every node has exactly `head.arity` children (the interner's arity +invariant). -/ +def DagArity (dag : Dag) : Prop := + ∀ t, (dag.node t).children.size = (dag.node t).head.arity + +/-- `u` is `t` or lies below it through child edges. -/ +inductive Desc (dag : Dag) : Nat → Nat → Prop + | refl (t : Nat) : Desc dag t t + | child {t u : Nat} (k : Nat) (hk : k < (dag.node t).children.size) + (h : Desc dag ((dag.node t).child k) u) : Desc dag t u + +/-- `u` lies strictly below `t`. -/ +def Below (dag : Dag) (t u : Nat) : Prop := + ∃ k, k < (dag.node t).children.size ∧ Desc dag ((dag.node t).child k) u + +theorem Below.desc {dag : Dag} {t u : Nat} (h : Below dag t u) : Desc dag t u := + let ⟨k, hk, hd⟩ := h + .child k hk hd + +theorem Desc.trans {dag : Dag} {t v u : Nat} (h₁ : Desc dag t v) (h₂ : Desc dag v u) : + Desc dag t u := by + induction h₁ with + | refl => exact h₂ + | child k hk _ ih => exact .child k hk (ih h₂) + +theorem Below.trans_desc {dag : Dag} {t v u : Nat} (h₁ : Below dag t v) (h₂ : Desc dag v u) : + Below dag t u := + let ⟨k, hk, hd⟩ := h₁ + ⟨k, hk, hd.trans h₂⟩ + +theorem Desc.trans_below {dag : Dag} {t v u : Nat} (h₁ : Desc dag t v) (h₂ : Below dag v u) : + Below dag t u := by + cases h₁ with + | refl => exact h₂ + | child k hk hd => exact ⟨k, hk, hd.trans h₂.desc⟩ + +theorem below_child {dag : Dag} {t k : Nat} (hk : k < (dag.node t).children.size) : + Below dag t ((dag.node t).child k) := + ⟨k, hk, .refl _⟩ + +/-- A telescope node. -/ +def IsSpine (n : Node) : Prop := + match n.head with + | .app | .lam _ | .all .. => True + | _ => False + +theorem spine_children {dag : Dag} (harity : DagArity dag) (v : Nat) + (hs : IsSpine (dag.node v)) : + Below dag v (dag.node v).spineNext ∧ Below dag v (dag.node v).sideChild := by + have ha := harity v + unfold IsSpine at hs + unfold Node.spineNext Node.sideChild + cases hh : (dag.node v).head <;> simp only [hh, Head.arity] at ha hs ⊢ <;> + first | exact hs.elim | exact ⟨below_child (by omega), below_child (by omega)⟩ + +theorem spineFold_spine (buildSide : Node → Except SharingError Ixon.Expr) : + ∀ (ns : List Node) (tail res : Ixon.Expr), + ns.foldrM (fun n acc => do let side ← buildSide n; rebuildSpineNode n acc side) tail = + .ok res → ∀ n ∈ ns, IsSpine n := by + intro ns + induction ns with + | nil => intro _ _ _ n hn; cases hn + | cons m ns ih => + intro tail res h n hn + rw [List.foldrM_cons] at h + obtain ⟨acc, hacc, hstep⟩ := bind_eq_ok h + obtain ⟨side, _, hre⟩ := bind_eq_ok hstep + rcases List.mem_cons.mp hn with rfl | hn + · unfold IsSpine + cases hh : n.head <;> simp only [rebuildSpineNode, hh] at hre <;> first | trivial | cases hre + · exact ih tail acc hacc n hn + +theorem spineFold_shares_mem (P : Nat → Prop) + (buildSide : Node → Except SharingError Ixon.Expr) : + ∀ (ns : List Node) (tail res : Ixon.Expr), + (∀ n ∈ ns, ∀ e, buildSide n = .ok e → SharesIn P e) → SharesIn P tail → + ns.foldrM (fun n acc => do let side ← buildSide n; rebuildSpineNode n acc side) tail = + .ok res → SharesIn P res := by + intro ns + induction ns with + | nil => intro tail res _ ht h; simp only [List.foldrM_nil] at h; cases h; exact ht + | cons n ns ih => + intro tail res hside ht h + rw [List.foldrM_cons] at h + obtain ⟨acc, hacc, hstep⟩ := bind_eq_ok h + have hinner := ih tail acc (fun m hm => hside m (List.mem_cons_of_mem n hm)) ht hacc + obtain ⟨side, hs, hre⟩ := bind_eq_ok hstep + have hside' := hside n List.mem_cons_self side hs + cases hh : n.head <;> simp only [rebuildSpineNode, hh] at hre <;> cases hre <;> + exact ⟨by assumption, by assumption⟩ + +/-- The nodes collected by a walk of telescope nodes lie on the walk below +`t`, and a nonempty walk ends strictly below `t`. -/ +theorem spineWalk_desc (p : Prep) (harity : DagArity p.dag) : + ∀ (j t : Nat), (∀ n ∈ (p.spineWalk j t).1, IsSpine n) → + (∀ n ∈ (p.spineWalk j t).1, ∃ v, Desc p.dag t v ∧ n = p.dag.node v) ∧ + (0 < j → Below p.dag t (p.spineWalk j t).2) ∧ Desc p.dag t (p.spineWalk j t).2 := by + intro j + induction j with + | zero => + intro t _ + refine ⟨fun n hn => ?_, fun h => absurd h (Nat.lt_irrefl 0), Desc.refl t⟩ + simp [Prep.spineWalk] at hn + | succ j ih => + intro t hs + simp only [Prep.spineWalk] at hs ⊢ + have hst : IsSpine (p.dag.node t) := hs _ List.mem_cons_self + have hnext := (spine_children harity t hst).1 + obtain ⟨hns, _, hend⟩ := ih (p.dag.node t).spineNext + (fun n hn => hs n (List.mem_cons_of_mem _ hn)) + refine ⟨?_, fun _ => hnext.trans_desc hend, hnext.desc.trans hend⟩ + intro n hn + rcases List.mem_cons.mp hn with rfl | hn + · exact ⟨t, .refl t, rfl⟩ + · obtain ⟨v, hv, rfl⟩ := hns n hn + exact ⟨v, hnext.desc.trans hv, rfl⟩ + +end Desc + +/-! ## Descendant-tracking build -/ + +section Build + +/-- `Share(i)` names a dictionary term that is `t` itself (only outside an +entry body) or lies strictly below `t`. -/ +def ShareFrom (dag : Dag) (index : Array (Option Nat)) (entry : Bool) (t i : Nat) : Prop := + ∃ u, index[u]?.getD none = some i ∧ ((entry = false ∧ u = t) ∨ Below dag t u) + +theorem shareFrom_lift {dag : Dag} {index : Array (Option Nat)} {entry : Bool} {t c : Nat} + (hc : Below dag t c) (i : Nat) (h : ShareFrom dag index false c i) : + ShareFrom dag index entry t i := by + obtain ⟨u, hu, hor⟩ := h + refine ⟨u, hu, Or.inr ?_⟩ + rcases hor with ⟨_, rfl⟩ | hb + · exact hc + · exact hc.trans_desc hb.desc + +/-- Every `Share` emitted while building `t` names a dictionary term below +`t`, or `t` itself when `t` is not being built as its own entry body. -/ +theorem build_shares_below (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (harity : DagArity p.dag) + (hidx : ∀ (u i : Nat), index[u]?.getD none = some i → i < UInt64.size) : + ∀ (fuel : Nat) (entry : Bool) (t : Nat) (e : Ixon.Expr), + p.build ev index width entry fuel t = .ok e → + SharesIn (ShareFrom p.dag index entry t) e := by + intro fuel + induction fuel with + | zero => intro entry t e h; simp [Prep.build] at h + | succ fuel ih => + intro entry t e h + have lift : ∀ c e', Below p.dag t c → p.build ev index width false fuel c = .ok e' → + SharesIn (ShareFrom p.dag index entry t) e' := fun c e' hc h' => + SharesIn.mono (shareFrom_lift hc) _ (ih false c e' h') + have hshare : ∀ u i, index[u]?.getD none = some i → + ((entry = false ∧ u = t) ∨ Below p.dag t u) → + SharesIn (ShareFrom p.dag index entry t) (.share i.toUInt64) := by + intro u i hi hu + simp only [SharesIn, toNat_toUInt64_of_lt (hidx u i hi)] + exact ⟨u, hi, hu⟩ + have ha := harity t + simp only [Prep.build] at h + split at h + · rename_i choice c hpick + split at h + · split at h + · -- Share + split at h + · rename_i i hi + cases h + refine hshare t i hi (Or.inl ⟨?_, rfl⟩) + cases entry + · rfl + · exact absurd rfl (pickOption_filter_ne_share _ (by simpa using hpick)) + · cases h + · -- inline node + cases hh : (p.dag.node t).head <;> simp only [hh] at h + case prj ti f => + obtain ⟨v, hv, hpure⟩ := bind_eq_ok h + cases hpure + exact lift _ v (below_child (by rw [ha, hh]; simp [Head.arity])) hv + case letE lc => + obtain ⟨ty, hty, h2⟩ := bind_eq_ok h + obtain ⟨v, hv, h3⟩ := bind_eq_ok h2 + obtain ⟨b, hb, hpure⟩ := bind_eq_ok h3 + cases hpure + exact ⟨lift _ ty (below_child (by rw [ha, hh]; simp [Head.arity])) hty, + lift _ v (below_child (by rw [ha, hh]; simp [Head.arity])) hv, + lift _ b (below_child (by rw [ha, hh]; simp [Head.arity])) hb⟩ + all_goals first + | (cases h; simp only [SharesIn, Node.toExpr, hh]) + | cases h + · -- telescope cut + split at h + · cases h + rename_i hj0 + split at h + · split at h + · rename_i i hi + simp only [pure_bind] at h + have hsp := spineFold_spine _ _ _ _ h + obtain ⟨hns, hcur, -⟩ := spineWalk_desc p harity _ t hsp + refine spineFold_shares_mem _ _ _ _ _ ?_ + (hshare _ i hi (Or.inr (hcur (Nat.pos_of_ne_zero hj0)))) h + intro n hn e' he' + obtain ⟨v, hv, rfl⟩ := hns n hn + exact lift _ e' (hv.trans_below (spine_children harity v (hsp _ hn)).2) he' + · cases h + · obtain ⟨tail, htail, hfold⟩ := bind_eq_ok h + have hsp := spineFold_spine _ _ _ _ hfold + obtain ⟨hns, hcur, -⟩ := spineWalk_desc p harity _ t hsp + refine spineFold_shares_mem _ _ _ _ _ ?_ + (lift _ tail (hcur (Nat.pos_of_ne_zero hj0)) htail) hfold + intro n hn e' he' + obtain ⟨v, hv, rfl⟩ := hns n hn + exact lift _ e' (hv.trans_below (spine_children harity v (hsp _ hn)).2) he' + · cases h + · cases h + +end Build + +/-! ## Dictionaries and lists -/ + +section Dictionaries + +theorem indexOfPairs_mem (size : Nat) (pairs : List (Nat × Nat)) : + ∀ (u i : Nat), (indexOfPairs size pairs)[u]?.getD none = some i → (u, i) ∈ pairs := by + unfold indexOfPairs + suffices hs : ∀ (l : List (Nat × Nat)) (acc : Array (Option Nat)), (∀ x ∈ l, x ∈ pairs) → + (∀ (u i : Nat), acc[u]?.getD none = some i → (u, i) ∈ pairs) → + ∀ (u i : Nat), (l.foldl (fun acc (t, i) => acc.set! t (some i)) acc)[u]?.getD none = + some i → (u, i) ∈ pairs by + refine hs pairs _ (fun x hx => hx) (fun u i hu => ?_) + simp only [Array.getElem?_replicate] at hu + split at hu <;> simp at hu + intro l + induction l with + | nil => intro acc _ hacc; simpa using hacc + | cons x xs ih => + intro acc hl hacc + rw [List.foldl_cons] + apply ih _ (fun y hy => hl y (List.mem_cons_of_mem x hy)) + intro u i hu + obtain ⟨t, j⟩ := x + simp only [Array.set!, Array.getElem?_setIfInBounds] at hu + split at hu + · rename_i htu + split at hu + · simp only [Option.getD_some, Option.some.injEq] at hu + subst hu htu + exact hl _ List.mem_cons_self + · simp at hu + · exact hacc u i hu + +/-- The dictionary of the first `k` entries maps `u` to `i` only if entry +`i < k` is `u`. -/ +theorem indexOfPrefix_spec (size : Nat) (table : Array Nat) (k u i : Nat) + (h : (indexOfPrefix size table k)[u]?.getD none = some i) : + i < k ∧ table[i]? = some u := by + have hm := indexOfPairs_mem size _ u i h + rw [List.mem_zipIdx_iff_getElem?] at hm + simp only [List.getElem?_take] at hm + split at hm + · rename_i hik + refine ⟨hik, ?_⟩ + simpa using hm + · cases hm + +/-- The dictionary of a whole table maps `u` to `i` only if entry `i` is `u`. -/ +theorem indexOfTable_spec (size : Nat) (table : Array Nat) (u i : Nat) + (h : (indexOfPairs size table.toList.zipIdx)[u]?.getD none = some i) : + table[i]? = some u := by + have hm := indexOfPairs_mem size _ u i h + rw [List.mem_zipIdx_iff_getElem?] at hm + simpa using hm + +theorem forall₂_getElem {α β : Type} {R : α → β → Prop} : + ∀ {xs : List α} {ys : List β}, List.Forall₂ R xs ys → + xs.length = ys.length ∧ + ∀ (k : Nat) (h₁ : k < xs.length) (h₂ : k < ys.length), R xs[k] ys[k] + | _, _, .nil => ⟨rfl, fun _ h => absurd h (Nat.not_lt_zero _)⟩ + | _, _, .cons hr hs => by + obtain ⟨hl, hk⟩ := forall₂_getElem hs + refine ⟨by simp [hl], fun k h₁ h₂ => ?_⟩ + cases k with + | zero => exact hr + | succ k => exact hk k (by simpa using h₁) (by simpa using h₂) + +theorem forall₂_mem_right {α β : Type} {R : α → β → Prop} : + ∀ {xs : List α} {ys : List β}, List.Forall₂ R xs ys → ∀ y ∈ ys, ∃ x, R x y + | _, _, .nil => fun _ h => by cases h + | _, _, .cons hr hs => fun y hy => by + rcases List.mem_cons.mp hy with rfl | hy + · exact ⟨_, hr⟩ + · exact forall₂_mem_right hs y hy + +theorem array_mapM_forall₂ {α β ε : Type} (f : α → Except ε β) (xs : Array α) (ys : Array β) + (h : xs.mapM f = .ok ys) : List.Forall₂ (fun x y => f x = .ok y) xs.toList ys.toList := by + rw [Array.mapM_eq_mapM_toList] at h + cases hm : List.mapM f xs.toList with + | error err => rw [hm] at h; cases h + | ok l => + rw [hm] at h + have : ys = l.toArray := by cases h; rfl + subst this + exact mapM_ok_forall₂ f _ _ hm + +end Dictionaries + +/-! ## Table materialization -/ + +section Table + +/-- A successful `materializeWith` builds every target standalone. -/ +theorem materializeWith_forall₂ (p : Prep) (index width : Array (Option Nat)) + (targets : Array Nat) (limits : Limits) {out : Array Ixon.Expr} {cost : Array Nat} + {work : Nat} (h : p.materializeWith index width targets limits = .ok (out, cost, work)) : + List.Forall₂ (fun t e => + p.build (p.evalAll width) index width false (p.dag.size + 1) t = .ok e) + targets.toList out.toList := by + unfold Prep.materializeWith at h + obtain ⟨_, _, h⟩ := bind_eq_ok h + simp only at h + split at h + · cases h + · obtain ⟨out', hout, hret⟩ := bind_eq_ok h + cases hret + exact array_mapM_forall₂ _ _ _ hout + +/-- An invariant of a counted `foldlM` loop over `0, …, m − 1`. -/ +theorem foldlM_range_inv {σ ε : Type} (f : σ → Nat → Except ε σ) (I : Nat → σ → Prop) + (hstep : ∀ i s s', I i s → f s i = .ok s' → I (i + 1) s') : + ∀ (m : Nat) (s0 s : σ), I 0 s0 → (List.range m).foldlM f s0 = .ok s → I m s := by + intro m + induction m with + | zero => intro s0 s h0 h; simp only [List.range_zero, List.foldlM_nil] at h; cases h; exact h0 + | succ m ih => + intro s0 s h0 h + rw [List.range_succ, List.foldlM_append] at h + obtain ⟨s1, h1, h⟩ := bind_eq_ok h + simp only [List.foldlM_cons, List.foldlM_nil] at h + obtain ⟨s2, h2, h⟩ := bind_eq_ok h + simp only [pure, Except.pure, Except.ok.injEq] at h + subst h + exact hstep m s1 _ (ih s0 s1 h0 h1) h2 + +/-- One table step: the entry is built against the current dictionary, which +then gains the entry. -/ +theorem materializeStep_spec {p : Prep} {table : Array Nat} {limits : Limits} + {widthAt : Nat → Nat} {st st' : TableState} {i : Nat} + (h : materializeStep p table limits widthAt st i = .ok st') : + ∃ e, p.build st.ev st.index st.width false (p.dag.size + 1) table[i]! = .ok e ∧ + st'.entries = st.entries.push e ∧ + st'.index = st.index.set! table[i]! (some i) ∧ + st'.width = st.width.set! table[i]! (some (widthAt i)) ∧ + st'.ev = p.evalUp st.ev (st.width.set! table[i]! (some (widthAt i))) table[i]! ∧ + st'.predicted = st.predicted + st.ev.cost[table[i]!]! ∧ + st.ev.cost[table[i]!]! ≤ limits.maxMaterialize := by + unfold materializeStep at h + dsimp only at h + split at h + · cases h + · rename_i hc + obtain ⟨e, he, h⟩ := bind_eq_ok h + try simp only at h + split at h + · cases h + · simp only [pure, Except.pure, Except.ok.injEq] at h + subst h + exact ⟨e, he, rfl, rfl, rfl, rfl, rfl, by omega⟩ + +/-- The parts of a successful `materializeTable`: the table fits the Share +word, the entry loop, and the roots built against its final dictionary. -/ +theorem materializeTable_parts (p : Prep) (table roots : Array Nat) (limits : Limits) + (widthAt : Nat → Nat) {entries rs : Array Ixon.Expr} {predicted work : Nat} + (h : materializeTable p table roots limits widthAt = .ok (entries, rs, predicted, work)) : + table.size < UInt64.size ∧ (∀ k, k < table.size → table[k]! < p.dag.size) ∧ ∃ st, + (List.range table.size).foldlM (materializeStep p table limits widthAt) + { entries := #[], index := Array.replicate p.dag.size none, + width := Array.replicate p.dag.size none, + ev := p.evalAll (Array.replicate p.dag.size none), + predicted := tag0Size table.size, work := 0 } = .ok st ∧ + entries = st.entries ∧ + roots.mapM (fun r => p.build st.ev st.index st.width false (p.dag.size + 1) r) = .ok rs ∧ + predicted = st.predicted + rootsCost st.ev.cost roots := by + unfold materializeTable at h + split at h + · cases h + · rename_i hsz + split at h + · cases h + rename_i hall + have hall' : (table.all fun x => decide (x < p.dag.size)) = true := by simpa using hall + have hrange : ∀ k, k < table.size → table[k]! < p.dag.size := by + intro k hk + rw [Array.all_eq_true] at hall' + rw [getElem!_pos table k hk] + simpa using hall' k hk + obtain ⟨st, hst, h⟩ := bind_eq_ok h + try simp only at h + split at h + · cases h + · obtain ⟨rs', hrs, h⟩ := bind_eq_ok h + try simp only at h + split at h + · cases h + · simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl, rfl, -⟩ := h + exact ⟨by unfold wordBound at hsz; omega, hrange, st, hst, rfl, hrs, rfl⟩ + +theorem indexOfPrefix_zero (size : Nat) (table : Array Nat) : + indexOfPrefix size table 0 = Array.replicate size none := by + simp [indexOfPrefix, indexOfPairs] + +theorem indexOfPrefix_succ (size : Nat) (table : Array Nat) {k : Nat} (hk : k < table.size) : + indexOfPrefix size table (k + 1) = (indexOfPrefix size table k).set! table[k]! (some k) := by + unfold indexOfPrefix indexOfPairs + have htake : table.toList.take (k + 1) = table.toList.take k ++ [table[k]!] := by + rw [List.take_succ_eq_append_getElem (by simpa using hk)] + simp [getElem!_pos table k hk] + rw [htake, List.zipIdx_append, List.foldl_append] + simp [List.length_take, Nat.min_eq_left (Nat.le_of_lt hk : k ≤ table.size)] + +/-- The dictionary of the table loop after `k` entries is the prefix +dictionary of the first `k` entries, with the layout widths. -/ +def TableInv (p : Prep) (table : Array Nat) (widthAt : Nat → Nat) (k : Nat) (st : TableState) : + Prop := + k ≤ table.size ∧ st.index = indexOfPrefix p.dag.size table k ∧ + st.width = (indexOfPrefix p.dag.size table k).map (·.map widthAt) ∧ + st.entries.size = k ∧ + ∀ j (hj : j < st.entries.size), ∃ ev, p.build ev (indexOfPrefix p.dag.size table j) + ((indexOfPrefix p.dag.size table j).map (·.map widthAt)) false (p.dag.size + 1) + table[j]! = .ok st.entries[j] + +theorem tableInv_loop (p : Prep) (table : Array Nat) (limits : Limits) (widthAt : Nat → Nat) + {st : TableState} + (h : (List.range table.size).foldlM (materializeStep p table limits widthAt) + { entries := #[], index := Array.replicate p.dag.size none, + width := Array.replicate p.dag.size none, + ev := p.evalAll (Array.replicate p.dag.size none), + predicted := tag0Size table.size, work := 0 } = .ok st) : + TableInv p table widthAt table.size st := by + refine foldlM_range_inv _ (fun k st => k ≤ table.size → TableInv p table widthAt k st) + (fun i s s' hI hs hle => ?_) table.size _ st (fun _ => ?_) h (Nat.le_refl _) + · obtain ⟨_, hidx, hwid, hsz, hent⟩ := hI (by omega) + obtain ⟨e, he, hent', hidx', hwid', -, -, -⟩ := materializeStep_spec hs + have hsucc := indexOfPrefix_succ p.dag.size table (k := i) (by omega) + refine ⟨hle, by rw [hidx', hidx, hsucc], ?_, by rw [hent']; simp [hsz], fun j hj => ?_⟩ + · rw [hwid', hwid, hsucc] + simp [Array.set!, Array.map_setIfInBounds] + · have hj2 : j < (s.entries.push e).size := hent' ▸ hj + have heq : s'.entries[j] = (s.entries.push e)[j] := by simp only [hent'] + rw [heq] + by_cases hji : j < s.entries.size + · rw [Array.getElem_push_lt hji] + exact hent j hji + · have hj' : j = i := by simp at hj2; omega + subst hj' + have : j = s.entries.size := by omega + simp only [this, Array.getElem_push_eq] + rw [hsz, ← hwid, ← hidx] + exact ⟨_, he⟩ + · exact ⟨Nat.zero_le _, by rw [indexOfPrefix_zero], by rw [indexOfPrefix_zero]; simp, + rfl, fun j hj => absurd hj (by simp)⟩ + +theorem getElem!_of_getElem? {table : Array Nat} {i u : Nat} (h : table[i]? = some u) : + table[i]! = u := by + simp [getElem!_def, h] + +/-- The prefix dictionary of a table is modelled by the table's terms. -/ +theorem indexModel_prefix (size : Nat) (table : Array Nat) (k : Nat) + (hk : k ≤ UInt64.size) (E : Nat → Ixon.Expr) : + IndexModel (indexOfPrefix size table k) E (fun i => E table[i]!) := by + intro u i h + obtain ⟨hik, hsome⟩ := indexOfPrefix_spec size table k u i h + exact ⟨by omega, by simp only [getElem!_of_getElem? hsome]⟩ + +/-- Loop-level backwardness of `materializeTable`: entry `k` only references +Share indices below `k`, and the roots only indices below the table size +(the Share part of `DecodeCtx.SharingWF`). -/ +theorem materializeTable_backward (p : Prep) (table roots : Array Nat) (limits : Limits) + (widthAt : Nat → Nat) (hsize : table.size ≤ UInt64.size) + {entries rs : Array Ixon.Expr} {predicted work : Nat} + (h : materializeTable p table roots limits widthAt = .ok (entries, rs, predicted, work)) : + entries.size = table.size ∧ + (∀ (k : Nat) (hk : k < entries.size), SharesIn (· < k) entries[k]) ∧ + ∀ r ∈ rs.toList, SharesIn (· < table.size) r := by + obtain ⟨_, _, st, hst, rfl, hroots, -⟩ := materializeTable_parts p table roots limits widthAt h + obtain ⟨-, hidx, -, hsz, hent⟩ := tableInv_loop p table limits widthAt hst + refine ⟨hsz, fun k hk => ?_, fun r hr => ?_⟩ + · obtain ⟨ev, hb⟩ := hent k hk + exact build_prefix_backward p ev table k (by omega) _ _ false _ _ hb + · rw [Array.mapM_eq_mapM_toList] at hroots + cases hm : List.mapM (fun r => p.build st.ev st.index st.width false (p.dag.size + 1) r) + roots.toList with + | error err => rw [hm] at hroots; cases hroots + | ok l => + rw [hm] at hroots + have : rs = l.toArray := by cases hroots; rfl + subst this + obtain ⟨t, ht⟩ := forall₂_mem_right (mapM_ok_forall₂ _ _ _ hm) r (by simpa using hr) + rw [hidx] at ht + exact build_prefix_backward p _ table table.size hsize _ _ false _ _ ht + +/-- Expansion correctness of `materializeTable`: with every `Share(i)` +replaced by the term of entry `i`, entry `k` is the term `table[k]` and each +root is its term. -/ +theorem materializeTable_correct (p : Prep) (table roots : Array Nat) (limits : Limits) + (widthAt : Nat → Nat) (hsize : table.size ≤ UInt64.size) + {entries rs : Array Ixon.Expr} {predicted work : Nat} + (h : materializeTable p table roots limits widthAt = .ok (entries, rs, predicted, work)) + (E : Nat → Ixon.Expr) (hE : DagModel p.dag E) : + (∀ (k : Nat) (hk : k < entries.size), + substShares (fun i => E table[i]!) entries[k] = E table[k]!) ∧ + List.Forall₂ (fun r e => substShares (fun i => E table[i]!) e = E r) + roots.toList rs.toList := by + obtain ⟨_, _, st, hst, rfl, hroots, -⟩ := materializeTable_parts p table roots limits widthAt h + obtain ⟨-, hidx, -, hsz, hent⟩ := tableInv_loop p table limits widthAt hst + refine ⟨fun k hk => ?_, ?_⟩ + · obtain ⟨ev, hb⟩ := hent k hk + exact build_correct p ev _ _ E _ hE + (indexModel_prefix p.dag.size table k (by omega) E) _ false _ _ hb + · rw [Array.mapM_eq_mapM_toList] at hroots + cases hm : List.mapM (fun r => p.build st.ev st.index st.width false (p.dag.size + 1) r) + roots.toList with + | error err => rw [hm] at hroots; cases hroots + | ok l => + rw [hm] at hroots + have : rs = l.toArray := by cases hroots; rfl + subst this + rw [hidx] at hm + exact forall₂_imp (fun t e he => build_correct p _ _ _ E _ hE + (indexModel_prefix p.dag.size table table.size hsize E) _ false t e he) + (mapM_ok_forall₂ _ _ _ hm) + +/-- The parts of a successful `materializeDependent`: the table fits the +Share word, entries are built as entry bodies and roots standalone, all +against the dictionary of the whole table. -/ +theorem materializeDependent_parts (p : Prep) (table roots : Array Nat) + (width : Array (Option Nat)) (limits : Limits) {es rs : Array Ixon.Expr} {total work : Nat} + (h : p.materializeDependent table roots width limits = .ok (es, rs, total, work)) : + table.size < UInt64.size ∧ + List.Forall₂ (fun t e => p.build (p.evalAll width) + (indexOfPairs p.dag.size table.toList.zipIdx) width true (p.dag.size + 1) t = .ok e) + table.toList es.toList ∧ + List.Forall₂ (fun r e => p.build (p.evalAll width) + (indexOfPairs p.dag.size table.toList.zipIdx) width false (p.dag.size + 1) r = .ok e) + roots.toList rs.toList := by + unfold Prep.materializeDependent at h + split at h + · cases h + rename_i hword + simp only at h + split at h + · cases h + obtain ⟨es', hes, h⟩ := bind_eq_ok h + obtain ⟨rs', hrs, h⟩ := bind_eq_ok h + cases h + refine ⟨by unfold wordBound at hword; omega, array_mapM_forall₂ _ _ _ hes, + array_mapM_forall₂ _ _ _ hrs⟩ + +/-- Loop-level backwardness of `materializeDependent`: if the table is in +dependency order (a stored term below entry `k` is stored at an index below +`k`), entry `k` only references Share indices below `k` and the roots only +indices below the table size (the Share part of `DecodeCtx.SharingWF`). -/ +theorem materializeDependent_backward (p : Prep) (table roots : Array Nat) + (width : Array (Option Nat)) (limits : Limits) (harity : DagArity p.dag) + (horder : ∀ (k j : Nat) (hk : k < table.size) (hj : j < table.size), + Below p.dag table[k] table[j] → j < k) + {es rs : Array Ixon.Expr} {total work : Nat} + (h : p.materializeDependent table roots width limits = .ok (es, rs, total, work)) : + es.size = table.size ∧ + (∀ (k : Nat) (hk : k < es.size), SharesIn (· < k) es[k]) ∧ + ∀ r ∈ rs.toList, SharesIn (· < table.size) r := by + obtain ⟨hword, hes, hrs⟩ := materializeDependent_parts p table roots width limits h + have hspec := indexOfTable_spec p.dag.size table + have hidx : ∀ (u i : Nat), (indexOfPairs p.dag.size table.toList.zipIdx)[u]?.getD none = + some i → i < UInt64.size := fun u i hi => by + have := (Array.getElem?_eq_some_iff.mp (hspec u i hi)).1 + omega + obtain ⟨hlen, hget⟩ := forall₂_getElem hes + simp only [Array.length_toList] at hlen + refine ⟨hlen.symm, fun k hk => ?_, fun r hr => ?_⟩ + · have hb := hget k (by simp; omega) (by simpa using hk) + simp only [Array.getElem_toList] at hb + refine SharesIn.mono ?_ _ + (build_shares_below p _ _ width harity hidx _ true _ _ hb) + rintro i ⟨u, hu, hor⟩ + rcases hor with ⟨hf, _⟩ | hbelow + · cases hf + · obtain ⟨hi, rfl⟩ := Array.getElem?_eq_some_iff.mp (hspec u i hu) + exact horder k i (by omega) hi hbelow + · obtain ⟨t, ht⟩ := forall₂_mem_right hrs r hr + refine SharesIn.mono ?_ _ (build_shares_below p _ _ width harity hidx _ false _ _ ht) + rintro i ⟨u, hu, -⟩ + exact (Array.getElem?_eq_some_iff.mp (hspec u i hu)).1 + +/-- Expansion correctness of `materializeDependent`: with every `Share(i)` +replaced by the term of entry `i`, entry `k` is the term `table[k]` and each +root is its term. -/ +theorem materializeDependent_correct (p : Prep) (table roots : Array Nat) + (width : Array (Option Nat)) (limits : Limits) + {es rs : Array Ixon.Expr} {total work : Nat} + (h : p.materializeDependent table roots width limits = .ok (es, rs, total, work)) + (E : Nat → Ixon.Expr) (hE : DagModel p.dag E) : + List.Forall₂ (fun t e => substShares (fun i => E table[i]!) e = E t) + table.toList es.toList ∧ + List.Forall₂ (fun r e => substShares (fun i => E table[i]!) e = E r) + roots.toList rs.toList := by + obtain ⟨hword, hes, hrs⟩ := materializeDependent_parts p table roots width limits h + have hσ : IndexModel (indexOfPairs p.dag.size table.toList.zipIdx) E + (fun i => E table[i]!) := by + intro u i hi + have hsome := indexOfTable_spec p.dag.size table u i hi + have := (Array.getElem?_eq_some_iff.mp hsome).1 + exact ⟨by omega, by simp only [getElem!_of_getElem? hsome]⟩ + exact ⟨forall₂_imp (fun t e he => build_correct p _ _ width E _ hE hσ _ true t e he) hes, + forall₂_imp (fun r e he => build_correct p _ _ width E _ hE hσ _ false r e he) hrs⟩ + +end Table + +end Ix.Compile.Verify.SharingExact diff --git a/Ix/Compile/Verify/Statements.lean b/Ix/Compile/Verify/Statements.lean index 83c9d5cbe..6fdf2b7b6 100644 --- a/Ix/Compile/Verify/Statements.lean +++ b/Ix/Compile/Verify/Statements.lean @@ -12,7 +12,6 @@ import Ix.Compile.Verify.CompileExpr import Ix.Compile.Verify.CompileExprCodec import Ix.Compile.Verify.CompileConstantCodec import Ix.Compile.Verify.CompilePreseed -import Ix.Compile.Verify.Sharing import Ix.Compile.Verify.CompileSharingCodec import Ix.Compile.Verify.CompileAxiomCodec import Ix.Compile.Verify.CompileDefinitionCodec @@ -23,6 +22,23 @@ import Ix.Compile.Verify.CompileInductiveCodec import Ix.Compile.Verify.CompileMutualCodec import Ix.Compile.Verify.Reference import Ix.Compile.Verify.SourceValue +import Ix.Compile.Verify.TagN +import Ix.Compile.Verify.SharingExactCanon +import Ix.Compile.Verify.SharingExactPasses +import Ix.Compile.Verify.UniformOptimizer +import Ix.Compile.Verify.UniformLength +import Ix.Compile.Verify.UniformDecomp +import Ix.Compile.Verify.UniformChecks +import Ix.Compile.Verify.UniformFinal +import Ix.Compile.Verify.UniformSearch +import Ix.Compile.Verify.UniformOptimality +import Ix.Compile.Verify.TieredSelect +import Ix.Compile.Verify.TieredTier +import Ix.Compile.Verify.TieredModel +import Ix.Compile.Verify.TieredPhase3 +import Ix.Compile.Verify.TieredIdem +import Ix.Compile.Verify.TieredWire +import Ix.Compile.Verify.TieredGuard /-! # Public compiler-verification frontier @@ -45,17 +61,13 @@ reference-address and universe-table conditions required by the constant wire. Frozen table views transport it across compilation, and the one-root axiom and sequential two-root definition phases now assemble unshared constants that round-trip through `serConstant`/`deConstant`. Production -`buildConstantWithSharing` is connected on its exact no-sharing branch: for -both axiom and definition roots, the actual builder equals the verified -unshared assembly, and `BlockResult.mk'` stores bytes that decode back to its -block. The production sharing pipeline is now proof-visible from recursive -Merkle analysis through usage propagation and nonempty table construction. -Analysis retains only wire-safe representatives, rewriting cannot increase -application, lambda, or forall spine counts, and `applySharing` preserves the -expression wire domain for every rewritten root and emitted sharing entry. -An explicit overflow fallback makes its sharing count unconditionally -representable by `UInt64`, closing the complete axiom and definition builders -against the constant codec. Pointwise recursor-rule and constructor updaters, +`buildConstantWithSharing` is the canonical construction +`canonicalSharingTiered .tagN` of the payload's roots: every successful build +is wire-safe, because `Tiered.canonicalSharingTiered_format` (`FormatOK`) makes +every table entry and root wire-safe and the table count representable by +`UInt64`; on the no-sharing outcome (roots kept, empty table) the builder +equals the verified unshared assembly, and `BlockResult.mk'` stores bytes that +decode back to its block. A compile step succeeds under `SharingSucceeds`. Pointwise recursor-rule and constructor updaters, together with a verified heterogeneous mutual-member fold, preserve all nested wire conditions and counted child arrays. Quotient, standalone recursor, mutual-block, and all four projection variants are consolidated by @@ -181,7 +193,7 @@ all old lookups and establish exact recovery for every traversed name, ancestor name component, and blob payload. The v2 universe writer and reader are now kernel-visible total definitions; an exact-consumption runner rejects trailing bytes, trimmed little-endian -integers and both `Tag2` forms have proved production inverses, and every +integers and the TagN integer code have proved production inverses, and every universe whose compressed successor counts fit `UInt64` has an exact serializer/decoder inverse. In particular, the `Sort 1` universe required by the first declaration fixture is covered. The v2 expression writer and reader @@ -191,7 +203,7 @@ compiler-facing wire domain, including arbitrary canonical application, lambda, and forall spines. Reference and recursive-reference instantiations may carry arbitrary wire-sized universe-index vectors. That domain includes the `A` type and both the type and value shapes of `idA`, with unrestricted -`UInt64` fields backed by complete `Tag0` and `Tag4` inverse laws. +`UInt64` fields backed by complete TagN (`f = 0`, `f = 4`) inverse laws. The declaration layer now composes those results through production definition and axiom payloads, their `ConstantInfo` discriminants, and the top-level `serConstant`/`deConstant` pair with arbitrary wire-representable sharing, diff --git a/Ix/Compile/Verify/TagN.lean b/Ix/Compile/Verify/TagN.lean new file mode 100644 index 000000000..2df62fab6 --- /dev/null +++ b/Ix/Compile/Verify/TagN.lean @@ -0,0 +1,449 @@ +import Ix.Compile.Verify.Codec + +/-! +# TagN integer code + +Proofs about `Ixon.putTagN` / `Ixon.getTagN` for flag widths `f ∈ {0, 2, 4}`. +The explicit bytes written (`Codec.tagNBytes`), their length +(`Ixon.tagNByteWidth`) and the exact reads (roundtrip) are in +`Ix.Compile.Verify.Codec`, where every wire codec proof uses them. This module +adds the rung ends, monotonicity of the width, and the converse: every successful +read consumed exactly the encoding of the decoded value, so the code is a +bijection between `UInt64` values (per flag) and accepted byte strings. +Invalid codes and overflowing 8-byte payloads are rejected. +-/ + +namespace Ix.Compile.Verify.TagN + +open Ix.Compile.Verify.Codec + +/-! ## Rung ends -/ + +theorem tagNEnd1_eq_0 : Ixon.tagNEnd1 0 = 128 := by decide +theorem tagNEnd2_eq_0 : Ixon.tagNEnd2 0 = 16512 := by decide +theorem tagNEnd3_eq_0 : Ixon.tagNEnd3 0 = 82048 := by decide +theorem tagNEnd4_eq_0 : Ixon.tagNEnd4 0 = 16859264 := by decide +theorem tagNEnd5_eq_0 : Ixon.tagNEnd5 0 = 4311826560 := by decide +theorem tagNEnd1_eq_2 : Ixon.tagNEnd1 2 = 32 := by decide +theorem tagNEnd2_eq_2 : Ixon.tagNEnd2 2 = 4128 := by decide +theorem tagNEnd3_eq_2 : Ixon.tagNEnd3 2 = 69664 := by decide +theorem tagNEnd4_eq_2 : Ixon.tagNEnd4 2 = 16846880 := by decide +theorem tagNEnd5_eq_2 : Ixon.tagNEnd5 2 = 4311814176 := by decide +theorem tagNEnd1_eq_4 : Ixon.tagNEnd1 4 = 8 := by decide +theorem tagNEnd2_eq_4 : Ixon.tagNEnd2 4 = 1032 := by decide +theorem tagNEnd3_eq_4 : Ixon.tagNEnd3 4 = 66568 := by decide +theorem tagNEnd4_eq_4 : Ixon.tagNEnd4 4 = 16843784 := by decide +theorem tagNEnd5_eq_4 : Ixon.tagNEnd5 4 = 4311811080 := by decide + +/-- The rung ends increase. -/ +theorem tagNEnd_le (f : Nat) : + Ixon.tagNEnd1 f ≤ Ixon.tagNEnd2 f ∧ Ixon.tagNEnd2 f ≤ Ixon.tagNEnd3 f ∧ + Ixon.tagNEnd3 f ≤ Ixon.tagNEnd4 f ∧ Ixon.tagNEnd4 f ≤ Ixon.tagNEnd5 f ∧ + Ixon.tagNEnd5 f ≤ Ixon.tagNEnd6 f := by + unfold Ixon.tagNEnd6 Ixon.tagNEnd5 Ixon.tagNEnd4 Ixon.tagNEnd3 Ixon.tagNEnd2 + exact ⟨Nat.le_add_right _ _, Nat.le_add_right _ _, Nat.le_add_right _ _, + Nat.le_add_right _ _, Nat.le_add_right _ _⟩ + +/-- Every `UInt64` lies below the end of rung 6, for every flag width. -/ +theorem uint64_lt_tagNEnd6 (f : Nat) (v : UInt64) : v.toNat < Ixon.tagNEnd6 f := by + unfold Ixon.tagNEnd6 + exact Nat.lt_of_lt_of_le v.toNat_lt (Nat.le_add_left _ _) + +/-- The 9-byte rung starts below `2^64` for the supported flag widths. -/ +theorem tagNEnd5_lt (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) : + Ixon.tagNEnd5 f < 2 ^ 33 := by + rcases hf with rfl | rfl | rfl <;> decide + +/-! ## Width -/ + +theorem tagNByteWidth_mono (f : Nat) {i j : Nat} (h : i ≤ j) : + Ixon.tagNByteWidth f i ≤ Ixon.tagNByteWidth f j := by + have := tagNEnd_le f + unfold Ixon.tagNByteWidth + repeat' split + all_goals omega + +theorem tagNByteWidth_pos (f i : Nat) : 1 ≤ Ixon.tagNByteWidth f i := by + unfold Ixon.tagNByteWidth + repeat' split + all_goals omega + +/-! ## Inverting successful reads -/ + +/-- A successful read moved the cursor across exactly `bytes`. -/ +def Consumed (s s' : Ixon.GetState) (bytes : ByteArray) : Prop := + s' = { idx := s.idx + bytes.size, bytes := s.bytes } ∧ + s.bytes.extract s.idx (s.idx + bytes.size) = bytes + +theorem Consumed.empty (s : Ixon.GetState) : Consumed s s ByteArray.empty := by + exact ⟨by simp, by simp⟩ + +theorem Consumed.trans {s s1 s2 : Ixon.GetState} {a b : ByteArray} + (h1 : Consumed s s1 a) (h2 : Consumed s1 s2 b) : Consumed s s2 (a ++ b) := by + obtain ⟨rfl, hx1⟩ := h1 + obtain ⟨rfl, hx2⟩ := h2 + simp only at hx2 + unfold Consumed + rw [ByteArray.size_append, ← Nat.add_assoc] + refine ⟨rfl, ?_⟩ + rw [ByteArray.extract_eq_extract_append_extract (s.idx + a.size) + (by omega) (by omega), hx1, hx2] + +theorem bind_ok_inv {x : Ixon.GetM α} {k : α → Ixon.GetM β} {s s' : Ixon.GetState} + {v : β} (h : (x >>= k) s = .ok v s') : + ∃ a s1, x s = .ok a s1 ∧ k a s1 = .ok v s' := by + change EStateM.bind x k s = _ at h + unfold EStateM.bind at h + split at h + · exact ⟨_, _, by assumption, h⟩ + · cases h + +theorem pure_ok_inv {a b : α} {s s' : Ixon.GetState} + (h : (pure a : Ixon.GetM α) s = .ok b s') : a = b ∧ s' = s := by + change EStateM.Result.ok a s = _ at h + cases h + exact ⟨rfl, rfl⟩ + +theorem throw_ok_false {e : String} {b : α} {s s' : Ixon.GetState} + (h : (throw e : Ixon.GetM α) s = .ok b s') : False := by + change EStateM.Result.error e s = _ at h + cases h + +theorem getU8_ok {s s' : Ixon.GetState} {b : UInt8} (h : Ixon.getU8 s = .ok b s') : + Consumed s s' [b].toByteArray ∧ s.bytes[s.idx]! = b := by + unfold Ixon.getU8 at h + change EStateM.bind EStateM.get _ s = _ at h + simp only [EStateM.bind, EStateM.get] at h + split at h + · rename_i hlt + change EStateM.Result.ok _ _ = _ at h + cases h + refine ⟨⟨by simp, ?_⟩, rfl⟩ + simp only [List.size_toByteArray, List.length_cons, List.length_nil, Nat.zero_add] + rw [ByteArray.extract_add_one (by omega)] + simp [getElem!_pos, hlt] + · cases h + +theorem or_shift_toNat (low : UInt8) (high : UInt64) (hh : high.toNat < 2 ^ 56) : + (low.toUInt64 ||| high <<< 8).toNat = low.toNat + high.toNat * 256 := by + have hlow := low.toNat_lt + have hsh : high.toNat * 256 < 2 ^ 64 := by omega + simp only [UInt64.toNat_or, UInt64.toNat_shiftLeft, UInt8.toNat_toUInt64, + UInt64.reduceToNat, Nat.reduceMod, Nat.shiftLeft_eq] + rw [show 2 ^ 8 = 256 from rfl, Nat.mod_eq_of_lt hsh, Nat.or_comm, + show high.toNat * 256 = high.toNat <<< 8 by rw [Nat.shiftLeft_eq], + ← Nat.shiftLeft_add_eq_or_of_lt (by simpa using hlow), Nat.shiftLeft_eq] + omega + +theorem getU64TrimmedLEAux_ok {len : Nat} (hlen : len ≤ 8) {s s' : Ixon.GetState} + {x : UInt64} (h : Ixon.getU64TrimmedLEAux len s = .ok x s') : + Consumed s s' (trimmedBytes x len) ∧ x.toNat < 2 ^ (8 * len) := by + induction len generalizing s s' x with + | zero => + obtain ⟨rfl, rfl⟩ := pure_ok_inv h + exact ⟨Consumed.empty _, by simp⟩ + | succ len ih => + obtain ⟨low, s1, hlow, h⟩ := bind_ok_inv h + obtain ⟨high, s2, hhigh, h⟩ := bind_ok_inv h + obtain ⟨rfl, rfl⟩ := pure_ok_inv h + obtain ⟨hc1, -⟩ := getU8_ok hlow + obtain ⟨hc2, hlt⟩ := ih (by omega) hhigh + have hlt' : high.toNat < 2 ^ 56 := + Nat.lt_of_lt_of_le hlt (Nat.pow_le_pow_right (by decide) (by omega)) + have hx := or_shift_toNat low high hlt' + have hlowNat := low.toNat_lt + have hbyte : (low.toUInt64 ||| high <<< 8).toUInt8 = low := by + rw [← UInt8.toNat_inj, UInt64.toNat_toUInt8, hx] + omega + have hshift : (low.toUInt64 ||| high <<< 8) >>> 8 = high := by + rw [← UInt64.toNat_inj, UInt64.toNat_shiftRight, hx] + simp only [UInt64.reduceToNat, Nat.reduceMod, Nat.shiftRight_eq_div_pow] + omega + refine ⟨?_, ?_⟩ + · simp only [trimmedBytes, hbyte, hshift] + exact hc1.trans hc2 + · have hp : 2 ^ (8 * (len + 1)) = 2 ^ (8 * len) * 256 := by + rw [Nat.mul_succ, Nat.pow_add] + rw [hx, hp] + omega + +theorem tagNHeader_split (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) (b : UInt8) : + Ixon.tagNHeader f (b.toNat / 2 ^ (8 - f)).toUInt8 (b.toNat % 2 ^ (8 - f)) = b ∧ + (b.toNat / 2 ^ (8 - f)).toUInt8.toNat < 2 ^ f := by + have key : ∀ n : Nat, (n.toUInt8).toNat = n % 256 := fun n => by simp + have hb := b.toNat_lt + refine ⟨?_, ?_⟩ + · unfold Ixon.tagNHeader + rw [← UInt8.toNat_inj, key, key] + rcases hf with rfl | rfl | rfl <;> + simp only [Nat.reduceSub, Nat.reducePow] at hb ⊢ <;> omega + · rw [key] + rcases hf with rfl | rfl | rfl <;> + simp only [Nat.reduceSub, Nat.reducePow] at hb ⊢ <;> omega + +theorem toUInt64_toNat_of_lt {n : Nat} (h : n < 2 ^ 64) : n.toUInt64.toNat = n := by + simp only [Nat.toUInt64_eq, UInt64.toNat_ofNat'] + exact Nat.mod_eq_of_lt h + +/-- Every successful `getTagN` read consumed exactly the encoding of the value +it returned, and the decoded flag fits in `f` bits. -/ +theorem getTagN_consumed (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) + {s s' : Ixon.GetState} {t : Ixon.TagN} (h : Ixon.getTagN f s = .ok t s') : + Consumed s s' (tagNBytes f t.flag t.value) ∧ t.flag.toNat < 2 ^ f := by + obtain ⟨hR, hlead, hmbit, hE1, hE2, hE3, hE4, hE5, hE5lt⟩ := tagN_consts f hf + unfold Ixon.getTagN at h + obtain ⟨b, s1, hb, h⟩ := bind_ok_inv h + obtain ⟨hc1, -⟩ := getU8_ok hb + obtain ⟨hhdr, hflag⟩ := tagNHeader_split f hf b + have hpR : b.toNat % 2 ^ (8 - f) < 2 ^ (8 - f) := + Nat.mod_lt _ (Nat.two_pow_pos _) + simp only at h + generalize b.toNat % 2 ^ (8 - f) = p at h hhdr hpR + generalize (b.toNat / 2 ^ (8 - f)).toUInt8 = flag at h hhdr hflag + by_cases h1 : p < 2 ^ (8 - f - 1) + · rw [if_pos h1] at h + obtain ⟨rfl, rfl⟩ := pure_ok_inv h + have hv : p.toUInt64.toNat = p := toUInt64_toNat_of_lt (by omega) + refine ⟨?_, hflag⟩ + have henc : tagNBytes f flag p.toUInt64 = [b].toByteArray ++ ByteArray.empty := by + unfold tagNBytes + simp only + rw [hv, if_pos (by omega), hhdr, ByteArray.append_empty] + rw [henc] + exact hc1.trans (Consumed.empty _) + rw [if_neg h1] at h + by_cases h2 : p - 2 ^ (8 - f - 1) < 2 ^ (8 - f - 2) + · rw [if_pos h2] at h + obtain ⟨lo, s2, hlo, h⟩ := bind_ok_inv h + obtain ⟨rfl, rfl⟩ := pure_ok_inv h + obtain ⟨hc2, -⟩ := getU8_ok hlo + have hlo' := lo.toNat_lt + have hv := toUInt64_toNat_of_lt (n := Ixon.tagNEnd1 f + + (p - 2 ^ (8 - f - 1)) * 256 + lo.toNat) (by omega) + refine ⟨?_, hflag⟩ + have henc : tagNBytes f flag (Ixon.tagNEnd1 f + (p - 2 ^ (8 - f - 1)) * 256 + + lo.toNat).toUInt64 = [b].toByteArray ++ [lo].toByteArray := by + unfold tagNBytes + simp only + rw [hv, if_neg (by omega), if_pos (by omega)] + have e1 : 2 ^ (8 - f - 1) + (Ixon.tagNEnd1 f + (p - 2 ^ (8 - f - 1)) * 256 + + lo.toNat - Ixon.tagNEnd1 f) / 256 = p := by omega + have e2 : ((Ixon.tagNEnd1 f + (p - 2 ^ (8 - f - 1)) * 256 + lo.toNat - + Ixon.tagNEnd1 f) % 256).toUInt8 = lo := by + rw [← UInt8.toNat_inj] + simp only [Nat.toUInt8_eq, UInt8.toNat_ofNat'] + omega + rw [e1, e2, hhdr] + rw [henc] + exact hc1.trans hc2 + rw [if_neg h2] at h + unfold Ixon.getTagNWide at h + by_cases h3 : p - 2 ^ (8 - f - 1) - 2 ^ (8 - f - 2) = 0 + · rw [if_pos h3] at h + obtain ⟨x, s2, hx, h⟩ := bind_ok_inv h + obtain ⟨rfl, rfl⟩ := pure_ok_inv h + obtain ⟨hc2, hxlt⟩ := getU64TrimmedLEAux_ok (by omega) hx + simp only [Nat.reduceMul, Nat.reducePow] at hxlt + have hv := toUInt64_toNat_of_lt (n := Ixon.tagNEnd2 f + x.toNat) (by omega) + refine ⟨?_, hflag⟩ + have henc : tagNBytes f flag (Ixon.tagNEnd2 f + x.toNat).toUInt64 = + [b].toByteArray ++ trimmedBytes x 2 := by + unfold tagNBytes + simp only + rw [hv, if_neg (by omega), if_neg (by omega), if_pos (by omega), + show 2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) = p by omega, hhdr, + show Ixon.tagNEnd2 f + x.toNat - Ixon.tagNEnd2 f = x.toNat by omega] + simp + rw [henc] + exact hc1.trans hc2 + rw [if_neg h3] at h + by_cases h4 : p - 2 ^ (8 - f - 1) - 2 ^ (8 - f - 2) = 1 + · rw [if_pos h4] at h + obtain ⟨x, s2, hx, h⟩ := bind_ok_inv h + obtain ⟨rfl, rfl⟩ := pure_ok_inv h + obtain ⟨hc2, hxlt⟩ := getU64TrimmedLEAux_ok (by omega) hx + simp only [Nat.reduceMul, Nat.reducePow] at hxlt + have hv := toUInt64_toNat_of_lt (n := Ixon.tagNEnd3 f + x.toNat) (by omega) + refine ⟨?_, hflag⟩ + have henc : tagNBytes f flag (Ixon.tagNEnd3 f + x.toNat).toUInt64 = + [b].toByteArray ++ trimmedBytes x 3 := by + unfold tagNBytes + simp only + rw [hv, if_neg (by omega), if_neg (by omega), if_neg (by omega), if_pos (by omega), + show 2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) + 1 = p by omega, hhdr, + show Ixon.tagNEnd3 f + x.toNat - Ixon.tagNEnd3 f = x.toNat by omega] + simp + rw [henc] + exact hc1.trans hc2 + rw [if_neg h4] at h + by_cases h5 : p - 2 ^ (8 - f - 1) - 2 ^ (8 - f - 2) = 2 + · rw [if_pos h5] at h + obtain ⟨x, s2, hx, h⟩ := bind_ok_inv h + obtain ⟨rfl, rfl⟩ := pure_ok_inv h + obtain ⟨hc2, hxlt⟩ := getU64TrimmedLEAux_ok (by omega) hx + simp only [Nat.reduceMul, Nat.reducePow] at hxlt + have hv := toUInt64_toNat_of_lt (n := Ixon.tagNEnd4 f + x.toNat) (by omega) + refine ⟨?_, hflag⟩ + have henc : tagNBytes f flag (Ixon.tagNEnd4 f + x.toNat).toUInt64 = + [b].toByteArray ++ trimmedBytes x 4 := by + unfold tagNBytes + simp only + rw [hv, if_neg (by omega), if_neg (by omega), if_neg (by omega), if_neg (by omega), + if_pos (by omega), + show 2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) + 2 = p by omega, hhdr, + show Ixon.tagNEnd4 f + x.toNat - Ixon.tagNEnd4 f = x.toNat by omega] + simp + rw [henc] + exact hc1.trans hc2 + rw [if_neg h5] at h + by_cases h6 : p - 2 ^ (8 - f - 1) - 2 ^ (8 - f - 2) = 3 + · rw [if_pos h6] at h + obtain ⟨x, s2, hx, h⟩ := bind_ok_inv h + obtain ⟨hc2, hxlt⟩ := getU64TrimmedLEAux_ok (by omega) hx + by_cases hov : Ixon.tagNEnd5 f + x.toNat < 2 ^ 64 + · rw [if_pos hov] at h + obtain ⟨rfl, rfl⟩ := pure_ok_inv h + have hv := toUInt64_toNat_of_lt hov + refine ⟨?_, hflag⟩ + have henc : tagNBytes f flag (Ixon.tagNEnd5 f + x.toNat).toUInt64 = + [b].toByteArray ++ trimmedBytes x 8 := by + unfold tagNBytes + simp only + rw [hv, if_neg (by omega), if_neg (by omega), if_neg (by omega), if_neg (by omega), + if_neg (by omega), + show 2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) + 3 = p by omega, hhdr, + show Ixon.tagNEnd5 f + x.toNat - Ixon.tagNEnd5 f = x.toNat by omega] + simp + rw [henc] + exact hc1.trans hc2 + · rw [if_neg hov] at h + exact (throw_ok_false h).elim + rw [if_neg h6] at h + exact (throw_ok_false h).elim + +/-- Every byte string accepted by the full-buffer TagN decoder is the +encoding of the value it decodes to (canonicity). -/ +theorem runGetExact_getTagN_eq (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) + {bytes : ByteArray} {t : Ixon.TagN} + (h : Ixon.runGetExact (Ixon.getTagN f) bytes = .ok t) : + bytes = Ixon.runPut (Ixon.putTagN f t.flag t.value) ∧ t.flag.toNat < 2 ^ f := by + rw [runPut_putTagN] + unfold Ixon.runGetExact at h + split at h + · rename_i a state hrun + split at h + · rename_i hidx + cases h + obtain ⟨⟨hs, hx⟩, hflag⟩ := getTagN_consumed f hf hrun + refine ⟨?_, hflag⟩ + subst hs + simp only [Nat.zero_add] at hidx hx + rw [← hx, hidx, ByteArray.extract_zero_size] + · cases h + · cases h + +/-- The full-buffer TagN decoder accepts exactly the encodings of in-range +flags and `UInt64` values: decoding is a bijection between accepted byte +strings and `{t | t.flag < 2^f}`. -/ +theorem runGetExact_getTagN_iff (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) + (bytes : ByteArray) (t : Ixon.TagN) : + Ixon.runGetExact (Ixon.getTagN f) bytes = .ok t ↔ + t.flag.toNat < 2 ^ f ∧ bytes = Ixon.runPut (Ixon.putTagN f t.flag t.value) := by + constructor + · intro h + obtain ⟨hb, hflag⟩ := runGetExact_getTagN_eq f hf h + exact ⟨hflag, hb⟩ + · rintro ⟨hflag, rfl⟩ + exact runGetExact_getTagN_putTagN f hf t.flag hflag t.value + +/-- Decoding is injective on accepted byte strings: no two distinct byte +strings decode to the same flag and value. -/ +theorem runGetExact_getTagN_inj (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) + {bytes₁ bytes₂ : ByteArray} {t : Ixon.TagN} + (h₁ : Ixon.runGetExact (Ixon.getTagN f) bytes₁ = .ok t) + (h₂ : Ixon.runGetExact (Ixon.getTagN f) bytes₂ = .ok t) : + bytes₁ = bytes₂ := by + rw [(runGetExact_getTagN_eq f hf h₁).1, (runGetExact_getTagN_eq f hf h₂).1] + +/-- Distinct values (or flags) have distinct encodings. -/ +theorem putTagN_inj (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) + {flag₁ flag₂ : UInt8} (hflag₁ : flag₁.toNat < 2 ^ f) (hflag₂ : flag₂.toNat < 2 ^ f) + {value₁ value₂ : UInt64} + (h : Ixon.runPut (Ixon.putTagN f flag₁ value₁) = + Ixon.runPut (Ixon.putTagN f flag₂ value₂)) : + flag₁ = flag₂ ∧ value₁ = value₂ := by + have h₁ := runGetExact_getTagN_putTagN f hf flag₁ hflag₁ value₁ + rw [h, runGetExact_getTagN_putTagN f hf flag₂ hflag₂ value₂] at h₁ + cases h₁ + exact ⟨rfl, rfl⟩ + +/-! ## Rejection -/ + +/-- A header whose `L = M = 1` code is 4 or more is rejected, whatever +follows it. Only `f = 0` and `f = 2` have such codes (`tagN4_code_valid`). -/ +theorem getTagN_rejects_code (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) + {s : Ixon.GetState} + (hcode : 2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) + 4 ≤ + (s.bytes[s.idx]!).toNat % 2 ^ (8 - f)) + (t : Ixon.TagN) (s' : Ixon.GetState) : + Ixon.getTagN f s ≠ .ok t s' := by + intro h + obtain ⟨hR, hlead, hmbit, -⟩ := tagN_consts f hf + unfold Ixon.getTagN at h + obtain ⟨b, s1, hb, h⟩ := bind_ok_inv h + obtain ⟨-, hbyte⟩ := getU8_ok hb + rw [hbyte] at hcode + simp only at h + generalize b.toNat % 2 ^ (8 - f) = p at h hcode + rw [if_neg (by omega), if_neg (by omega)] at h + unfold Ixon.getTagNWide at h + rw [if_neg (by omega), if_neg (by omega), if_neg (by omega), if_neg (by omega)] at h + exact throw_ok_false h + +/-- With a 4-bit flag every header code is valid: the `L = M = 1` code has two +bits and selects one of the 3-, 4-, 5- and 9-byte rungs. -/ +theorem tagN4_code_valid (b : UInt8) : + b.toNat % 2 ^ (8 - 4) < 2 ^ (8 - 4 - 1) + 2 ^ (8 - 4 - 2) + 4 := by + have := Nat.mod_lt b.toNat (show 0 < 2 ^ (8 - 4) by decide) + simp only [Nat.reduceSub, Nat.reducePow] at this ⊢ + omega + +/-- A 9-byte encoding whose value would reach `2^64` is rejected. -/ +theorem getTagN_rejects_overflow (f : Nat) (hf : f = 0 ∨ f = 2 ∨ f = 4) + (flag : UInt8) (hflag : flag.toNat < 2 ^ f) (x : UInt64) + (hx : 2 ^ 64 ≤ Ixon.tagNEnd5 f + x.toNat) (before after : ByteArray) + (t : Ixon.TagN) (s' : Ixon.GetState) : + Ixon.getTagN f { + idx := before.size + bytes := before ++ + [Ixon.tagNHeader f flag (2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) + 3)].toByteArray ++ + trimmedBytes x 8 ++ after } ≠ .ok t s' := by + intro h + obtain ⟨hR, hlead, hmbit, -⟩ := tagN_consts f hf + generalize hhdr : Ixon.tagNHeader f flag (2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) + 3) = hdr at h + obtain ⟨hdiv, hmod⟩ := tagNHeader_fields f hf flag hflag + (2 ^ (8 - f - 1) + 2 ^ (8 - f - 2) + 3) (by omega) + rw [hhdr] at hdiv hmod + unfold Ixon.getTagN at h + obtain ⟨b, s1, hb, h⟩ := bind_ok_inv h + rw [show before ++ [hdr].toByteArray ++ trimmedBytes x 8 ++ after = + before ++ [hdr].toByteArray ++ (trimmedBytes x 8 ++ after) by + simp [ByteArray.append_assoc], getU8_reads hdr before (trimmedBytes x 8 ++ after)] at hb + cases hb + simp only [hdiv, hmod] at h + rw [if_neg (by omega), if_neg (by omega)] at h + unfold Ixon.getTagNWide at h + rw [if_neg (by omega), if_neg (by omega), if_neg (by omega), if_pos (by omega)] at h + obtain ⟨y, s2, hy, h⟩ := bind_ok_inv h + have hr := getU64TrimmedLEAux_reads x 8 + (shiftBytes_eq_zero_of_lt x 8 (by simpa using x.toNat_lt)) + (before ++ [hdr].toByteArray) after + rw [ByteArray.size_append] at hr + rw [show before ++ [hdr].toByteArray ++ (trimmedBytes x 8 ++ after) = + before ++ [hdr].toByteArray ++ trimmedBytes x 8 ++ after by + simp [ByteArray.append_assoc], hr] at hy + cases hy + rw [if_neg (by omega)] at h + exact throw_ok_false h + +end Ix.Compile.Verify.TagN diff --git a/Ix/Compile/Verify/TieredGuard.lean b/Ix/Compile/Verify/TieredGuard.lean new file mode 100644 index 000000000..5c7c1bf19 --- /dev/null +++ b/Ix/Compile/Verify/TieredGuard.lean @@ -0,0 +1,1121 @@ +import Ix.Compile.Verify.TieredPhase3 + +/-! +# Tiered construction: phase 3 is never longer than phase 1 + +The phase-1 bodies and roots are writings of their terms (`gBuild_tree`); +every body only references terms that the allocated order places before it +(`allocate_spec`), so it is also a writing under each prefix dictionary of +phase 3. A writing's length is linear in its Share widths +(`WTree.gcost_eq`), so the phase-1 writings priced at the phase-3 indices +cost the phase-1 layout length minus the reference cost of the phase-1 +order plus that of the allocated order, which the guard keeps no larger. +Each phase-3 part is a minimum for its dictionary (`materializeTable_min`), +hence `rematerialize`'s length check can never fail +(`phase3_le_phase1`). + +The module also proves `allocate_optimal`: with the reference counts fixed, +when the phase-1 table has at most `tier2End` entries (so every index from 8 +on has width 2), the allocated order has the minimum reference cost +`Σ ref · widthAt (index)` among all orders of the table that place every +body reference before its user. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact + +/-! ## Leaves and the length of a writing -/ + +mutual +/-- The Share leaves of a writing, left to right. -/ +def WTree.leaves : WTree → List Nat + | .share x => [x] + | .node _ kids => WTree.leavesL kids + | .tele _ _ sides tail => WTree.leavesL sides ++ WTree.leaves tail +/-- The Share leaves of a list of writings. -/ +def WTree.leavesL : List WTree → List Nat + | [] => [] + | k :: ks => WTree.leaves k ++ WTree.leavesL ks +end + +mutual +/-- The length of a writing without its Shares. -/ +def WTree.base (p : Prep) : WTree → Nat + | .share _ => 0 + | .node x kids => (p.dag.node x).head.ownBytes + WTree.baseL p kids + | .tele x j sides tail => + tag4Size j + j * (p.dag.node x).sideExtra + WTree.baseL p sides + WTree.base p tail +/-- The total base length of a list of writings. -/ +def WTree.baseL (p : Prep) : List WTree → Nat + | [] => 0 + | k :: ks => WTree.base p k + WTree.baseL p ks +end + +mutual +/-- **Linearity.** A writing's length is its base length plus the widths of +its Share leaves. -/ +theorem WTree.gcost_eq (p : Prep) (wd : Nat → Nat) : + ∀ T : WTree, T.gcost p wd = T.base p + (T.leaves.map wd).sum + | .share x => by simp [WTree.gcost, WTree.base, WTree.leaves] + | .node x kids => by + simp only [WTree.gcost, WTree.base, WTree.leaves, WTree.gcosts_eq' p wd kids] + omega + | .tele x j sides tail => by + simp only [WTree.gcost, WTree.base, WTree.leaves, WTree.gcosts_eq' p wd sides, + WTree.gcost_eq p wd tail, List.map_append, List.sum_append] + omega +theorem WTree.gcosts_eq' (p : Prep) (wd : Nat → Nat) : + ∀ L : List WTree, WTree.gcosts p wd L = WTree.baseL p L + ((WTree.leavesL L).map wd).sum + | [] => by simp [WTree.gcosts, WTree.baseL, WTree.leavesL] + | k :: ks => by + simp only [WTree.gcosts, WTree.baseL, WTree.leavesL, WTree.gcost_eq p wd k, + WTree.gcosts_eq' p wd ks, List.map_append, List.sum_append] + omega +end + +theorem mem_leavesL_iff {L : List WTree} {y : Nat} : + y ∈ WTree.leavesL L ↔ ∃ i, ∃ h : i < L.length, y ∈ (L[i]).leaves := by + induction L with + | nil => simp [WTree.leavesL] + | cons a L ih => + simp only [WTree.leavesL, List.mem_append, ih] + constructor + · rintro (h | ⟨i, hi, h⟩) + · exact ⟨0, by simp, h⟩ + · exact ⟨i + 1, by simp; omega, by simpa using h⟩ + · rintro ⟨i, hi, h⟩ + cases i with + | zero => exact Or.inl h + | succ i => exact Or.inr ⟨i, by simp at hi; omega, by simpa using h⟩ + +theorem mem_leavesL {L : List WTree} {k : Nat} (hk : k < L.length) {y : Nat} + (hy : y ∈ (L[k]).leaves) : y ∈ WTree.leavesL L := by + induction L generalizing k with + | nil => cases hk + | cons a L ih => + simp only [WTree.leavesL, List.mem_append] + cases k with + | zero => exact Or.inl hy + | succ k => exact Or.inr (ih (by simp at hk; omega) hy) + +/-- A writing stays valid when only its Share leaves are known available. -/ +theorem Valid.mono_leaves {p : Prep} {S S' : Nat → Bool} {x : Nat} {T : WTree} + (h : Valid p S x T) (hS : ∀ y ∈ T.leaves, S' y = true) : Valid p S' x T := by + induction h with + | share _ => exact .share (hS _ (by simp [WTree.leaves])) + | node hf hlen _ ih => + exact .node hf hlen fun i hi => ih i hi fun y hy => + hS y (by simp only [WTree.leaves]; exact mem_leavesL hi hy) + | teleCut hf hj1 hj hlen _ _ ih => + refine .teleCut hf hj1 hj hlen (fun k hk => ih k hk fun y hy => hS y ?_) (hS _ ?_) + · simp only [WTree.leaves, List.mem_append]; exact Or.inl (mem_leavesL hk hy) + · simp [WTree.leaves] + | teleFull hf hlen _ _ ih iht => + refine .teleFull hf hlen (fun k hk => ih k hk fun y hy => hS y ?_) + (iht fun y hy => hS y ?_) + · simp only [WTree.leaves, List.mem_append]; exact Or.inl (mem_leavesL hk hy) + · simp only [WTree.leaves, List.mem_append]; exact Or.inr hy + +/-! ## Share lists -/ + +/-- The Share indices of an expression, left to right. -/ +def shareList (e : Ixon.Expr) : List Nat := (shareIndices e #[]).toList + +theorem shareIndices_acc : ∀ (e : Ixon.Expr) (acc : Array Nat), + (shareIndices e acc).toList = acc.toList ++ shareList e := by + intro e + induction e with + | share i => intro acc; simp [shareIndices, shareList] + | prj _ _ v ih => intro acc; simp only [shareIndices, shareList]; rw [ih, ih #[]]; simp + | app f a ihf iha => + intro acc + simp only [shareIndices, shareList] + rw [iha, ihf, iha (shareIndices f #[]), ihf #[]] + simp + | lam _ t b iht ihb => + intro acc + simp only [shareIndices, shareList] + rw [ihb, iht, ihb (shareIndices t #[]), iht #[]] + simp + | all _ _ t b iht ihb => + intro acc + simp only [shareIndices, shareList] + rw [ihb, iht, ihb (shareIndices t #[]), iht #[]] + simp + | letE _ t v b iht ihv ihb => + intro acc + simp only [shareIndices, shareList] + rw [ihb, ihv, iht, ihb (shareIndices v (shareIndices t #[])), ihv (shareIndices t #[]), + iht #[]] + simp + | sort _ | var _ | ref _ _ | recur _ _ | str _ | nat _ => + intro acc; simp [shareIndices, shareList] + +theorem shareList_app (f a : Ixon.Expr) : shareList (.app f a) = shareList f ++ shareList a := by + unfold shareList; simp only [shareIndices]; rw [shareIndices_acc]; rfl +theorem shareList_lam (c : Ixon.BinderContract) (t b : Ixon.Expr) : + shareList (.lam c t b) = shareList t ++ shareList b := by + unfold shareList; simp only [shareIndices]; rw [shareIndices_acc]; rfl +theorem shareList_all (c : Ixon.BinderContract) (r : Ixon.ValueContract) (t b : Ixon.Expr) : + shareList (.all c r t b) = shareList t ++ shareList b := by + unfold shareList; simp only [shareIndices]; rw [shareIndices_acc]; rfl +theorem shareList_prj (ti f : UInt64) (v : Ixon.Expr) : shareList (.prj ti f v) = shareList v := by + unfold shareList; simp only [shareIndices] +theorem shareList_letE (c : Ixon.LetContract) (t v b : Ixon.Expr) : + shareList (.letE c t v b) = shareList t ++ shareList v ++ shareList b := by + unfold shareList; simp only [shareIndices]; rw [shareIndices_acc, shareIndices_acc]; rfl +theorem shareList_share (i : UInt64) : shareList (.share i) = [i.toNat] := by + simp [shareList, shareIndices] + +theorem rebuild_shares {n : Node} {inner side e : Ixon.Expr} (h : rebuildSpineNode n inner side = .ok e) : + (shareList e).Perm (shareList side ++ shareList inner) := by + unfold rebuildSpineNode at h + cases hh : n.head <;> simp only [hh] at h <;> try cases h + · rw [shareList_app]; exact List.perm_append_comm + · rw [shareList_lam] + · rw [shareList_all] + +/-- The Shares of a rebuilt telescope are those of its sides and its tail. -/ +theorem spineFold_shares' (buildSide : Node → Except SharingError Ixon.Expr) (S : Node → List Nat) : + ∀ (ns : List Node) (tail e : Ixon.Expr), + (∀ n ∈ ns, ∀ e', buildSide n = .ok e' → (shareList e').Perm (S n)) → + ns.foldrM (fun n acc => do let side ← buildSide n; rebuildSpineNode n acc side) tail = + .ok e → + (shareList e).Perm (ns.flatMap S ++ shareList tail) := by + intro ns + induction ns with + | nil => intro tail e _ h; simp only [List.foldrM_nil] at h; cases h; simp + | cons n ns ih => + intro tail e hS h + rw [List.foldrM_cons] at h + obtain ⟨acc, hacc, hstep⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + obtain ⟨side, hs, hre⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok hstep + have h1 := ih tail acc (fun m hm => hS m (List.mem_cons_of_mem _ hm)) hacc + have h2 := rebuild_shares hre + have h3 := hS n List.mem_cons_self side hs + refine h2.trans ?_ + simp only [List.flatMap_cons, List.append_assoc] + exact h3.append h1 + +/-- Every side of a successfully rebuilt telescope was built. -/ +theorem spineFold_sides_ok (buildSide : Node → Except SharingError Ixon.Expr) : + ∀ (ns : List Node) (tail e : Ixon.Expr), + ns.foldrM (fun n acc => do let side ← buildSide n; rebuildSpineNode n acc side) tail = + .ok e → ∀ n ∈ ns, ∃ e', buildSide n = .ok e' := by + intro ns + induction ns with + | nil => intro _ _ _ n hn; cases hn + | cons m ns ih => + intro tail e h n hn + rw [List.foldrM_cons] at h + obtain ⟨acc, hacc, hstep⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + obtain ⟨side, hs, _⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok hstep + rcases List.mem_cons.mp hn with rfl | hn + · exact ⟨side, hs⟩ + · exact ih tail acc hacc n hn + +theorem leavesL_map (f : Nat → Nat) : + ∀ L : List WTree, (WTree.leavesL L).map f = L.flatMap fun T => T.leaves.map f + | [] => by simp [WTree.leavesL] + | k :: ks => by simp [WTree.leavesL, leavesL_map f ks] + +/-! ## The writing a build emits -/ + +/-- `T` is the writing of the expression `e` built for `t`: a valid writing +with the dictionary `avail`, inline if it is an entry body, with the Shares +of `e` as its leaves (by index), and with the length of `e` under every Share +pricing `sc` that matches leaf widths `wd'`. -/ +def TreeOf (p : Prep) (avail : Nat → Bool) (index : Array (Option Nat)) (entry : Bool) (t : Nat) + (e : Ixon.Expr) (T : WTree) : Prop := + Valid p avail t T ∧ (entry = true → T.isShare = false) ∧ + (T.leaves.map fun u => (index[u]?.getD none).getD 0).Perm (shareList e) ∧ + ∀ (sc wd' : Nat → Nat), (∀ (u i : Nat), index[u]?.getD none = some i → sc i = wd' u) → + (sizeInfoWith sc e).full = T.gcost p wd' ∧ OnlyCont p.family[t]! (sizeInfoWith sc e) + +open Ix.Compile.Verify.SharingExact (bind_eq_ok toNat_toUInt64_of_lt pickOption_mem + pickOption_filter_ne_share) in +/-- **The writing of a build.** Every expression `build` emits (against an +evaluation with the model rows of the dictionary) is a writing of its term +whose length, under any Share pricing, is the writing's length at the +matching leaf widths, and whose leaves are its Shares. -/ +theorem PrepWF.gBuild_tree {p : Prep} (hp : PrepWF p) + {wd : Nat → Nat} {avail : Nat → Bool} (ev : DictEval) (hev : GEvalOK p wd avail ev) + (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) + (hindex : ∀ (u : Nat), (index[u]?.getD none).isSome = avail u) + (hidx : ∀ (u i : Nat), index[u]?.getD none = some i → i < UInt64.size) : + ∀ (fuel : Nat) (entry : Bool) (t : Nat) (e : Ixon.Expr), t < p.dag.size → + p.build ev index width entry fuel t = .ok e → ∃ T, TreeOf p avail index entry t e T := by + have hshare : ∀ (u i : Nat) (sc wd' : Nat → Nat), index[u]?.getD none = some i → + (∀ (u i : Nat), index[u]?.getD none = some i → sc i = wd' u) → + (sizeInfoWith sc (.share i.toUInt64)).full = wd' u := by + intro u i sc wd' hi hsc + simp only [sizeInfoWith, SizeInfo.plain, toNat_toUInt64_of_lt (hidx u i hi), hsc u i hi] + have hleaf : ∀ (u i : Nat), index[u]?.getD none = some i → + ([u].map fun u => (index[u]?.getD none).getD 0).Perm (shareList (.share i.toUInt64)) := by + intro u i hi + rw [shareList_share, toNat_toUInt64_of_lt (hidx u i hi)] + simp [hi] + intro fuel + induction fuel with + | zero => intro entry t e _ h; simp [Prep.build] at h + | succ fuel ih => + intro entry t e ht h + -- the writings of the children, chosen once per term + have hex : ∀ c e', c < p.dag.size → p.build ev index width false fuel c = .ok e' → + ∃ T, TreeOf p avail index false c e' T := fun c e' hc he => ih false c e' hc he + classical + let Tof : Nat → WTree := fun c => + if hc : ∃ e', c < p.dag.size ∧ p.build ev index width false fuel c = .ok e' then + Classical.choose (hex c (Classical.choose hc) (Classical.choose_spec hc).1 + (Classical.choose_spec hc).2) + else default + have hTof : ∀ c e', c < p.dag.size → p.build ev index width false fuel c = .ok e' → + TreeOf p avail index false c e' (Tof c) := by + intro c e' hc he + have hc' : ∃ e', c < p.dag.size ∧ p.build ev index width false fuel c = .ok e' := + ⟨e', hc, he⟩ + simp only [Tof, dif_pos hc'] + have hsame : Classical.choose hc' = e' := by + have h2 : (Except.ok (Classical.choose hc') : Except SharingError Ixon.Expr) = .ok e' := + (Classical.choose_spec hc').2.symm.trans he + exact Except.ok.inj h2 + have := Classical.choose_spec (hex c (Classical.choose hc') (Classical.choose_spec hc').1 + (Classical.choose_spec hc').2) + have key : ∀ x T, x = e' → TreeOf p avail index false c x T → TreeOf p avail index false c e' T := by + intro x T hx hT; subst hx; exact hT + exact key _ _ hsame this + simp only [Prep.build] at h + split at h + · rename_i choice c hpick + have hent : entry = true → choice ≠ .share := by + intro he + subst he + simp only [if_true] at hpick + exact pickOption_filter_ne_share _ hpick + split at h + · rename_i hcheck + obtain ⟨b, hb⟩ := pickOption_mem _ hpick + have hmem : (choice, c, b) ∈ (p.options ev index width t).toList := by + split at hb + · rw [Array.toList_filter] at hb; exact (List.mem_filter.mp hb).1 + · exact hb + have hopt := hp.gOptions_mem ev hev index width hwidth hindex ht hmem + split at h + · -- Share + split at h + · rename_i i hi + cases h + refine ⟨.share t, .share (by rw [← hindex, hi]; rfl), fun he => absurd rfl (hent he), + hleaf t i hi, fun sc wd' hsc => ⟨hshare t i sc wd' hi hsc, share_onlyCont sc _ _⟩⟩ + · cases h + · -- inline node + obtain ⟨h1, _⟩ | ⟨_, hf, _⟩ | ⟨j, h1, _⟩ := hopt + · cases h1 + · have har := hp.dag.arity t ht + rw [← dag_node_eq ht] at har + cases hh : (p.dag.node t).head <;> simp only [hh] at h har + case prj ti f => + obtain ⟨v, hv, hpure⟩ := bind_eq_ok h + cases hpure + have hc0 : (p.dag.node t).child 0 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + obtain ⟨hvV, -, hvL, hvS⟩ := hTof _ v (by omega) hv + refine ⟨.node t [Tof ((p.dag.node t).child 0)], + .node hf (by simp [hh, Head.arity]) (fun i hi => ?_), fun _ => rfl, ?_, + fun sc wd' hsc => ⟨?_, fun F' _ => by cases F' <;> rfl⟩⟩ + · have : i = 0 := by simpa using hi + subst this + exact hvV + · simp only [WTree.leaves, WTree.leavesL, List.append_nil, shareList_prj] + exact hvL + · simp [WTree.gcost, WTree.gcosts, sizeInfoWith, SizeInfo.plain, Head.ownBytes, hh, + (hvS sc wd' hsc).1] <;> omega + case letE lc => + obtain ⟨ty, hty, h2⟩ := bind_eq_ok h + obtain ⟨v, hv, h3⟩ := bind_eq_ok h2 + obtain ⟨bd, hbd, hpure⟩ := bind_eq_ok h3 + cases hpure + have hc0 : (p.dag.node t).child 0 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + have hc1 : (p.dag.node t).child 1 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + have hc2 : (p.dag.node t).child 2 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + obtain ⟨h0V, -, h0L, h0S⟩ := hTof _ ty (by omega) hty + obtain ⟨h1V, -, h1L, h1S⟩ := hTof _ v (by omega) hv + obtain ⟨h2V, -, h2L, h2S⟩ := hTof _ bd (by omega) hbd + refine ⟨.node t [Tof ((p.dag.node t).child 0), Tof ((p.dag.node t).child 1), + Tof ((p.dag.node t).child 2)], + .node hf (by simp [hh, Head.arity]) (fun i hi => ?_), fun _ => rfl, ?_, + fun sc wd' hsc => ⟨?_, fun F' _ => by cases F' <;> rfl⟩⟩ + · simp only [List.length_cons, List.length_nil] at hi + rcases (by omega : i = 0 ∨ i = 1 ∨ i = 2) with rfl | rfl | rfl + · exact h0V + · exact h1V + · exact h2V + · simp only [WTree.leaves, WTree.leavesL, List.append_nil, shareList_letE, + List.map_append] + rw [List.append_assoc] + exact h0L.append (h1L.append h2L) + · simp [WTree.gcost, WTree.gcosts, sizeInfoWith, SizeInfo.plain, Head.ownBytes, hh, + (h0S sc wd' hsc).1, (h1S sc wd' hsc).1, (h2S sc wd' hsc).1] <;> omega + all_goals first + | (cases h; done) + | (cases h + simp only [Node.toExpr, hh] + refine ⟨.node t [], .node hf (by simp [hh, Head.arity]) + (fun i hi => absurd hi (by simp)), fun _ => rfl, ?_, + fun sc wd' hsc => ⟨?_, fun F' _ => by cases F' <;> rfl⟩⟩ + · simp [WTree.leaves, WTree.leavesL, shareList, shareIndices] + · simp [WTree.gcost, WTree.gcosts, hh, sizeInfoWith, SizeInfo.plain, + Head.ownBytes]) + · cases h1 + · -- telescope cut + rename_i j + obtain ⟨h1, _⟩ | ⟨h1, _⟩ | ⟨j', hj', hf, hj1, hjl, hcase⟩ := hopt + · cases h1 + · cases h1 + cases hj' + obtain ⟨_, hk, hend, htl, htf⟩ := hp.spine t ht hf + let ns := (List.range j).map (fun k => p.dag.node (spineAt p t k)) + let sides := (List.range j).map (fun k => Tof (sideAt p t k)) + let idx : Nat → Nat := fun u => (index[u]?.getD none).getD 0 + have hfam : ∀ n ∈ ns, n.head.family = p.family[t]! := by + intro n hn + obtain ⟨k, hk', rfl⟩ := List.mem_map.mp hn + rw [List.mem_range] at hk' + obtain ⟨hle, hkf, _, _⟩ := hk k (by omega) + rw [← hp.family _ (by omega), hkf] + have hsideLt : ∀ k, k < j → sideAt p t k < p.dag.size := fun k hk' => by + have := hp.sideAt_lt ht hf (k := k) (by omega); omega + have hlen : ns.length = j := by simp [ns] + have hne : ns ≠ [] := by + intro h0 + have := congrArg List.length h0 + simp [ns] at this + omega + -- the side writings + have hsideTree : ∀ n ∈ ns, ∀ e', + p.build ev index width false fuel n.sideChild = .ok e' → + TreeOf p avail index false n.sideChild e' (Tof n.sideChild) := by + intro n hn e' he' + obtain ⟨k, hk', rfl⟩ := List.mem_map.mp hn + rw [List.mem_range] at hk' + exact hTof _ e' (hsideLt k hk') he' + have hsum : ∀ (wd' : Nat → Nat), (ns.map fun n => + n.sideExtra + (Tof n.sideChild).gcost p wd').sum = + j * (p.dag.node t).sideExtra + WTree.gcosts p wd' sides := by + intro wd' + have : ∀ k ∈ List.range j, (p.dag.node (spineAt p t k)).sideExtra + + (Tof (p.dag.node (spineAt p t k)).sideChild).gcost p wd' = + (p.dag.node t).sideExtra + (Tof (sideAt p t k)).gcost p wd' := by + intro k hk' + rw [List.mem_range] at hk' + rw [hp.sideExtra_spine ht hf (by omega)] + rfl + simp only [ns, List.map_map] + rw [show ((fun n : Node => n.sideExtra + (Tof n.sideChild).gcost p wd') ∘ + fun k => p.dag.node (spineAt p t k)) = fun k => + (p.dag.node (spineAt p t k)).sideExtra + + (Tof (p.dag.node (spineAt p t k)).sideChild).gcost p wd' from rfl, + List.map_congr_left this, sum_map_const_add, WTree.gcosts_eq] + simp [sides, List.map_map] + rfl + have hflat : ns.flatMap (fun n => (Tof n.sideChild).leaves.map idx) = + (WTree.leavesL sides).map idx := by + rw [leavesL_map] + simp only [ns, sides, List.flatMap_map] + rfl + have hsidesValid : ∀ (k : Nat) (h : k < sides.length), + (∃ e', p.build ev index width false fuel (sideAt p t k) = .ok e') → + Valid p avail (sideAt p t k) sides[k] := by + intro k hk' ⟨e', he'⟩ + simp only [sides, List.getElem_map, List.getElem_range] + exact (hTof _ e' (hsideLt k (by simpa [sides] using hk')) he').1 + rw [spineWalk_eq] at h + split at h + · cases h + split at h + · -- the prefix ends in a Share + rename_i _ hjlt + split at h + · rename_i i hi + obtain ⟨tl, htl', hfold⟩ := bind_eq_ok h + cases htl' + have hsideOK : ∀ (k : Nat), k < j → + ∃ e', p.build ev index width false fuel (sideAt p t k) = .ok e' := by + intro k hk' + exact spineFold_sides_ok _ ns _ _ hfold _ + (List.mem_map.mpr ⟨k, List.mem_range.mpr hk', rfl⟩) + have hcur : avail (spineAt p t j) = true := by rw [← hindex, hi]; rfl + refine ⟨.tele t j sides (.share (spineAt p t j)), + .teleCut hf hj1 hjlt (by simp [sides]) + (fun k hk' => hsidesValid k hk' (hsideOK k (by simpa [sides] using hk'))) hcur, + fun _ => rfl, ?_, fun sc wd' hsc => ?_⟩ + · have hsh := spineFold_shares' _ (fun n => (Tof n.sideChild).leaves.map idx) ns _ _ + (fun n hn e' he' => ((hsideTree n hn e' he').2.2.1).symm) hfold + simp only [WTree.leaves, List.map_append] + rw [← hflat] + refine List.Perm.trans ?_ hsh.symm + exact List.Perm.append (List.Perm.refl _) (hleaf _ i hi) + · obtain ⟨_, hfull, honly⟩ := spineFold_size sc p.family[t]! _ + (fun n => (Tof n.sideChild).gcost p wd') _ _ _ hfam + (fun n hn e' he' => ((hsideTree n hn e' he').2.2.2 sc wd' hsc).1) + (by cases p.family[t]! <;> rfl) hfold + refine ⟨?_, honly hne⟩ + rw [hfull hne, hlen, hsum wd', hshare _ i sc wd' hi hsc] + simp only [WTree.gcost] + omega + · obtain ⟨tl, htl', _⟩ := bind_eq_ok h + cases htl' + · -- the full spine ends in the natural tail + rename_i _ hjlt + have hjeq : j = p.spineLen[t]! := by omega + obtain ⟨tl, htl', hfold⟩ := bind_eq_ok h + simp only at htl' + rw [hjeq, hend] at htl' + have hsideOK : ∀ (k : Nat), k < j → + ∃ e', p.build ev index width false fuel (sideAt p t k) = .ok e' := by + intro k hk' + exact spineFold_sides_ok _ ns _ _ hfold _ + (List.mem_map.mpr ⟨k, List.mem_range.mpr hk', rfl⟩) + obtain ⟨htV, -, htL, htS⟩ := hTof _ tl (by omega) htl' + have hvalid : Valid p avail t (.tele t p.spineLen[t]! sides (Tof p.tail[t]!)) := + .teleFull hf (by simp [sides, hjeq]) + (fun k hk' => hsidesValid k hk' (hsideOK k (by simpa [sides] using hk'))) htV + rw [← hjeq] at hvalid + refine ⟨.tele t j sides (Tof p.tail[t]!), hvalid, fun _ => rfl, ?_, + fun sc wd' hsc => ?_⟩ + · have hsh := spineFold_shares' _ (fun n => (Tof n.sideChild).leaves.map idx) ns _ _ + (fun n hn e' he' => ((hsideTree n hn e' he').2.2.1).symm) hfold + simp only [WTree.leaves, List.map_append] + rw [← hflat] + exact List.Perm.trans (List.Perm.append (List.Perm.refl _) htL) hsh.symm + · obtain ⟨htfull, htonly⟩ := htS sc wd' hsc + obtain ⟨_, hfull, honly⟩ := spineFold_size sc p.family[t]! _ + (fun n => (Tof n.sideChild).gcost p wd') _ _ _ hfam + (fun n hn e' he' => ((hsideTree n hn e' he').2.2.2 sc wd' hsc).1) + (htonly _ (Ne.symm htf)) hfold + refine ⟨?_, honly hne⟩ + rw [hfull hne, hlen, hsum wd', htfull] + simp only [WTree.gcost] + omega + + · cases h + · cases h + +/-- The leaves of a valid writing are available. -/ +theorem Valid.leaves_avail {p : Prep} {S : Nat → Bool} {x : Nat} {T : WTree} + (h : Valid p S x T) : ∀ y ∈ T.leaves, S y = true := by + induction h with + | share hS => intro y hy; simp [WTree.leaves] at hy; subst hy; exact hS + | node _ _ _ ih => + intro y hy + simp only [WTree.leaves] at hy + obtain ⟨i, hi, hyi⟩ := mem_leavesL_iff.mp hy + exact ih i hi y hyi + | teleCut _ _ _ _ _ hS ih => + intro y hy + simp only [WTree.leaves, List.mem_append] at hy + rcases hy with hy | hy + · obtain ⟨i, hi, hyi⟩ := mem_leavesL_iff.mp hy + exact ih i hi y hyi + · simp at hy; subst hy; exact hS + | teleFull _ _ _ _ ih iht => + intro y hy + simp only [WTree.leaves, List.mem_append] at hy + rcases hy with hy | hy + · obtain ⟨i, hi, hyi⟩ := mem_leavesL_iff.mp hy + exact ih i hi y hyi + · exact iht y hy + +/-! ## The phase-1 writings -/ + +open Ix.Compile.Verify.SharingExact (materializeDependent_parts indexOfTable_spec) in +/-- The phase-1 table bodies and roots are writings with the phase-1 +dictionary (its stored set, Shares by phase-1 index). -/ +theorem phase1_trees {w : Nat} {limits : Limits} {ex : Expanded} {u : UniformSharingResult} + (hu : optimizeUniformExpanded w limits ex = .ok u) : + DagWF ex.dag ∧ (∀ r ∈ ex.roots.toList, r < ex.dag.size) ∧ + (∀ t ∈ u.result.tableTerms.toList, t < ex.dag.size) ∧ + u.result.tableTerms.size < UInt64.size ∧ + (∀ t, ((indexOfPairs ex.dag.size u.result.tableTerms.toList.zipIdx)[t]?.getD none).isSome = + decide (t ∈ u.result.tableTerms.toList)) ∧ + List.Forall₂ (fun t e => ∃ T, TreeOf (Prep.ofDag ex.dag) + (fun t => decide (t ∈ u.result.tableTerms.toList)) + (indexOfPairs ex.dag.size u.result.tableTerms.toList.zipIdx) true t e T) + u.result.tableTerms.toList u.result.sharing.toList ∧ + List.Forall₂ (fun r e => ∃ T, TreeOf (Prep.ofDag ex.dag) + (fun t => decide (t ∈ u.result.tableTerms.toList)) + (indexOfPairs ex.dag.size u.result.tableTerms.toList.zipIdx) false r e T) + ex.roots.toList u.result.roots.toList := by + obtain ⟨_, hwf, hroots, _, _, c, _, hfin⟩ := optimizeUniform_parts hu + obtain ⟨hin, _, _, htable, _, work, hmat, _⟩ := uniformFinish_spec hfin + have hp := prepWF_ofDag hwf + have hperm : u.result.tableTerms.toList.Perm c.stored.toList := by + rw [htable]; exact pinnedOrder_perm _ _ _ + have hin' : ∀ t ∈ u.result.tableTerms.toList, t < ex.dag.size := + fun t ht => hin t (hperm.subset ht) + obtain ⟨hsize, hents, hrts⟩ := materializeDependent_parts _ _ _ _ _ hmat + rw [← htable] at hsize hents hrts + let width1 := c.stored.foldl (fun acc t => acc.set! t (some w)) (Array.replicate ex.dag.size none) + let avail1 := fun t => decide (t ∈ u.result.tableTerms.toList) + let index1 := indexOfPairs ex.dag.size u.result.tableTerms.toList.zipIdx + have hwidth : ∀ t, widthOf width1 t = if avail1 t then some w else none := by + intro t + simp only [width1, avail1] + rw [← Array.foldl_toList, widthOfStored ex.dag.size w c.stored.toList hin t] + simp only [hperm.mem_iff] + have hindex : ∀ t, (index1[t]?.getD none).isSome = avail1 t := + fun t => indexOfTable_isSome _ _ hin' t + have hidx : ∀ (t i : Nat), index1[t]?.getD none = some i → i < UInt64.size := by + intro t i hi + have := indexOfTable_spec _ _ t i hi + have := (Array.getElem?_eq_some_iff.mp this).1 + omega + have hev := hp.evalAll_ok (ofDag_empty_size ex.dag) (wd := fun _ => w) (avail := avail1) + width1 hwidth + refine ⟨hwf, hroots, hin', hsize, hindex, ?_, ?_⟩ + · refine Ix.Compile.Verify.Tiered.forall₂_imp_mem hents fun t ht e he => ?_ + exact hp.gBuild_tree _ hev index1 width1 hwidth hindex hidx _ true t e (hin' t ht) he + · refine Ix.Compile.Verify.Tiered.forall₂_imp_mem hrts fun r hr e he => ?_ + exact hp.gBuild_tree _ hev index1 width1 hwidth hindex hidx _ false r e (hroots r hr) he + +end Ix.Compile.Verify.UniformModel + +namespace Ix.Compile.Verify.Tiered + +open Ix.Sharing.Exact +open Ix.Compile.Verify.UniformModel +open Ix.Compile.Verify.SharingExact (indexOfPrefix_spec indexOfTable_spec) + +/-! ## Sums -/ + +theorem sum_range_array (arr : Array Nat) (F : Nat → Nat) : + ((List.range arr.size).map fun i => F arr[i]!).sum = (arr.toList.map F).sum := by + congr 1 + apply List.ext_getElem (by simp) + intro i h1 h2 + simp only [List.getElem_map, List.getElem_range, Array.getElem_toList] + rw [getElem!_pos arr i (by simpa using h1)] + +theorem refCost_eq_sum (layout : ShareLayout) (weight : Nat → Nat) (ord : Array Nat) : + refCost layout weight ord = + ((List.range ord.size).map fun k => weight ord[k]! * layout.widthAt k).sum := by + unfold refCost + rw [← Array.foldl_toList, Ix.Compile.Verify.UniformModel.foldl_add_eq_sum, Nat.zero_add] + congr 1 + apply List.ext_getElem (by simp) + intro k h1 h2 + simp only [List.getElem_map, List.getElem_range, Array.toList_zipIdx, List.getElem_zipIdx] + rw [getElem!_pos ord k (by simpa using h2)] + simp + +theorem sum_map_zero : ∀ (l : List Nat), (l.map fun _ => (0 : Nat)).sum = 0 + | [] => rfl + | _ :: l => by simp [sum_map_zero l] + +theorem sum_count (N : Nat) (g : Nat → Nat) : + ∀ (A : List Nat), (∀ j ∈ A, j < N) → + ((List.range N).map fun i => A.count i * g i).sum = (A.map g).sum := by + intro A + induction A with + | nil => intro _; simp only [List.count_nil, Nat.zero_mul, List.map_nil, List.sum_nil]; exact sum_map_zero _ + | cons a A ih => + intro hA + have ha := hA a List.mem_cons_self + have h1 : ((List.range N).map fun i => (a :: A).count i * g i) = + List.zipWith (· + ·) ((List.range N).map fun i => A.count i * g i) + ((List.range N).map fun i => if a = i then g i else 0) := by + apply List.ext_getElem (by simp) + intro i h1 h2 + simp only [List.getElem_map, List.getElem_range, List.getElem_zipWith, List.count_cons] + by_cases hai : a = i + · subst hai; simp [Nat.add_mul] + · simp [hai] + have hsplit : ∀ (l1 l2 : List Nat), l1.length = l2.length → + (List.zipWith (· + ·) l1 l2).sum = l1.sum + l2.sum := by + intro l1 + induction l1 with + | nil => intro l2 h; cases l2 <;> simp_all + | cons x xs ih' => + intro l2 h + cases l2 with + | nil => simp at h + | cons y ys => + simp only [List.zipWith_cons_cons, List.sum_cons] + rw [ih' ys (by simpa using h)] + omega + have hone : ((List.range N).map fun i => if a = i then g i else 0).sum = g a := by + have : ∀ M, a < M → ((List.range M).map fun i => if a = i then g i else 0).sum = g a := by + intro M + induction M with + | zero => intro h; omega + | succ M ihM => + intro h + rw [List.range_succ, List.map_append, List.sum_append] + by_cases haM : a = M + · subst haM + have : ((List.range a).map fun i => if a = i then g i else 0).sum = 0 := by + rw [List.map_congr_left (g := fun _ => 0) (fun i hi => by + rw [List.mem_range] at hi; simp [show a ≠ i by omega])] + exact sum_map_zero _ + simp [this] + · rw [ihM (by omega)] + simp [haM] + exact this N ha + rw [h1, hsplit _ _ (by simp), ih (fun j hj => hA j (List.mem_cons_of_mem _ hj)), hone] + simp + omega + +theorem sum_map_flatMap {α : Type} (f : α → List Nat) (g : Nat → Nat) : + ∀ (L : List α), ((L.flatMap f).map g).sum = (L.map fun x => ((f x).map g).sum).sum + | [] => rfl + | x :: xs => by + simp only [List.flatMap_cons, List.map_append, List.sum_append, List.map_cons, List.sum_cons, + sum_map_flatMap f g xs] + +/-! ## Parts and prefix lookups -/ + +/-- One part: a re-materialized part no longer than any writing for its +dictionary, against a phase-1 writing whose leaves are in that dictionary. -/ +theorem part_le {P : Prep} {S S' : Nat → Bool} {t : Nat} {T : WTree} {wd1 wd3 : Nat → Nat} + {size1 size3 : Nat} (hT : Valid P S t T) (hleaves : ∀ l ∈ T.leaves, S' l = true) + (hmin : ∀ T', Valid P S' t T' → size3 ≤ T'.gcost P wd3) (h1 : size1 = T.gcost P wd1) : + size3 + (T.leaves.map wd1).sum ≤ size1 + (T.leaves.map wd3).sum := by + have := hmin T (hT.mono_leaves hleaves) + rw [WTree.gcost_eq] at this h1 + omega + +/-- In a table without repeats, the prefix dictionary of `k` entries maps +entry `j < k` to `j`. -/ +theorem prefix_lookup {n : Nat} {table : Array Nat} (hnd : table.toList.Nodup) + {j k d : Nat} (hj : table[j]? = some d) (hjk : j < k) (hd : d < n) : + (indexOfPrefix n table k)[d]?.getD none = some j := by + have hjs : j < table.size := (Array.getElem?_eq_some_iff.mp hj).1 + have hsome : ((indexOfPrefix n table k)[d]?.getD none).isSome = true := by + unfold indexOfPrefix indexOfPairs + apply indexOfPairs_isSome _ _ d (by simp; exact hd) + refine Or.inr ⟨j, List.mem_zipIdx_iff_getElem?.mpr ?_⟩ + simp only [List.getElem?_take] + rw [if_pos hjk] + simpa using hj + obtain ⟨i, hi⟩ := Option.isSome_iff_exists.mp hsome + obtain ⟨hik, hti⟩ := indexOfPrefix_spec n table k d i hi + have his : i < table.size := (Array.getElem?_eq_some_iff.mp hti).1 + have : i = j := getBang_inj hnd his hjs (by + rw [getElem!_pos table i his, getElem!_pos table j hjs] + have h1 := (Array.getElem?_eq_some_iff.mp hti).2 + have h2 := (Array.getElem?_eq_some_iff.mp hj).2 + rw [h1, h2]) + rw [hi, this] + +/-! ## Phase 3 is never longer than phase 1 -/ + +/-- **Phase 3 ≤ phase 1, by construction.** After a successful phase 1 and +phase 2, the re-materialized table and roots are at most as long, priced by +the layout, as the phase-1 output: every phase-1 body and root is a writing +for its phase-3 dictionary (the allocated order places every body reference +first), each phase-3 part is a minimum for its dictionary, and the guard +keeps the reference cost of the allocated order at most the phase-1 +order's. So `rematerialize`'s length check never fails. -/ +theorem phase3_le_phase1 {layout : ShareLayout} {limits : Limits} {ex : Expanded} {w : Nat} + {u : UniformSharingResult} {a : Allocation} {entries rs : Array Ixon.Expr} + {predicted work : Nat} + (hu : optimizeUniformExpanded w limits ex = .ok u) + (ha : allocate layout limits ex.dag (graphFacts ex.dag ex.roots).deg u.result.tableTerms + u.result.sharing u.result.roots = .ok a) + (hm : materializeTable (Prep.ofDag ex.dag) a.order ex.roots limits layout.widthAt = + .ok (entries, rs, predicted, work)) : + predicted ≤ layoutBytes layout u.result.sharing u.result.roots := by + obtain ⟨hwf, hroots, hin1, hsize1, hindex1, hents, hrts⟩ := phase1_trees hu + obtain ⟨hnd1, -, hperm, hback, -, -, -, -, -, -⟩ := allocate_spec ha + have hrcEq := (allocate_spec ha).2.2.2.2.2.1 + have hrfEq := (allocate_spec ha).2.2.2.2.2.2.1 + have hrcLe := (allocate_spec ha).2.2.2.2.2.2.2.1 + obtain ⟨hsz3, -, hr3, hpred⟩ := materializeTable_spec hwf hroots hm + obtain ⟨hmin3, hrmin3⟩ := materializeTable_min hwf hroots hm + -- names + generalize ho1 : u.result.tableTerms = order1 at * + generalize he1 : u.result.sharing = entries1 at * + generalize hr1 : u.result.roots = roots1 at * + generalize ho : a.order = order at * + let n := ex.dag.size + let N := order1.size + let index1 := indexOfPairs n order1.toList.zipIdx + let idx1 : Nat → Nat := fun t => (index1[t]?.getD none).getD 0 + let avail1 : Nat → Bool := fun t => decide (t ∈ order1.toList) + let pos3 : Nat → Nat := fun t => ((indexOfPrefix n order order.size)[t]?.getD none).getD 0 + let wA : Nat → Nat := fun j => layout.widthAt j + let wB : Nat → Nat := fun j => layout.widthAt (pos3 order1[j]!) + have hnd : order.toList.Nodup := hperm.nodup_iff.mpr hnd1 + have hNsz : order.size = N := by + have := hperm.length_eq; simpa using this + -- available terms are table terms at their index + have hK1 : ∀ l, avail1 l = true → idx1 l < N ∧ order1[idx1 l]! = l := by + intro l hl + have hs : (index1[l]?.getD none).isSome = true := by rw [hindex1 l]; exact hl + obtain ⟨i, hi⟩ := Option.isSome_iff_exists.mp hs + have h2 := indexOfTable_spec n order1 l i hi + have hi' : idx1 l = i := by simp only [idx1, hi]; rfl + rw [hi'] + exact ⟨(Array.getElem?_eq_some_iff.mp h2).1, by + rw [getElem!_pos order1 i (Array.getElem?_eq_some_iff.mp h2).1] + exact (Array.getElem?_eq_some_iff.mp h2).2⟩ + have hidxSelf : ∀ i, i < N → idx1 order1[i]! = i := by + intro i hi + have hmem : order1[i]! ∈ order1.toList := by + rw [getElem!_pos order1 i hi]; simp + obtain ⟨hlt, heq⟩ := hK1 order1[i]! (by simp only [avail1]; exact decide_eq_true hmem) + exact getBang_inj hnd1 hlt hi heq + -- the writing facts per phase-1 expression + have hTreeFacts : ∀ (entry : Bool) (t : Nat) (e : Ixon.Expr) (T : WTree), + TreeOf (Prep.ofDag ex.dag) avail1 index1 entry t e T → + (∀ j ∈ shareList e, j < N) ∧ + (∀ f : Nat → Nat, (T.leaves.map f).sum = ((shareList e).map fun j => f order1[j]!).sum) ∧ + (∀ l ∈ T.leaves, ∃ j ∈ shareList e, order1[j]! = l ∧ j < N) := by + intro entry t e T hT + obtain ⟨hV, -, hL, -⟩ := hT + have hav := hV.leaves_avail + refine ⟨fun j hj => ?_, fun f => ?_, fun l hl => ?_⟩ + · obtain ⟨l, hl, rfl⟩ := List.mem_map.mp (hL.mem_iff.mpr hj) + exact (hK1 l (hav l hl)).1 + · have : T.leaves.map f = (T.leaves.map idx1).map fun j => f order1[j]! := by + rw [List.map_map] + apply List.map_congr_left + intro l hl + simp only [Function.comp] + rw [(hK1 l (hav l hl)).2] + rw [this] + exact (hL.map _).sum_nat + · exact ⟨idx1 l, hL.mem_iff.mp (List.mem_map_of_mem hl), (hK1 l (hav l hl)).2, + (hK1 l (hav l hl)).1⟩ + let s : Ixon.Expr → Nat := fun e => (sizeInfoWith layout.widthAt e).full + let A : Ixon.Expr → Nat := fun e => ((shareList e).map wA).sum + let B : Ixon.Expr → Nat := fun e => ((shareList e).map wB).sum + -- per-expression inequality from a phase-1 writing + have hpart : ∀ (entry : Bool) (t : Nat) (e : Ixon.Expr) (T : WTree) (S' : Nat → Bool) + (wd3 : Nat → Nat) (size3 : Nat), + TreeOf (Prep.ofDag ex.dag) avail1 index1 entry t e T → + (∀ l ∈ T.leaves, S' l = true ∧ wd3 l = layout.widthAt (pos3 l)) → + (∀ T', Valid (Prep.ofDag ex.dag) S' t T' → size3 ≤ T'.gcost (Prep.ofDag ex.dag) wd3) → + size3 + A e ≤ s e + B e := by + intro entry t e T S' wd3 size3 hT hleaf hmin + obtain ⟨hall, hsum, -⟩ := hTreeFacts entry t e T hT + have h1 : s e = T.gcost (Prep.ofDag ex.dag) (fun l => layout.widthAt (idx1 l)) := + (hT.2.2.2 layout.widthAt _ (fun v i hi => by simp only [idx1, hi]; rfl)).1 + have hle := part_le hT.1 (fun l hl => (hleaf l hl).1) hmin h1 + have hA : (T.leaves.map fun l => layout.widthAt (idx1 l)).sum = A e := by + rw [hsum] + simp only [A, wA] + congr 1 + apply List.map_congr_left + intro j hj + rw [hidxSelf j (hall j hj)] + have hB : (T.leaves.map wd3).sum = B e := by + rw [List.map_congr_left (fun l hl => (hleaf l hl).2), hsum] + rw [hA, hB] at hle + exact hle + -- shares of phase-1 expressions lie in the table + have hshN : ∀ (entry : Bool) (t : Nat) (e : Ixon.Expr) (T : WTree), + TreeOf (Prep.ofDag ex.dag) avail1 index1 entry t e T → ∀ j ∈ shareList e, j < N := + fun entry t e T hT => (hTreeFacts entry t e T hT).1 + -- table terms are in range and at their phase-3 position + have hpos : ∀ k, k < order.size → pos3 order[k]! = k := by + intro k hk + have hd : order[k]! ∈ order1.toList := by + rw [getElem!_pos order k hk]; exact hperm.subset (by simp) + have := prefix_lookup (n := n) hnd (j := k) (k := order.size) (d := order[k]!) + (by rw [getElem!_pos order k hk]; simp [hk]) hk (hin1 _ hd) + simp only [pos3, this] + rfl + -- the indexed phase-1 writings + obtain ⟨hlenE, hgetE⟩ := Ix.Compile.Verify.SharingExact.forall₂_getElem hents + obtain ⟨hlenR, hgetR⟩ := Ix.Compile.Verify.SharingExact.forall₂_getElem hrts + obtain ⟨hlenR3, hgetR3⟩ := Ix.Compile.Verify.SharingExact.forall₂_getElem hrmin3 + simp only [Array.length_toList] at hlenE hlenR hlenR3 + -- entries + have hentry : ∀ k, k < N → + s entries[k]! + A entries1[idx1 order[k]!]! ≤ + s entries1[idx1 order[k]!]! + B entries1[idx1 order[k]!]! := by + intro k hk + have hk3 : k < order.size := by omega + have hke : k < entries.size := by omega + have hd : order[k]! ∈ order1.toList := by + rw [getElem!_pos order k hk3]; exact hperm.subset (by simp) + obtain ⟨hiN, hti⟩ := hK1 order[k]! (by simp only [avail1]; exact decide_eq_true hd) + have hiN' : idx1 order[k]! < entries1.size := by simp only [N] at hiN; omega + obtain ⟨T, hT⟩ := hgetE (idx1 order[k]!) (by simpa using hiN) (by simpa using hiN') + simp only [Array.getElem_toList] at hT + rw [← getElem!_pos order1 _ hiN, hti, ← getElem!_pos entries1 _ (by omega)] at hT + refine hpart true _ _ T (prefixAvail n order k) (prefixWd n order layout.widthAt k) + (s entries[k]!) hT (fun l hl => ?_) (fun T' hT' => ?_) + · obtain ⟨j, hj, hjl, hjN⟩ := (hTreeFacts true _ _ T hT).2.2 l hl + have hdep : l ∈ (tierDeps order1 entries1).getD order[k]! [] := by + rw [← hti, getElem!_pos order1 _ hiN, tierDeps_spec hnd1 entries1 hiN] + rw [Array.getElem?_eq_getElem (by omega), Option.getD_some] + rw [mem_bodyRefs] + refine ⟨j, ?_, ?_⟩ + · rw [← getElem!_pos entries1 _ (by omega)]; exact hj + · rw [← hjl, getElem!_pos order1 j hjN]; simp + obtain ⟨j', hj'k, hj'⟩ := hback k hk3 l (by rw [← getElem!_pos order k hk3]; exact hdep) + have hl1 : l ∈ order1.toList := by rw [← hjl, getElem!_pos order1 j hjN]; simp + have hlook := prefix_lookup (n := n) hnd hj' hj'k (hin1 l hl1) + have hlook' := prefix_lookup (n := n) hnd hj' (k := order.size) + (Array.getElem?_eq_some_iff.mp hj').1 (hin1 l hl1) + refine ⟨by simp only [prefixAvail, hlook]; rfl, ?_⟩ + simp only [prefixWd, pos3, hlook, hlook'] + rfl + · have := (hmin3 k hke).1 T' hT' + rw [getElem!_pos entries k hke] + exact this + -- roots + have hroot : ∀ r, r < ex.roots.size → + s rs[r]! + A roots1[r]! ≤ s roots1[r]! + B roots1[r]! := by + intro r hr + have hr1 : r < roots1.size := by omega + have hr3 : r < rs.size := by omega + obtain ⟨T, hT⟩ := hgetR r (by simpa using hr) (by simpa using hr1) + have hmin := (hgetR3 r (by simpa using hr) (by simpa using hr3)).1 + simp only [Array.getElem_toList] at hT hmin + rw [← getElem!_pos roots1 r hr1] at hT + refine hpart false _ _ T (prefixAvail n order order.size) + (prefixWd n order layout.widthAt order.size) (s rs[r]!) hT (fun l hl => ?_) (fun T' hT' => ?_) + · have hl1 : l ∈ order1.toList := by + have := hT.1.leaves_avail l hl + simpa [avail1] using this + obtain ⟨j, hj⟩ := List.mem_iff_getElem?.mp (hperm.mem_iff.mpr hl1) + have hj' : order[j]? = some l := by simpa using hj + have hjk : j < order.size := (Array.getElem?_eq_some_iff.mp hj').1 + have hlook := prefix_lookup (n := n) hnd hj' hjk (hin1 l hl1) + refine ⟨by simp only [prefixAvail, hlook]; rfl, ?_⟩ + simp only [prefixWd, pos3, hlook] + rfl + · rw [getElem!_pos rs r hr3] + exact hmin T' hT' + -- sums over the entries, reindexed by the phase-1 order + have hreindex : ∀ (F : Ixon.Expr → Nat), + ((List.range N).map fun k => F entries1[idx1 order[k]!]!).sum = (entries1.toList.map F).sum := by + intro F + rw [show N = order.size from hNsz.symm, sum_range_array order (fun t => F entries1[idx1 t]!), + List.Perm.sum_nat (hperm.map _), ← sum_range_array order1 (fun t => F entries1[idx1 t]!)] + rw [show order1.size = entries1.size by omega] + apply sum_range_eq F entries1 + intro j hj + rw [hidxSelf j (by simp only [N]; omega), getElem!_pos entries1 j hj] + have hsumE : (entries.toList.map s).sum + (entries1.toList.map A).sum ≤ + (entries1.toList.map s).sum + (entries1.toList.map B).sum := by + have h := Ix.Compile.Verify.UniformModel.sum_le_sum_of_le (List.range N) (fun k hk => + hentry k (List.mem_range.mp hk)) + rw [Ix.Compile.Verify.SharingExact.sum_map_add, Ix.Compile.Verify.SharingExact.sum_map_add, + hreindex A, hreindex s, hreindex B] at h + have hE : ((List.range N).map fun k => s entries[k]!).sum = (entries.toList.map s).sum := by + rw [show N = entries.size by omega] + exact sum_range_eq s entries fun j hj => by rw [getElem!_pos entries j hj] + rw [hE] at h + exact h + have hsumR : (rs.toList.map s).sum + (roots1.toList.map A).sum ≤ + (roots1.toList.map s).sum + (roots1.toList.map B).sum := by + have h := Ix.Compile.Verify.UniformModel.sum_le_sum_of_le (List.range ex.roots.size) + (fun k hk => hroot k (List.mem_range.mp hk)) + rw [Ix.Compile.Verify.SharingExact.sum_map_add, Ix.Compile.Verify.SharingExact.sum_map_add] at h + have h1 : ∀ (F : Ixon.Expr → Nat), ((List.range ex.roots.size).map fun k => F roots1[k]!).sum = + (roots1.toList.map F).sum := by + intro F + rw [show ex.roots.size = roots1.size by omega] + exact sum_range_eq F roots1 fun j hj => by rw [getElem!_pos roots1 j hj] + have h2 : ((List.range ex.roots.size).map fun k => s rs[k]!).sum = (rs.toList.map s).sum := by + rw [show ex.roots.size = rs.size by omega] + exact sum_range_eq s rs fun j hj => by rw [getElem!_pos rs j hj] + rw [h1 A, h1 s, h1 B, h2] at h + exact h + -- all Shares of the phase-1 output, counted per index + have hallN : ∀ j ∈ (entries1.toList ++ roots1.toList).flatMap shareList, j < N := by + intro j hj + obtain ⟨e, he, hje⟩ := List.mem_flatMap.mp hj + rcases List.mem_append.mp he with he | he + · obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp he + obtain ⟨T, hT⟩ := hgetE i (by simp at hi ⊢; omega) hi + exact hshN _ _ _ T hT j hje + · obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp he + obtain ⟨T, hT⟩ := hgetR i (by simp at hi ⊢; omega) hi + exact hshN _ _ _ T hT j hje + have hsumAll : ∀ g : Nat → Nat, + (((entries1.toList ++ roots1.toList).flatMap shareList).map g).sum = + (entries1.toList.map fun e => ((shareList e).map g).sum).sum + + (roots1.toList.map fun e => ((shareList e).map g).sum).sum := by + intro g + rw [sum_map_flatMap, List.map_append, List.sum_append] + let weight : Nat → Nat := fun t => (tierWeights order1 entries1 roots1).getD t 0 + have hW : ∀ i, i < N → weight order1[i]! = + ((entries1.toList ++ roots1.toList).flatMap shareList).count i := by + intro i hi + simp only [weight] + rw [getElem!_pos order1 i hi, tierWeights_spec hnd1 entries1 roots1 hi] + rfl + have hAall : (entries1.toList.map A).sum + (roots1.toList.map A).sum = + refCost layout weight order1 := by + simp only [A] + rw [← hsumAll, ← sum_count N wA _ hallN, refCost_eq_sum] + congr 1 + apply List.map_congr_left + intro i hi + rw [List.mem_range] at hi + rw [hW i hi] + have hBall : (entries1.toList.map B).sum + (roots1.toList.map B).sum = + refCost layout weight order := by + simp only [B] + rw [← hsumAll, ← sum_count N wB _ hallN, refCost_eq_sum] + have h1 : ((List.range N).map fun i => + ((entries1.toList ++ roots1.toList).flatMap shareList).count i * wB i) = + (List.range order1.size).map fun i => + (fun t => weight t * layout.widthAt (pos3 t)) order1[i]! := by + apply List.map_congr_left + intro i hi + rw [List.mem_range] at hi + rw [← hW i hi] + rw [h1, sum_range_array order1 (fun t => weight t * layout.widthAt (pos3 t)), + ← List.Perm.sum_nat (hperm.map _), ← sum_range_array order] + congr 1 + apply List.map_congr_left + intro k hk + rw [List.mem_range] at hk + show weight order[k]! * layout.widthAt (pos3 order[k]!) = _ + rw [hpos k hk] + -- conclude + have hlenE' : entries1.size = N := by simp only [N]; omega + have hlen3 : entries.size = N := by omega + have htag : tag0Size entries.size = tag0Size entries1.size := by rw [hlen3, hlenE'] + rw [layoutBytes_eq, hpred, htag] + have hrc : a.refCostFinal ≤ a.refCost1 := hrcLe + rw [hrfEq, hrcEq] at hrc + simp only [weight] at hAall hBall + simp only [s] at hsumE hsumR + omega + + + + +/-! ## Optimality of the allocation in the 2-byte tier -/ + +open Ix.Compile.Verify.SharingExact (tagNWidth_rung1 tagNRung1End_eq) in +theorem widthAt_lt8 (layout : ShareLayout) {k : Nat} (hk : k < 8) : layout.widthAt k = 1 := by + cases layout with + | tagN => exact tagNWidth_rung1 (by rw [tagNRung1End_eq]; exact hk) + +open Ix.Compile.Verify.SharingExact (tagNWidth_rung2 tagNRung1End_eq) in +theorem widthAt_tier2 (layout : ShareLayout) {k : Nat} (h1 : 8 ≤ k) (h2 : k < layout.tier2End) : + layout.widthAt k = 2 := by + cases layout with + | tagN => exact tagNWidth_rung2 (by rw [tagNRung1End_eq]; exact h1) h2 + +/-- The reference cost of an order of at most `tier2End` terms: the first +`min 8 N` entries cost one byte per reference, the others two. -/ +theorem refCost_tier2 (layout : ShareLayout) (weight : Nat → Nat) (ρ : Array Nat) + (hsmall : ρ.size ≤ layout.tier2End) : + refCost layout weight ρ + ((List.range (min 8 ρ.size)).map fun k => weight ρ[k]!).sum = + 2 * ((List.range ρ.size).map fun k => weight ρ[k]!).sum := by + rw [refCost_eq_sum] + suffices h : ∀ M, M ≤ ρ.size → + ((List.range M).map fun k => weight ρ[k]! * layout.widthAt k).sum + + ((List.range (min 8 M)).map fun k => weight ρ[k]!).sum = + 2 * ((List.range M).map fun k => weight ρ[k]!).sum from h ρ.size (Nat.le_refl _) + intro M + induction M with + | zero => intro _; simp + | succ M ih => + intro hM + have ih' := ih (by omega) + simp only [List.range_succ, List.map_append, List.sum_append, List.map_cons, List.map_nil, + List.sum_cons, List.sum_nil] + by_cases h8 : M < 8 + · rw [widthAt_lt8 layout h8, show min 8 (M + 1) = min 8 M + 1 by omega, List.range_succ, + List.map_append, List.sum_append, show min 8 M = M by omega] + simp only [List.map_cons, List.map_nil, List.sum_cons, List.sum_nil] + rw [show min 8 M = M by omega] at ih' + omega + · rw [widthAt_tier2 layout (by omega) (by omega), show min 8 (M + 1) = min 8 M by omega] + omega + +theorem take_feasible {deps : Nat → List Nat} {order1 π : Array Nat} {m : Nat} + (hperm : π.toList.Perm order1.toList) (hnd : order1.toList.Nodup) + (hback : ∀ k (hk : k < π.size), ∀ d ∈ deps π[k], ∃ j, j < k ∧ π[j]? = some d) : + Feasible deps order1.toList m (π.toList.take m) := by + have hndπ : π.toList.Nodup := hperm.nodup_iff.mpr hnd + refine ⟨hndπ.sublist (List.take_sublist _ _), fun x hx => hperm.subset + (List.mem_of_mem_take hx), fun u hu d hd => ?_, by simp; omega⟩ + obtain ⟨k, hk, rfl⟩ := List.mem_iff_getElem.mp hu + have hk' : k < π.size := by simp at hk; omega + have hkm : k < m := by simp at hk; omega + rw [List.getElem_take, Array.getElem_toList] at hd + obtain ⟨j, hjk, hj⟩ := hback k hk' d hd + have hjs : j < π.size := (Array.getElem?_eq_some_iff.mp hj).1 + rw [List.mem_iff_getElem] + refine ⟨j, by simp; omega, ?_⟩ + rw [List.getElem_take, Array.getElem_toList] + exact (Array.getElem?_eq_some_iff.mp hj).2 + +theorem wsum_take (weight : Nat → Nat) (π : Array Nat) (m : Nat) : + wsum weight (π.toList.take m) = + ((List.range (min m π.size)).map fun k => weight π[k]!).sum := by + unfold wsum + congr 1 + apply List.ext_getElem (by simp) + intro k h1 h2 + simp only [List.getElem_map, List.getElem_take, Array.getElem_toList, List.getElem_range] + simp at h1 + rw [getElem!_pos π k (by omega)] + +/-- **Optimality of the allocation when the table fits the 2-byte tier.** +With the reference counts fixed, if the phase-1 table has at most +`tier2End` entries (so every index from 8 on has width 2), the allocated +order has the minimum reference cost `Σ ref · widthAt (index)` among all +orders of the table that place every body reference before its user. -/ +theorem allocate_optimal {layout : ShareLayout} {limits : Limits} {dag : Dag} {deg : Array Nat} + {order1 : Array Nat} {entries1 roots1 : Array Ixon.Expr} {a : Allocation} + (h : allocate layout limits dag deg order1 entries1 roots1 = .ok a) + (hsmall : order1.size ≤ layout.tier2End) : + ∀ π : Array Nat, π.toList.Perm order1.toList → + (∀ k (hk : k < π.size), ∀ d ∈ (tierDeps order1 entries1).getD π[k] [], + ∃ j, j < k ∧ π[j]? = some d) → + a.refCostFinal ≤ refCost layout (fun t => (tierWeights order1 entries1 roots1).getD t 0) π := by + intro π hπ hπback + obtain ⟨hnd, ⟨hFfeas, -, hFmax, -⟩, -, -, -, -, -, -, hperm2, hle2⟩ := allocate_spec h + generalize hw : (fun t => (tierWeights order1 entries1 roots1).getD t 0) = weight at * + generalize ho2 : pinnedOrder dag deg a.tier ++ kahnOrder weight + (fun t => (tierDeps order1 entries1).getD t []) + ((order1.toList.mergeSort (· ≤ ·)).toArray.filter (!a.tier.contains ·)) = order2 at * + have hNπ : π.size = order1.size := by simpa using hπ.length_eq + have hN2 : order2.size = order1.size := by simpa using hperm2.length_eq + -- both orders split their cost by the weight of their first `min 8 N` entries + have hsplitπ := refCost_tier2 layout weight π (by omega) + have hsplit2 := refCost_tier2 layout weight order2 (by omega) + have htot : ∀ ρ : Array Nat, ρ.toList.Perm order1.toList → + ((List.range ρ.size).map fun k => weight ρ[k]!).sum = wsum weight order1.toList := by + intro ρ hρ + rw [sum_range_array ρ weight, wsum] + exact (hρ.map _).sum_nat + rw [htot π hπ] at hsplitπ + rw [htot order2 hperm2] at hsplit2 + -- the first entries of `π` form a closed set of at most `min 8 N` terms + have hfeas := take_feasible (deps := fun t => (tierDeps order1 entries1).getD t []) + (m := min 8 order1.size) hπ hnd hπback + have hπle := hFmax _ hfeas + rw [wsum_take, show min (min 8 order1.size) π.size = min 8 π.size by omega] at hπle + -- the first entries of the pinned order contain the first tier + have htier : wsum weight a.tier.toList ≤ + ((List.range (min 8 order2.size)).map fun k => weight order2[k]!).sum := by + rw [← wsum_take] + have hlenT : a.tier.size ≤ min 8 order2.size := by + have := hFfeas.2.2.2; simp at this; omega + have hpin : (pinnedOrder dag deg a.tier).toList.Perm a.tier.toList := pinnedOrder_perm _ _ _ + have hpsz : (pinnedOrder dag deg a.tier).size = a.tier.size := by + simpa using hpin.length_eq + rw [← ho2, Array.toList_append, List.take_append, wsum_append, + List.take_of_length_le (by simp; omega), wsum_perm hpin] + exact Nat.le_add_right _ _ + omega + +end Ix.Compile.Verify.Tiered diff --git a/Ix/Compile/Verify/TieredIdem.lean b/Ix/Compile/Verify/TieredIdem.lean new file mode 100644 index 000000000..087655fb4 --- /dev/null +++ b/Ix/Compile/Verify/TieredIdem.lean @@ -0,0 +1,100 @@ +import Ix.Compile.Verify.TieredPhase3 + +/-! +# Tiered construction: determinism and idempotence + +* `canonicalTiered_det`: the construction on an expanded input depends only + on its canonical DAG and root IDs (the expansion statistics are recorded + but do not influence the encoding). +* `canonicalTiered_reexpand`: the output re-expands, against the input's + canonical DAG, to its table terms and exactly the input root IDs (it + encodes the same terms). +* `canonicalSharingTieredTable_idem`: normalizing the output again + reproduces it, provided expanding the output yields the same canonical DAG + and root IDs as expanding the input. That proviso is the statement that + canonical expansion depends only on the denoted terms; `canonicalize_det` + proves it for the canonicalization step, while the interner's pointer + cache (`Ix.Sharing.Exact.exprPtr`, an opaque pointer comparison) is outside what + can be proved here, so the proviso is stated, not proved. +-/ + +namespace Ix.Compile.Verify.Tiered + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (bind_eq_ok) + +/-- The parts of a result the encoding is made of. -/ +def encodingOf (r : TieredSharingResult) : Array Ixon.Expr × Array Ixon.Expr × Array Nat := + (r.result.sharing, r.result.roots, r.result.tableTerms) + +/-- **Determinism.** Two expanded inputs with the same canonical DAG and root +IDs give the same encoding, table terms and candidate statistics. -/ +theorem canonicalTiered_det {layout : ShareLayout} {limits : Limits} + {ex₁ ex₂ : Expanded} (hd : ex₁.dag = ex₂.dag) (hr : ex₁.roots = ex₂.roots) : + (canonicalTieredExpanded layout limits ex₁).map (fun r => (encodingOf r, r.stats)) = + (canonicalTieredExpanded layout limits ex₂).map + (fun r => (encodingOf r, r.stats)) := by + unfold canonicalTieredExpanded + rw [hd, hr] + cases canonicalTieredCore layout limits ex₂.dag ex₂.roots <;> rfl + +/-- The output of a candidate re-expands against the input DAG to its table +terms and the input roots. -/ +theorem tieredAtWidth_reexpand {layout : ShareLayout} {limits : Limits} {ex : Expanded} {w : Nat} + {c : TieredSharingResult} (h : tieredAtWidth layout limits ex w = .ok c) : + ∃ k, reexpand limits ex.dag c.result.sharing c.result.roots = + .ok (c.result.tableTerms, ex.roots, k) := by + obtain ⟨u, a, m, -, -, hm, rfl⟩ := tieredAtWidth_parts h + obtain ⟨_, -, -, hre, -⟩ := rematerialize_parts hm + exact hre + +/-- **Round trip.** The output of the tiered construction re-expands, +against the input's canonical DAG, to its table terms and exactly the input +root IDs: it encodes the input's terms. -/ +theorem canonicalTiered_reexpand {layout : ShareLayout} {limits : Limits} {ex : Expanded} + {r : TieredSharingResult} (h : canonicalTieredExpanded layout limits ex = .ok r) : + ∃ k, reexpand limits ex.dag r.result.sharing r.result.roots = + .ok (r.result.tableTerms, ex.roots, k) := by + obtain ⟨r₀, hr₀, rfl, -, -, -, -, -⟩ := canonicalTiered_core h + show ∃ k, reexpand limits ex.dag r₀.result.sharing r₀.result.roots = + .ok (r₀.result.tableTerms, ex.roots, k) + have hcand : ∀ (w : Nat) (c : TieredSharingResult), + tieredAtWidth layout limits ⟨ex.dag, ex.roots, 0, 0⟩ w = .ok c → + ∃ k, reexpand limits ex.dag c.result.sharing c.result.roots = + .ok (c.result.tableTerms, ex.roots, k) := + fun w c hc => tieredAtWidth_reexpand (ex := ⟨ex.dag, ex.roots, 0, 0⟩) hc + obtain ⟨c₁, c₂, c₃, h₁, h₂, h₃, ⟨c, hc, hrc⟩, -, -⟩ := canonicalTieredCore_select hr₀ + have hres : r₀.result = c.result := by rw [hrc] + rw [hres] + simp only [List.mem_cons, List.not_mem_nil, or_false] at hc + rcases hc with hc | hc | hc <;> rw [hc] + · exact hcand 1 c₁ h₁ + · exact hcand 2 c₂ h₂ + · exact hcand 3 c₃ h₃ + +/-- **Idempotence.** If expanding the output yields the same canonical DAG +and root IDs as expanding the input, normalizing the output reproduces its +sharing table, roots and table terms. -/ +theorem canonicalSharingTieredTable_idem {layout : ShareLayout} {limits : Limits} + {sharing roots : Array Ixon.Expr} {r : TieredSharingResult} {ex ex' : Expanded} + (h : canonicalSharingTieredTable layout sharing roots limits = .ok r) + (hex : expand limits sharing roots true = .ok ex) + (hex' : expand limits r.result.sharing r.result.roots true = .ok ex') + (hd : ex'.dag = ex.dag) (hr : ex'.roots = ex.roots) : + ∃ r', canonicalSharingTieredTable layout r.result.sharing r.result.roots limits = + .ok r' ∧ encodingOf r' = encodingOf r ∧ r'.stats = r.stats := by + unfold canonicalSharingTieredTable at h ⊢ + rw [hex] at h + rw [hex'] + change canonicalTieredExpanded layout limits ex = .ok r at h + change ∃ r', canonicalTieredExpanded layout limits ex' = .ok r' ∧ _ + have hdet := canonicalTiered_det (layout := layout) (limits := limits) hd hr + rw [h] at hdet + cases h' : canonicalTieredExpanded layout limits ex' with + | error e => rw [h'] at hdet; cases hdet + | ok r' => + rw [h'] at hdet + simp only [Except.map, Except.ok.injEq, Prod.mk.injEq] at hdet + exact ⟨r', rfl, hdet.1, hdet.2⟩ + +end Ix.Compile.Verify.Tiered diff --git a/Ix/Compile/Verify/TieredModel.lean b/Ix/Compile/Verify/TieredModel.lean new file mode 100644 index 000000000..82f27641b --- /dev/null +++ b/Ix/Compile/Verify/TieredModel.lean @@ -0,0 +1,2184 @@ +import Ix.Compile.Verify.UniformWritings +import Ix.Compile.Verify.UniformSearch + +/-! +# The fixed-dictionary model at per-term Share widths + +The uniform-width model (`UniformModel`, `UniformWritings`) prices every +Share at one width `w`. Phase 3 of the tiered construction prices the Share +of each table entry by its real width `widthAt (index)`. This module is the +same model with a width per term, `wd : Nat → Nat` (used where `avail` holds): + +* `gCost` / `gInl`: the cheapest standalone / inline writing of a term; +* `gEvalFrom_spec`, `gEvalAll_cost`: the executable dictionary evaluation + computes them; +* `gBuild_size`: every expression `Prep.build` emits has that length; +* `gValid_cost`, `gExists_opt`: they are the minimum lengths of a writing + (`Valid`), with Shares priced by `wd`, and the minima are attained; +* `gCost_local`, `evalUp_ok`: the incremental re-evaluation after adding + one term to the dictionary computes the new model. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (CP NodeArity getElem!_eq_getElem setBang_getElem! + child_eq_getElem cp_of_childrenPrecede bind_eq_ok sizeInfoWith_app_full sizeInfoWith_app_appCont + sizeInfoWith_lam_full sizeInfoWith_lam_lamCont sizeInfoWith_all_full sizeInfoWith_all_allCont + toNat_toUInt64_of_lt pickOption_mem pickOption_filter_ne_share) + +/-! ## The model -/ + +/-- The cost of the cut after `j` spine nodes of `t`: the prefix, ending in +the Share of the `j`-th spine node. -/ +def gCutCost (p : Prep) (wd : Nat → Nat) (cost : Nat → Nat) (t j : Nat) : Nat := + tag4Size j + prefixSides p cost t j + wd (spineAt p t j) + +/-- The available cuts of `t` at spine positions `j, …, spineLen t - 1`. -/ +def gCutsFrom (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j : Nat) : + List Nat := + (List.range' j (p.spineLen[t]! - j)).filterMap fun j' => + if avail (spineAt p t j') then some (gCutCost p wd cost t j') else none + +/-- The internal cuts of telescope `t`. -/ +def gCutCosts (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t : Nat) : + List Nat := + gCutsFrom p wd avail cost t 1 + +theorem gCutCosts_eq (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (cost : Nat → Nat) + (t : Nat) : gCutCosts p wd avail cost t = gCutsFrom p wd avail cost t 1 := rfl + +/-- Cheapest inline writing of `t` given the costs of the terms below it. -/ +def gInlOf (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t : Nat) : Nat := + if p.family[t]! = .none then + (p.dag.node t).children.foldl (fun acc c => acc + cost c) (p.dag.node t).head.ownBytes + else + (gCutCosts p wd avail cost t).foldl min (naturalCost p cost t) + +/-- Cheapest standalone writing of `t`: its Share if stored and shorter. -/ +def gCostOf (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t : Nat) : + Nat := + if avail t then min (gInlOf p wd avail cost t) (wd t) else gInlOf p wd avail cost t + +/-- The model values of every term, children first. -/ +def gVals (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) : Array Nat := + foldRange (fun arr t => arr.set! t (gCostOf p wd avail (arr[·]!) t)) 0 p.dag.size + (Array.replicate p.dag.size 0) + +/-- `C_M(t)`: the cheapest standalone writing of `t` with the dictionary +`avail` at the widths `wd`. -/ +def gCost (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (t : Nat) : Nat := + (gVals p wd avail)[t]! + +/-- The cheapest inline writing of `t` (the body of its entry). -/ +def gInl (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (t : Nat) : Nat := + gInlOf p wd avail (gCost p wd avail) t + +section Model + + +variable {p : Prep} (hp : PrepWF p) +include hp + +theorem PrepWF.gInlOf_congr {wd : Nat → Nat} {avail : Nat → Bool} {f g : Nat → Nat} {t : Nat} + (ht : t < p.dag.size) (hfg : ∀ c, c < t → f c = g c) : + gInlOf p wd avail f t = gInlOf p wd avail g t := by + unfold gInlOf + split + · rw [← Array.foldl_toList, ← Array.foldl_toList] + have hch : ∀ c ∈ (p.dag.node t).children.toList, f c = g c := + fun c hc => hfg c (hp.dag.child_lt ht (Array.mem_toList_iff.mp hc)) + generalize (p.dag.node t).children.toList = l at hch + generalize (p.dag.node t).head.ownBytes = acc + induction l generalizing acc with + | nil => rfl + | cons c l ih => + simp only [List.foldl_cons] + rw [hch c List.mem_cons_self] + exact ih (fun c hc => hch c (List.mem_cons_of_mem _ hc)) _ + · rename_i hf + obtain ⟨_, _, _, htl, _⟩ := hp.spine t ht hf + have hcuts : gCutCosts p wd avail f t = gCutCosts p wd avail g t := by + unfold gCutCosts gCutsFrom + apply filterMap_congr' + intro j hj + rw [List.mem_range'_1] at hj + unfold gCutCost + rw [hp.prefixSides_congr j t ht hf (by omega) hfg] + unfold naturalCost + rw [hcuts, hp.prefixSides_congr _ t ht hf (Nat.le_refl _) hfg, hfg _ htl] + +theorem PrepWF.gCostOf_congr {wd : Nat → Nat} {avail : Nat → Bool} {f g : Nat → Nat} {t : Nat} + (ht : t < p.dag.size) (hfg : ∀ c, c < t → f c = g c) : + gCostOf p wd avail f t = gCostOf p wd avail g t := by + unfold gCostOf + rw [hp.gInlOf_congr ht hfg] + +/-- The model recurrence: `C_S(t)` from the costs of the terms below `t`. -/ +theorem PrepWF.gCost_eq (wd : Nat → Nat) (avail : Nat → Bool) (t : Nat) (ht : t < p.dag.size) : + gCost p wd avail t = gCostOf p wd avail (gCost p wd avail) t := by + let step := fun (arr : Array Nat) (t : Nat) => arr.set! t (gCostOf p wd avail (arr[·]!) t) + have hinv : ∀ m, m ≤ p.dag.size → + ((List.range m).foldl step (Array.replicate p.dag.size 0)).size = p.dag.size ∧ + ∀ t, t < m → ((List.range m).foldl step (Array.replicate p.dag.size 0))[t]! = + gCostOf p wd avail (((List.range m).foldl step (Array.replicate p.dag.size 0))[·]!) t := by + intro m + induction m with + | zero => simp + | succ m ih => + intro hm + obtain ⟨hsize, hprev⟩ := ih (by omega) + rw [foldl_range_succ] + generalize hA : (List.range m).foldl step (Array.replicate p.dag.size 0) = A at hsize hprev + have hsame : ∀ c, c < m → (step A m)[c]! = A[c]! := by + intro c hc + simp only [step, setBang_getElem!] + rw [if_neg (by omega)] + refine ⟨by simp [step, hsize], fun t' ht' => ?_⟩ + have hcongr : gCostOf p wd avail ((step A m)[·]!) t' = gCostOf p wd avail (A[·]!) t' := + hp.gCostOf_congr (by omega) fun c hc => hsame c (by omega) + rw [hcongr] + by_cases htm : t' = m + · subst htm + simp only [step, setBang_getElem!, hsize] + rw [if_pos (by simp; omega)] + · rw [hsame t' (by omega)] + exact hprev t' (by omega) + have := (hinv p.dag.size (Nat.le_refl _)).2 t ht + unfold gCost gVals + rw [foldRange_zero] + exact this + +end Model + +theorem gCutsFrom_split (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j k : Nat) + (hjk : j ≤ k) (hk : k < p.spineLen[t]!) (hav : avail (spineAt p t k) = true) + (hnone : ∀ k', j ≤ k' → k' < k → avail (spineAt p t k') = false) : + gCutsFrom p wd avail cost t j = gCutCost p wd cost t k :: gCutsFrom p wd avail cost t (k + 1) := by + unfold gCutsFrom + rw [show p.spineLen[t]! - j = (k - j) + (1 + (p.spineLen[t]! - (k + 1))) by omega, + ← List.range'_append_1, ← List.range'_append_1, List.filterMap_append, + List.filterMap_append] + have hpre : (List.range' j (k - j)).filterMap (fun j' => + if avail (spineAt p t j') then some (gCutCost p wd cost t j') else none) = [] := by + rw [List.filterMap_eq_nil_iff] + intro a ha + rw [List.mem_range'_1] at ha + rw [hnone a ha.1 (by omega)] + rfl + rw [hpre, show j + (k - j) = k by omega] + simp [hav] + +theorem gCutsFrom_nil (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j : Nat) + (hnone : ∀ k, j ≤ k → k < p.spineLen[t]! → avail (spineAt p t k) = false) : + gCutsFrom p wd avail cost t j = [] := by + unfold gCutsFrom + rw [List.filterMap_eq_nil_iff] + intro a ha + rw [List.mem_range'_1] at ha + rw [hnone a ha.1 (by omega)] + rfl + +theorem PrepWF.gCutScan_spec {p : Prep} (hp : PrepWF p) {wd : Nat → Nat} {avail : Nat → Bool} + {cost : Nat → Nat} (sides : Array Nat) (below : Array (Option Nat)) + (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) + {t : Nat} (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) + (hsides : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + sides[spineAt p t k]! = prefixSides p cost (spineAt p t k) (p.spineLen[t]! - k)) + (hbelow : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + FirstAvail p avail (spineAt p t k) 1 below[spineAt p t k]!) : + ∀ (fuel j : Nat) (cur : Option Nat) (best work : Nat), 1 ≤ j → j ≤ p.spineLen[t]! → + p.spineLen[t]! - j ≤ fuel → FirstAvail p avail t j cur → + (cutScan p.spineLen sides below width p.spineLen[t]! + (prefixSides p cost t p.spineLen[t]!) fuel cur best work).1 = + (gCutsFrom p wd avail cost t j).foldl min best := by + obtain ⟨_, hk, _, _, _⟩ := hp.spine t ht hf + intro fuel + induction fuel with + | zero => + intro j cur best work _ hj hfuel _ + have : gCutsFrom p wd avail cost t j = [] := by + unfold gCutsFrom + rw [show p.spineLen[t]! - j = 0 by omega] + rfl + rw [this] + rfl + | succ fuel ih => + intro j cur best work hj1 hj hfuel hcur + cases cur with + | none => + rw [gCutsFrom_nil p wd avail cost t j hcur] + rfl + | some u => + obtain ⟨k, hjk, hkl, rfl, hav, hnone⟩ := hcur + obtain ⟨_, _, hlenk, _⟩ := hk k hkl + simp only [cutScan] + rw [gCutsFrom_split p wd avail cost t j k hjk hkl hav hnone, List.foldl_cons, + ite_lt_eq_min] + have hcand : tag4Size (p.spineLen[t]! - p.spineLen[spineAt p t k]!) + + (prefixSides p cost t p.spineLen[t]! - sides[spineAt p t k]!) + + (widthOf width (spineAt p t k)).getD 0 = gCutCost p wd cost t k := by + rw [hlenk, hsides k (by omega) hkl, hwidth, if_pos hav] + have hsplit := prefixSides_add p cost k (p.spineLen[t]! - k) t + rw [show k + (p.spineLen[t]! - k) = p.spineLen[t]! by omega] at hsplit + unfold gCutCost + rw [show p.spineLen[t]! - (p.spineLen[t]! - k) = k by omega, hsplit] + simp + rw [hcand] + exact ih (k + 1) _ _ _ (by omega) (by omega) (by omega) + (FirstAvail.shift hlenk (hbelow k (by omega) hkl)) + + +def GEvalRow (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (st : DictEval) (t : Nat) : Prop := + st.cost[t]! = gCost p wd avail t ∧ + (p.family[t]! ≠ .none → + st.sides[t]! = prefixSides p (gCost p wd avail) t p.spineLen[t]! ∧ + FirstAvail p avail t 1 st.below[t]!) + +theorem PrepWF.gEvalStep_spec {p : Prep} (hp : PrepWF p) {wd : Nat → Nat} {avail : Nat → Bool} + (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) + (affected : Array Bool) (st : DictEval) (m : Nat) (hm : m < p.dag.size) + (haff : affected[m]! = true) + (hsz : st.cost.size = p.dag.size ∧ st.sides.size = p.dag.size ∧ + st.below.size = p.dag.size) + (hrows : ∀ t, t < m → GEvalRow p wd avail st t) : + let st' := evalStep p.dag p.family p.spineLen p.tail width affected st m + (st'.cost.size = p.dag.size ∧ st'.sides.size = p.dag.size ∧ + st'.below.size = p.dag.size) ∧ ∀ t, t < m + 1 → GEvalRow p wd avail st' t := by + intro st' + obtain ⟨hcs, hss, hbs⟩ := hsz + have keepN : ∀ (v : Nat) (arr : Array Nat) (i : Nat), i ≠ m → (arr.set! m v)[i]! = arr[i]! := by + intro v arr i hi + rw [setBang_getElem!, if_neg (by intro h; exact hi h.1.symm)] + have keepO : ∀ (v : Option Nat) (arr : Array (Option Nat)) (i : Nat), i ≠ m → + (arr.set! m v)[i]! = arr[i]! := by + intro v arr i hi + rw [setBang_getElem!, if_neg (by intro h; exact hi h.1.symm)] + have atN : ∀ (v : Nat) (arr : Array Nat), arr.size = p.dag.size → (arr.set! m v)[m]! = v := by + intro v arr hs + rw [setBang_getElem!, if_pos ⟨rfl, by omega⟩] + have atO : ∀ (v : Option Nat) (arr : Array (Option Nat)), arr.size = p.dag.size → + (arr.set! m v)[m]! = v := by + intro v arr hs + rw [setBang_getElem!, if_pos ⟨rfl, by omega⟩] + have hcostLt : ∀ c, c < m → st.cost[c]! = gCost p wd avail c := fun c hc => (hrows c hc).1 + have hcm := hp.gCost_eq wd avail m hm + have hcostOf : ∀ inl, gInlOf p wd avail (gCost p wd avail) m = inl → + (match widthOf width m with + | some w => min inl w + | none => inl) = gCost p wd avail m := by + intro inl hinl + rw [hcm] + unfold gCostOf + rw [hinl, hwidth] + by_cases ha : avail m = true <;> simp [ha] + by_cases hf : p.family[m]! = .none + · -- non-telescope + have hfold : (p.dag.node m).children.foldl (fun acc c => acc + st.cost[c]!) + (p.dag.node m).head.ownBytes = gInlOf p wd avail (gCost p wd avail) m := by + unfold gInlOf + rw [if_pos hf] + exact foldl_add_congr _ _ fun c hc => hcostLt c (hp.dag.child_lt hm hc) + have hst' : st'.cost = st.cost.set! m (gCost p wd avail m) ∧ st'.sides = st.sides ∧ + st'.below = st.below := by + simp only [st', evalStep, haff, if_true, hf, beq_self_eq_true] + refine ⟨?_, trivial, trivial⟩ + congr 1 + exact hcostOf _ hfold.symm + obtain ⟨hc', hs', hb'⟩ := hst' + refine ⟨⟨by simp [hc', hcs], by rw [hs']; exact hss, by rw [hb']; exact hbs⟩, + fun t ht => ?_⟩ + by_cases htm : t = m + · subst htm + exact ⟨by rw [hc', atN _ _ hcs], fun h => absurd hf h⟩ + · obtain ⟨h1, h2⟩ := hrows t (by omega) + refine ⟨by rw [hc', keepN _ _ _ htm, h1], ?_⟩ + rw [hs', hb'] + exact h2 + · -- telescope + obtain ⟨hl1, hk, hend, htl, _⟩ := hp.spine m hm hf + have hlt := hp.snext_lt hm hf + have hside := hp.sideChild_lt hm hf + have hS : (p.dag.node m).sideExtra + st.cost[(p.dag.node m).sideChild]! + + (if p.family[snext p m]! = p.family[m]! then st.sides[snext p m]! else 0) = + prefixSides p (gCost p wd avail) m p.spineLen[m]! := by + rw [hcostLt _ hside] + rcases hp.spine_step hm hf with ⟨hs, hl, _⟩ | ⟨hs, hl, _⟩ + · rw [if_pos hs, ((hrows _ hlt).2 (by rw [hs]; exact hf)).1, hl] + rfl + · rw [if_neg hs, hl] + simp [prefixSides, sideCost] + have hB : FirstAvail p avail m 1 + (if p.family[snext p m]! = p.family[m]! then + (if (widthOf width (snext p m)).isSome then some (snext p m) + else st.below[snext p m]!) else none) := by + rcases hp.spine_step hm hf with ⟨hs, hl, _⟩ | ⟨hs, hl, _⟩ + · rw [if_pos hs, hwidth] + have hn1 := (hp.spine (snext p m) (by omega) (by rw [hs]; exact hf)).1 + by_cases hav : avail (snext p m) = true + · rw [if_pos hav] + exact ⟨1, Nat.le_refl _, by omega, rfl, hav, fun k' h1 h2 => by omega⟩ + · rw [if_neg hav] + simp only [Option.isSome_none, Bool.false_eq_true, if_false] + have hrow := ((hrows _ hlt).2 (by rw [hs]; exact hf)).2 + have hlen1 : p.spineLen[spineAt p m 1]! = p.spineLen[m]! - 1 := by + simp only [spineAt]; omega + exact FirstAvail.unshift (by omega) (by simpa [spineAt] using hav) + (FirstAvail.shift hlen1 hrow) + · rw [if_neg hs] + intro k h1 h2 + omega + generalize hBdef : (if p.family[snext p m]! = p.family[m]! then + (if (widthOf width (snext p m)).isSome then some (snext p m) + else st.below[snext p m]!) else none) = B at hB + generalize hSdef : prefixSides p (gCost p wd avail) m p.spineLen[m]! = S at hS + -- rows of the spine nodes below `m` + have hspine : ∀ k, 1 ≤ k → k < p.spineLen[m]! → + spineAt p m k ≠ m ∧ GEvalRow p wd avail st (spineAt p m k) ∧ + p.family[spineAt p m k]! ≠ .none ∧ + p.spineLen[spineAt p m k]! = p.spineLen[m]! - k := by + intro k h1 h2 + have hlt' := hp.spineAt_lt hm hf h1 h2 + obtain ⟨_, hkf, hklen, _⟩ := hk k h2 + exact ⟨by omega, hrows _ hlt', by rw [hkf]; exact hf, hklen⟩ + have hsides : ∀ k, 1 ≤ k → k < p.spineLen[m]! → + (st.sides.set! m S)[spineAt p m k]! = + prefixSides p (gCost p wd avail) (spineAt p m k) (p.spineLen[m]! - k) := by + intro k h1 h2 + obtain ⟨hne, hrow, hfk, hlenk⟩ := hspine k h1 h2 + rw [keepN _ _ _ hne, (hrow.2 hfk).1, hlenk] + have hbelow : ∀ k, 1 ≤ k → k < p.spineLen[m]! → + FirstAvail p avail (spineAt p m k) 1 (st.below.set! m B)[spineAt p m k]! := by + intro k h1 h2 + obtain ⟨hne, hrow, hfk, _⟩ := hspine k h1 h2 + rw [keepO _ _ _ hne] + exact (hrow.2 hfk).2 + have hscan := hp.gCutScan_spec (cost := gCost p wd avail) (st.sides.set! m S) + (st.below.set! m B) width hwidth hm hf hsides hbelow p.spineLen[m]! 1 B + (tag4Size p.spineLen[m]! + S + st.cost[p.tail[m]!]!) st.work (Nat.le_refl _) + (by omega) (by omega) hB + rw [hSdef] at hscan + have hinl : gInlOf p wd avail (gCost p wd avail) m = + (cutScan p.spineLen (st.sides.set! m S) (st.below.set! m B) width p.spineLen[m]! S + p.spineLen[m]! B (tag4Size p.spineLen[m]! + S + st.cost[p.tail[m]!]!) st.work).1 := by + rw [hscan, hcostLt _ htl] + unfold gInlOf + rw [if_neg hf, gCutCosts_eq, naturalCost, hSdef] + have hst' : st'.cost = st.cost.set! m (gCost p wd avail m) ∧ + st'.sides = st.sides.set! m S ∧ st'.below = st.below.set! m B := by + simp only [st', evalStep, haff, if_true] + have hfb : (p.family[m]! == Family.none) = false := by simpa using hf + simp only [hfb, Bool.false_eq_true, if_false] + simp only [ite_beq_family] + rw [show (p.dag.node m).spineNext = snext p m from rfl, hS, hBdef] + refine ⟨?_, rfl, rfl⟩ + congr 1 + exact hcostOf _ hinl + obtain ⟨hc', hs', hb'⟩ := hst' + refine ⟨⟨by simp [hc', hcs], by simp [hs', hss], by simp [hb', hbs]⟩, fun t ht => ?_⟩ + by_cases htm : t = m + · subst htm + refine ⟨by rw [hc', atN _ _ hcs], fun _ => ⟨?_, ?_⟩⟩ + · rw [hs', atN _ _ hss, hSdef] + · rw [hb', atO _ _ hbs] + exact hB + · obtain ⟨h1, h2⟩ := hrows t (by omega) + refine ⟨by rw [hc', keepN _ _ _ htm, h1], fun hft => ?_⟩ + obtain ⟨h3, h4⟩ := h2 hft + exact ⟨by rw [hs', keepN _ _ _ htm, h3], by rw [hb', keepO _ _ _ htm]; exact h4⟩ + +theorem PrepWF.gEvalFrom_spec {p : Prep} (hp : PrepWF p) {wd : Nat → Nat} {avail : Nat → Bool} + (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) (init : DictEval) + (hsz : init.cost.size = p.dag.size ∧ init.sides.size = p.dag.size ∧ + init.below.size = p.dag.size) + (affected : Array Bool) (haff : ∀ t, t < p.dag.size → affected[t]! = true) : + ∀ t, t < p.dag.size → + GEvalRow p wd avail (evalFrom p.dag p.family p.spineLen p.tail init width affected) t := by + have hinv : ∀ m, m ≤ p.dag.size → + let st := (List.range m).foldl (evalStep p.dag p.family p.spineLen p.tail width affected) + { init with work := 0 } + (st.cost.size = p.dag.size ∧ st.sides.size = p.dag.size ∧ st.below.size = p.dag.size) ∧ + ∀ t, t < m → GEvalRow p wd avail st t := by + intro m + induction m with + | zero => intro _; exact ⟨hsz, fun t h => absurd h (Nat.not_lt_zero _)⟩ + | succ m ih => + intro hm + obtain ⟨hs, hrows⟩ := ih (by omega) + simp only at hs hrows ⊢ + rw [foldl_range_succ] + exact hp.gEvalStep_spec width hwidth affected _ m (by omega) (haff m (by omega)) hs hrows + intro t ht + unfold evalFrom + rw [foldRange_zero] + exact (hinv p.dag.size (Nat.le_refl _)).2 t ht + +theorem gVals_size (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) : + (gVals p wd avail).size = p.dag.size := by + unfold gVals + rw [foldRange_zero] + generalize List.range p.dag.size = l + suffices h : ∀ (arr : Array Nat), + (l.foldl (fun arr t => arr.set! t (gCostOf p wd avail (arr[·]!) t)) arr).size = arr.size by + rw [h]; simp + induction l with + | nil => intro _; rfl + | cons x l ih => intro arr; rw [List.foldl_cons, ih]; simp + +theorem gCost_of_ge (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) {t : Nat} + (ht : p.dag.size ≤ t) : gCost p wd avail t = 0 := by + unfold gCost + simp [gVals_size, show ¬ t < p.dag.size by omega] + +/-- `Prep.evalAll` computes `C_S` for every term (`0` out of range on both +sides). -/ +theorem PrepWF.gEvalAll_cost {p : Prep} (hp : PrepWF p) {wd : Nat → Nat} {avail : Nat → Bool} + (hempty : p.empty.cost.size = p.dag.size ∧ p.empty.sides.size = p.dag.size ∧ + p.empty.below.size = p.dag.size) + (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) (t : Nat) : + (p.evalAll width).cost[t]! = gCost p wd avail t := by + by_cases ht : t < p.dag.size + · exact (hp.gEvalFrom_spec width hwidth p.empty hempty _ + (fun t ht => by simp [ht]) t ht).1 + · have hs := (evalFrom_size p.dag p.family p.spineLen p.tail p.empty width + (Array.replicate p.dag.size true)).1 + rw [gCost_of_ge p wd avail (by omega)] + unfold Prep.evalAll Prep.eval + simp [hs, hempty.1, show ¬ t < p.dag.size by omega] + +/-! ## The entry cost of materialization -/ + + +/-- An evaluation whose rows are the model rows of every term. -/ +def GEvalOK (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (ev : DictEval) : Prop := + (ev.cost.size = p.dag.size ∧ ev.sides.size = p.dag.size ∧ ev.below.size = p.dag.size) ∧ + ∀ t, t < p.dag.size → GEvalRow p wd avail ev t + +theorem GEvalOK.cost {p : Prep} {wd : Nat → Nat} {avail : Nat → Bool} {ev : DictEval} + (h : GEvalOK p wd avail ev) (c : Nat) : ev.cost[c]! = gCost p wd avail c := by + by_cases hc : c < p.dag.size + · exact (h.2 c hc).1 + · rw [gCost_of_ge p wd avail (by omega)] + simp [h.1.1, hc] + +/-- `Prep.evalAll` gives the model rows. -/ +theorem PrepWF.evalAll_ok {p : Prep} (hp : PrepWF p) + (hempty : p.empty.cost.size = p.dag.size ∧ p.empty.sides.size = p.dag.size ∧ + p.empty.below.size = p.dag.size) + {wd : Nat → Nat} {avail : Nat → Bool} (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) : + GEvalOK p wd avail (p.evalAll width) := by + refine ⟨?_, hp.gEvalFrom_spec width hwidth p.empty hempty _ (fun t ht => by simp [ht])⟩ + obtain ⟨a, b, c⟩ := evalFrom_size p.dag p.family p.spineLen p.tail p.empty width + (Array.replicate p.dag.size true) + exact ⟨a.trans hempty.1, b.trans hempty.2.1, c.trans hempty.2.2⟩ + +/-! ## Options and built lengths -/ + +/-- The internal-cut options found by `Prep.cutOptions` are the available cuts. -/ +theorem PrepWF.gCutOptions_spec {p : Prep} (hp : PrepWF p) {wd : Nat → Nat} {avail : Nat → Bool} + (ev : DictEval) (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) + (hindex : ∀ u, (index[u]?.getD none).isSome = avail u) + {t : Nat} (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) (flag : UInt8) + (hsides : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + ev.sides[spineAt p t k]! = + prefixSides p (gCost p wd avail) (spineAt p t k) (p.spineLen[t]! - k)) + (hbelow : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + FirstAvail p avail (spineAt p t k) 1 ev.below[spineAt p t k]!) : + ∀ (fuel j : Nat) (cur : Option Nat) (opts : Array (Choice × Nat × ByteArray)), + 1 ≤ j → j ≤ p.spineLen[t]! → p.spineLen[t]! - j ≤ fuel → FirstAvail p avail t j cur → + ∃ L : List (Choice × Nat × ByteArray), + (p.cutOptions ev index width flag p.spineLen[t]! + (prefixSides p (gCost p wd avail) t p.spineLen[t]!) fuel cur opts).toList = + opts.toList ++ L ∧ + L.map (·.2.1) = gCutsFrom p wd avail (gCost p wd avail) t j ∧ + ∀ o ∈ L, o.1 ≠ .share := by + obtain ⟨_, hk, _, _, _⟩ := hp.spine t ht hf + intro fuel + induction fuel with + | zero => + intro j cur opts _ hj hfuel _ + refine ⟨[], by simp [Prep.cutOptions], ?_, fun o ho => by cases ho⟩ + unfold gCutsFrom + rw [show p.spineLen[t]! - j = 0 by omega] + rfl + | succ fuel ih => + intro j cur opts hj1 hj hfuel hcur + cases cur with + | none => + exact ⟨[], by simp [Prep.cutOptions], by rw [gCutsFrom_nil p wd avail _ t j hcur]; rfl, + fun o ho => by cases ho⟩ + | some u => + obtain ⟨k, hjk, hkl, rfl, hav, hnone⟩ := hcur + obtain ⟨_, _, hlenk, _⟩ := hk k hkl + have hcand : tag4Size (p.spineLen[t]! - p.spineLen[spineAt p t k]!) + + (prefixSides p (gCost p wd avail) t p.spineLen[t]! - ev.sides[spineAt p t k]!) + + (widthOf width (spineAt p t k)).getD 0 = gCutCost p wd (gCost p wd avail) t k := by + rw [hlenk, hsides k (by omega) hkl, hwidth, if_pos hav] + have hsplit := prefixSides_add p (gCost p wd avail) k (p.spineLen[t]! - k) t + rw [show k + (p.spineLen[t]! - k) = p.spineLen[t]! by omega] at hsplit + unfold gCutCost + rw [show p.spineLen[t]! - (p.spineLen[t]! - k) = k by omega, hsplit] + simp + have hidx : (index[spineAt p t k]?.getD none).isSome = true := by rw [hindex]; exact hav + simp only [Prep.cutOptions, hidx, if_true] + obtain ⟨L, hL, hcost, hnot⟩ := ih (k + 1) _ _ (by omega) (by omega) (by omega) + (FirstAvail.shift hlenk (hbelow k (by omega) hkl)) + refine ⟨(Choice.cut (p.spineLen[t]! - p.spineLen[spineAt p t k]!), + tag4Size (p.spineLen[t]! - p.spineLen[spineAt p t k]!) + + (prefixSides p (gCost p wd avail) t p.spineLen[t]! - ev.sides[spineAt p t k]!) + + (widthOf width (spineAt p t k)).getD 0, + tag4Bytes flag (p.spineLen[t]! - p.spineLen[spineAt p t k]!)) :: L, ?_, ?_, ?_⟩ + · rw [hL]; simp + · rw [List.map_cons, hcost, gCutsFrom_split p wd avail _ t j k hjk hkl hav hnone] + simp only + rw [hcand] + · intro o ho + rcases List.mem_cons.mp ho with rfl | ho + · simp + · exact hnot o ho + +/-- The entry cost used by `materializeDependent` is the model's inline cost. -/ +theorem PrepWF.gInlineCost_eq {p : Prep} (hp : PrepWF p) + {wd : Nat → Nat} {avail : Nat → Bool} (ev : DictEval) (hev : GEvalOK p wd avail ev) (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) + (hindex : ∀ u, (index[u]?.getD none).isSome = avail u) (t : Nat) (ht : t < p.dag.size) : + p.inlineCost ev index width t = gInl p wd avail t := by + have hrow : ∀ t', t' < p.dag.size → GEvalRow p wd avail ev t' := + hev.2 + have hcost : ∀ c, c < p.dag.size → ev.cost[c]! = gCost p wd avail c := + fun c hc => (hrow c hc).1 + let base : Array (Choice × Nat × ByteArray) := + match index[t]?.getD none with + | some i => #[(Choice.share, (widthOf width t).getD 0, tag4Bytes Ixon.Expr.FLAG_SHARE i)] + | none => #[] + have hbase : base.toList.filter (fun o => o.1 != Choice.share) = [] := + share_opts_filter index width t + unfold Prep.inlineCost Prep.options gInl + by_cases hf : p.family[t]! = .none + · have hfb : (p.family[t]! == Family.none) = true := by simp [hf] + simp only [hfb, if_true] + have hfold : (p.dag.node t).children.foldl (fun acc c => acc + ev.cost[c]!) + (p.dag.node t).head.ownBytes = gInlOf p wd avail (gCost p wd avail) t := by + unfold gInlOf + rw [if_pos hf] + exact foldl_add_congr _ _ fun c hc => + hcost c (by have := hp.dag.child_lt ht hc; omega) + rw [pickOption_cost _ (Choice.inline, gInlOf p wd avail (gCost p wd avail) t, + Ixon.runPut (Ixon.putTagN 4 (p.dag.node t).head.flag (p.dag.node t).head.tag4Field)) []] + · rfl + · rw [Array.toList_filter, Array.toList_push, List.filter_append] + change base.toList.filter _ ++ _ = _ + rw [hbase, hfold] + rfl + · have hfb : (p.family[t]! == Family.none) = false := by simpa using hf + simp only [hfb, Bool.false_eq_true, if_false] + obtain ⟨hs, hb⟩ := (hrow t ht).2 hf + obtain ⟨_, hk, _, htl, _⟩ := hp.spine t ht hf + have hspine : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + GEvalRow p wd avail ev (spineAt p t k) ∧ + p.family[spineAt p t k]! ≠ .none ∧ + p.spineLen[spineAt p t k]! = p.spineLen[t]! - k := by + intro k h1 h2 + have hlt' := hp.spineAt_lt ht hf h1 h2 + obtain ⟨_, hkf, hklen, _⟩ := hk k h2 + exact ⟨hrow _ (by omega), by rw [hkf]; exact hf, hklen⟩ + let natOpt : Choice × Nat × ByteArray := + (Choice.cut p.spineLen[t]!, + tag4Size p.spineLen[t]! + ev.sides[t]! + + ev.cost[p.tail[t]!]!, + tag4Bytes (p.dag.node t).head.flag p.spineLen[t]!) + obtain ⟨L, hL, hLcost, hLnot⟩ := hp.gCutOptions_spec ev index width hwidth + hindex ht hf (p.dag.node t).head.flag + (fun k h1 h2 => by + obtain ⟨hr, hfk, hlenk⟩ := hspine k h1 h2 + rw [(hr.2 hfk).1, hlenk]) + (fun k h1 h2 => by + obtain ⟨hr, hfk, _⟩ := hspine k h1 h2 + exact (hr.2 hfk).2) + p.spineLen[t]! 1 _ (base.push natOpt) (Nat.le_refl _) (by omega) (by omega) hb + rw [← hs] at hL + have hnat : natOpt.2.1 = naturalCost p (gCost p wd avail) t := by + simp only [natOpt] + rw [hs, hcost _ (by omega)] + rfl + rw [pickOption_cost _ natOpt L] + · rw [hLcost, hnat] + unfold gInlOf + rw [if_neg hf, gCutCosts_eq] + · simp only [base, natOpt] at hL hbase + rw [Array.toList_filter] + refine (congrArg (List.filter _) hL).trans ?_ + rw [Array.toList_push, List.filter_append, List.filter_append, + hbase, List.filter_eq_self.mpr (fun o ho => choice_ne_share (hLnot o ho))] + rfl + +/-- The internal cuts with their choices. -/ +def gCutsFromC (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j : Nat) : + List (Choice × Nat) := + (List.range' j (p.spineLen[t]! - j)).filterMap fun j' => + if avail (spineAt p t j') then some (.cut j', gCutCost p wd cost t j') else none + +theorem mem_gCutsFromC {p : Prep} {wd : Nat → Nat} {avail : Nat → Bool} {cost : Nat → Nat} {t j : Nat} + {ch : Choice} {c : Nat} (h : (ch, c) ∈ gCutsFromC p wd avail cost t j) : + ∃ k, j ≤ k ∧ k < p.spineLen[t]! ∧ avail (spineAt p t k) = true ∧ ch = .cut k ∧ + c = gCutCost p wd cost t k := by + unfold gCutsFromC at h + obtain ⟨k, hk, hkv⟩ := List.mem_filterMap.mp h + rw [List.mem_range'_1] at hk + split at hkv + · rename_i hav + simp only [Option.some.injEq, Prod.mk.injEq] at hkv + exact ⟨k, hk.1, by omega, hav, hkv.1.symm, hkv.2.symm⟩ + · cases hkv + +theorem gCutsFromC_split (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j k : Nat) + (hjk : j ≤ k) (hk : k < p.spineLen[t]!) (hav : avail (spineAt p t k) = true) + (hnone : ∀ k', j ≤ k' → k' < k → avail (spineAt p t k') = false) : + gCutsFromC p wd avail cost t j = + (Choice.cut k, gCutCost p wd cost t k) :: gCutsFromC p wd avail cost t (k + 1) := by + unfold gCutsFromC + rw [show p.spineLen[t]! - j = (k - j) + (1 + (p.spineLen[t]! - (k + 1))) by omega, + ← List.range'_append_1, ← List.range'_append_1, List.filterMap_append, + List.filterMap_append] + have hpre : (List.range' j (k - j)).filterMap (fun j' => + if avail (spineAt p t j') then some (Choice.cut j', gCutCost p wd cost t j') else none) = [] := by + rw [List.filterMap_eq_nil_iff] + intro a ha + rw [List.mem_range'_1] at ha + rw [hnone a ha.1 (by omega)] + rfl + rw [hpre, show j + (k - j) = k by omega] + simp [hav] + +theorem gCutsFromC_nil (p : Prep) (wd : Nat → Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j : Nat) + (hnone : ∀ k, j ≤ k → k < p.spineLen[t]! → avail (spineAt p t k) = false) : + gCutsFromC p wd avail cost t j = [] := by + unfold gCutsFromC + rw [List.filterMap_eq_nil_iff] + intro a ha + rw [List.mem_range'_1] at ha + rw [hnone a ha.1 (by omega)] + rfl + +/-- The internal-cut options found by `Prep.cutOptions`, with their choices. -/ +theorem PrepWF.gCutOptions_pairs {p : Prep} (hp : PrepWF p) {wd : Nat → Nat} {avail : Nat → Bool} + (ev : DictEval) (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) + (hindex : ∀ u, (index[u]?.getD none).isSome = avail u) + {t : Nat} (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) (flag : UInt8) + (hsides : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + ev.sides[spineAt p t k]! = + prefixSides p (gCost p wd avail) (spineAt p t k) (p.spineLen[t]! - k)) + (hbelow : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + FirstAvail p avail (spineAt p t k) 1 ev.below[spineAt p t k]!) : + ∀ (fuel j : Nat) (cur : Option Nat) (opts : Array (Choice × Nat × ByteArray)), + 1 ≤ j → j ≤ p.spineLen[t]! → p.spineLen[t]! - j ≤ fuel → FirstAvail p avail t j cur → + ∃ L : List (Choice × Nat × ByteArray), + (p.cutOptions ev index width flag p.spineLen[t]! + (prefixSides p (gCost p wd avail) t p.spineLen[t]!) fuel cur opts).toList = + opts.toList ++ L ∧ + L.map (fun o => (o.1, o.2.1)) = gCutsFromC p wd avail (gCost p wd avail) t j := by + obtain ⟨_, hk, _, _, _⟩ := hp.spine t ht hf + intro fuel + induction fuel with + | zero => + intro j cur opts _ hj hfuel _ + refine ⟨[], by simp [Prep.cutOptions], ?_⟩ + unfold gCutsFromC + rw [show p.spineLen[t]! - j = 0 by omega] + rfl + | succ fuel ih => + intro j cur opts hj1 hj hfuel hcur + cases cur with + | none => + exact ⟨[], by simp [Prep.cutOptions], by rw [gCutsFromC_nil p wd avail _ t j hcur]; rfl⟩ + | some u => + obtain ⟨k, hjk, hkl, rfl, hav, hnone⟩ := hcur + obtain ⟨_, _, hlenk, _⟩ := hk k hkl + have hcand : tag4Size (p.spineLen[t]! - p.spineLen[spineAt p t k]!) + + (prefixSides p (gCost p wd avail) t p.spineLen[t]! - ev.sides[spineAt p t k]!) + + (widthOf width (spineAt p t k)).getD 0 = gCutCost p wd (gCost p wd avail) t k := by + rw [hlenk, hsides k (by omega) hkl, hwidth, if_pos hav] + have hsplit := prefixSides_add p (gCost p wd avail) k (p.spineLen[t]! - k) t + rw [show k + (p.spineLen[t]! - k) = p.spineLen[t]! by omega] at hsplit + unfold gCutCost + rw [show p.spineLen[t]! - (p.spineLen[t]! - k) = k by omega, hsplit] + simp + have hidx : (index[spineAt p t k]?.getD none).isSome = true := by rw [hindex]; exact hav + simp only [Prep.cutOptions, hidx, if_true] + obtain ⟨L, hL, hcost⟩ := ih (k + 1) _ _ (by omega) (by omega) (by omega) + (FirstAvail.shift hlenk (hbelow k (by omega) hkl)) + refine ⟨(Choice.cut (p.spineLen[t]! - p.spineLen[spineAt p t k]!), + tag4Size (p.spineLen[t]! - p.spineLen[spineAt p t k]!) + + (prefixSides p (gCost p wd avail) t p.spineLen[t]! - ev.sides[spineAt p t k]!) + + (widthOf width (spineAt p t k)).getD 0, + tag4Bytes flag (p.spineLen[t]! - p.spineLen[spineAt p t k]!)) :: L, ?_, ?_⟩ + · rw [hL]; simp + · rw [List.map_cons, hcost, gCutsFromC_split p wd avail _ t j k hjk hkl hav hnone] + simp only + rw [hcand, hlenk, show p.spineLen[t]! - (p.spineLen[t]! - k) = k by omega] + +/-- The options of a term: its Share (if stored), its inline node, or a +telescope cut of `j` spine nodes, with the model costs. -/ +theorem PrepWF.gOptions_mem {p : Prep} (hp : PrepWF p) + {wd : Nat → Nat} {avail : Nat → Bool} (ev : DictEval) (hev : GEvalOK p wd avail ev) (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) + (hindex : ∀ u, (index[u]?.getD none).isSome = avail u) {t : Nat} (ht : t < p.dag.size) + {ch : Choice} {c : Nat} {b : ByteArray} + (h : (ch, c, b) ∈ (p.options ev index width t).toList) : + (ch = .share ∧ c = wd t ∧ avail t = true) ∨ + (ch = .inline ∧ p.family[t]! = .none ∧ c = gInl p wd avail t) ∨ + (∃ j, ch = .cut j ∧ p.family[t]! ≠ .none ∧ 1 ≤ j ∧ j ≤ p.spineLen[t]! ∧ + ((j = p.spineLen[t]! ∧ c = naturalCost p (gCost p wd avail) t) ∨ + (j < p.spineLen[t]! ∧ avail (spineAt p t j) = true ∧ + c = gCutCost p wd (gCost p wd avail) t j))) := by + have hrow : ∀ t', t' < p.dag.size → GEvalRow p wd avail ev t' := + hev.2 + have hcost : ∀ c, ev.cost[c]! = gCost p wd avail c := + hev.cost + -- the base: the Share option, if any + have hbase : ∀ x ∈ (match index[t]?.getD none with + | some i => #[(Choice.share, (widthOf width t).getD 0, tag4Bytes Ixon.Expr.FLAG_SHARE i)] + | none => (#[] : Array (Choice × Nat × ByteArray))).toList, + x.1 = .share ∧ x.2.1 = wd t ∧ avail t = true := by + intro x hx + split at hx + · rename_i i hi + simp only [List.mem_singleton] at hx + have hav : avail t = true := by rw [← hindex, hi]; rfl + subst hx + exact ⟨rfl, by simp [hwidth, hav], hav⟩ + · simp at hx + unfold Prep.options at h + by_cases hf : p.family[t]! = .none + · have hfb : (p.family[t]! == Family.none) = true := by simp [hf] + simp only [hfb, if_true, Array.toList_push, List.mem_append, List.mem_singleton] at h + rcases h with h | h + · obtain ⟨h1, h2, h3⟩ := hbase _ h + exact Or.inl ⟨h1, h2, h3⟩ + · simp only [Prod.mk.injEq] at h + obtain ⟨rfl, rfl, _⟩ := h + refine Or.inr (Or.inl ⟨rfl, hf, ?_⟩) + unfold gInl gInlOf + rw [if_pos hf] + exact foldl_add_congr _ _ fun c _ => hcost c + · have hfb : (p.family[t]! == Family.none) = false := by simpa using hf + simp only [hfb, Bool.false_eq_true, if_false] at h + obtain ⟨hs, hb⟩ := (hrow t ht).2 hf + obtain ⟨hl1, hk, _, htl, _⟩ := hp.spine t ht hf + have hspine : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + GEvalRow p wd avail ev (spineAt p t k) ∧ + p.family[spineAt p t k]! ≠ .none ∧ + p.spineLen[spineAt p t k]! = p.spineLen[t]! - k := by + intro k h1 h2 + have hlt' := hp.spineAt_lt ht hf h1 h2 + obtain ⟨_, hkf, hklen, _⟩ := hk k h2 + exact ⟨hrow _ (by omega), by rw [hkf]; exact hf, hklen⟩ + obtain ⟨L, hL, hLc⟩ := hp.gCutOptions_pairs ev index width hwidth + hindex ht hf (p.dag.node t).head.flag + (fun k h1 h2 => by + obtain ⟨hr, hfk, hlenk⟩ := hspine k h1 h2 + rw [(hr.2 hfk).1, hlenk]) + (fun k h1 h2 => by + obtain ⟨hr, hfk, _⟩ := hspine k h1 h2 + exact (hr.2 hfk).2) + p.spineLen[t]! 1 _ ((match index[t]?.getD none with + | some i => #[(Choice.share, (widthOf width t).getD 0, tag4Bytes Ixon.Expr.FLAG_SHARE i)] + | none => #[]).push (Choice.cut p.spineLen[t]!, + tag4Size p.spineLen[t]! + ev.sides[t]! + + ev.cost[p.tail[t]!]!, + tag4Bytes (p.dag.node t).head.flag p.spineLen[t]!)) (Nat.le_refl _) (by omega) + (by omega) hb + rw [← hs] at hL + have h' := hL ▸ h + simp only [List.mem_append, Array.toList_push, List.mem_singleton] at h' + rcases h' with (h' | h') | h' + · obtain ⟨h1, h2, h3⟩ := hbase _ h' + exact Or.inl ⟨h1, h2, h3⟩ + · simp only [Prod.mk.injEq] at h' + obtain ⟨rfl, rfl, _⟩ := h' + refine Or.inr (Or.inr ⟨_, rfl, hf, hl1, Nat.le_refl _, Or.inl ⟨rfl, ?_⟩⟩) + rw [hs, hcost] + rfl + · have hm : (ch, c) ∈ gCutsFromC p wd avail (gCost p wd avail) t 1 := by + rw [← hLc] + exact List.mem_map.mpr ⟨_, h', rfl⟩ + obtain ⟨k, hk1, hkl, hav, rfl, rfl⟩ := mem_gCutsFromC hm + exact Or.inr (Or.inr ⟨k, rfl, hf, hk1, by omega, Or.inr ⟨hkl, hav, rfl⟩⟩) + +/-- Every expression `build` emits has the length of the model: its entry +cost for an entry body, its standalone cost otherwise (Shares priced by `wd`), +and it continues no telescope of another family. -/ +theorem PrepWF.gBuild_size {p : Prep} (hp : PrepWF p) + {wd : Nat → Nat} {avail : Nat → Bool} (ev : DictEval) (hev : GEvalOK p wd avail ev) (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) + (hindex : ∀ u, (index[u]?.getD none).isSome = avail u) + (sc : Nat → Nat) + (hsc : ∀ (u i : Nat), index[u]?.getD none = some i → i < UInt64.size ∧ sc i = wd u) : + ∀ (fuel : Nat) (entry : Bool) (t : Nat) (e : Ixon.Expr), t < p.dag.size → + p.build ev index width entry fuel t = .ok e → + (sizeInfoWith sc e).full = (if entry then gInl p wd avail t else gCost p wd avail t) ∧ + OnlyCont p.family[t]! (sizeInfoWith sc e) := by + have hcost : ∀ c, ev.cost[c]! = gCost p wd avail c := + hev.cost + have hshare : ∀ (u i : Nat), index[u]?.getD none = some i → + (sizeInfoWith sc (.share i.toUInt64)).full = wd u := by + intro u i hi + obtain ⟨hlt, hw⟩ := hsc u i hi + simp only [sizeInfoWith, SizeInfo.plain, toNat_toUInt64_of_lt hlt, hw] + intro fuel + induction fuel with + | zero => intro entry t e _ h; simp [Prep.build] at h + | succ fuel ih => + intro entry t e ht h + simp only [Prep.build] at h + split at h + · rename_i choice c hpick + split at h + · rename_i hcheck + -- the chosen option and its cost + obtain ⟨b, hb⟩ := pickOption_mem _ hpick + have hmem : (choice, c, b) ∈ (p.options ev index width t).toList := by + split at hb + · rw [Array.toList_filter] at hb; exact (List.mem_filter.mp hb).1 + · exact hb + have hc : (if entry then gInl p wd avail t else gCost p wd avail t) = c := by + cases entry with + | false => + simp only [Bool.false_or, beq_iff_eq] at hcheck + simp only [Bool.false_eq_true, if_false] + rw [← hcost, hcheck] + | true => + simp only [if_true] + rw [← hp.gInlineCost_eq ev hev index width hwidth hindex t ht] + unfold Prep.inlineCost + simp only [if_true] at hpick + rw [hpick] + rfl + rw [hc] + have hopt := hp.gOptions_mem ev hev index width hwidth hindex ht hmem + split at h + · -- Share + obtain ⟨_, rfl, _⟩ | ⟨h1, _⟩ | ⟨j, h1, _⟩ := hopt + · split at h + · rename_i i hi + cases h + exact ⟨hshare t i hi, share_onlyCont sc _ _⟩ + · cases h + · cases h1 + · cases h1 + · -- inline node + obtain ⟨h1, _⟩ | ⟨_, hf, hcv⟩ | ⟨j, h1, _⟩ := hopt + · cases h1 + · rw [hcv] + unfold gInl gInlOf + rw [if_pos hf] + have har := hp.dag.arity t ht + rw [← dag_node_eq ht] at har + cases hh : (p.dag.node t).head <;> simp only [hh] at h har + case prj ti f => + obtain ⟨v, hv, hpure⟩ := bind_eq_ok h + cases hpure + have hc0 : (p.dag.node t).child 0 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + obtain ⟨hvs, _⟩ := ih false _ v (by omega) hv + simp only [Bool.false_eq_true, if_false] at hvs + refine ⟨?_, fun F' _ => by cases F' <;> rfl⟩ + rw [← Array.foldl_toList, children_toList (m := 1) (by simpa [Head.arity] using har)] + simp [sizeInfoWith, SizeInfo.plain, hvs, Head.ownBytes] <;> omega + case letE lc => + obtain ⟨ty, hty, h2⟩ := bind_eq_ok h + obtain ⟨v, hv, h3⟩ := bind_eq_ok h2 + obtain ⟨bd, hbd, hpure⟩ := bind_eq_ok h3 + cases hpure + have hc0 : (p.dag.node t).child 0 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + have hc1 : (p.dag.node t).child 1 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + have hc2 : (p.dag.node t).child 2 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + obtain ⟨hs0, _⟩ := ih false _ ty (by omega) hty + obtain ⟨hs1, _⟩ := ih false _ v (by omega) hv + obtain ⟨hs2, _⟩ := ih false _ bd (by omega) hbd + simp only [Bool.false_eq_true, if_false] at hs0 hs1 hs2 + refine ⟨?_, fun F' _ => by cases F' <;> rfl⟩ + rw [← Array.foldl_toList, children_toList (m := 3) (by simpa [Head.arity] using har)] + simp [sizeInfoWith, SizeInfo.plain, hs0, hs1, hs2, Head.ownBytes, + List.range_succ] <;> omega + all_goals first + | (cases h; done) + | (cases h + simp only [Node.toExpr, hh] + refine ⟨?_, fun F' _ => by cases F' <;> rfl⟩ + rw [← Array.foldl_toList, + children_toList (m := 0) (by simpa [Head.arity] using har)] + simp [sizeInfoWith, SizeInfo.plain, Head.ownBytes]) + · cases h1 + · -- telescope cut + rename_i j + obtain ⟨h1, _⟩ | ⟨h1, _⟩ | ⟨j', hj', hf, hj1, hjl, hcase⟩ := hopt + · cases h1 + · cases h1 + cases hj' + obtain ⟨_, hk, hend, htl, htf⟩ := hp.spine t ht hf + have hfam : ∀ n ∈ (List.range j).map (fun k => p.dag.node (spineAt p t k)), + n.head.family = p.family[t]! := by + intro n hn + obtain ⟨k, hk', rfl⟩ := List.mem_map.mp hn + rw [List.mem_range] at hk' + obtain ⟨hle, hkf, _, _⟩ := hk k (by omega) + rw [← hp.family _ (by omega), hkf] + have hsz : ∀ n ∈ (List.range j).map (fun k => p.dag.node (spineAt p t k)), ∀ e', + p.build ev index width false fuel n.sideChild = .ok e' → + (sizeInfoWith sc e').full = gCost p wd avail n.sideChild := by + intro n hn e' he' + obtain ⟨k, hk', rfl⟩ := List.mem_map.mp hn + rw [List.mem_range] at hk' + obtain ⟨hle, hkf, _, _⟩ := hk k (by omega) + have hs := hp.sideChild_lt (t := spineAt p t k) (by omega) (by rw [hkf]; exact hf) + have := (ih false _ e' (by omega) he').1 + simpa using this + have hsum : (((List.range j).map (fun k => p.dag.node (spineAt p t k))).map + (fun n => n.sideExtra + gCost p wd avail n.sideChild)).sum = + prefixSides p (gCost p wd avail) t j := by + rw [prefixSides_eq_sum, List.map_map] + rfl + have hlen : ((List.range j).map (fun k => p.dag.node (spineAt p t k))).length = j := by + simp + have hne : (List.range j).map (fun k => p.dag.node (spineAt p t k)) ≠ [] := by + intro h0 + have := congrArg List.length h0 + simp at this + omega + rw [spineWalk_eq] at h + split at h + · cases h + split at h + · -- the prefix ends in a Share + rename_i _ hjlt + split at h + · rename_i i hi + obtain ⟨tl, htl', hfold⟩ := bind_eq_ok h + cases htl' + obtain ⟨_, hfull, honly⟩ := spineFold_size sc p.family[t]! _ + (fun n => gCost p wd avail n.sideChild) _ _ _ hfam hsz + (by cases p.family[t]! <;> rfl) hfold + refine ⟨?_, honly hne⟩ + rw [hfull hne, hlen, hsum, hshare _ i hi] + rcases hcase with ⟨hjl', _⟩ | ⟨_, _, hcv⟩ + · omega + · rw [hcv] + unfold gCutCost + simp only at * + omega + · obtain ⟨tl, htl', _⟩ := bind_eq_ok h + cases htl' + · -- the full spine ends in the natural tail + rename_i _ hjlt + have hjeq : j = p.spineLen[t]! := by omega + obtain ⟨tl, htl', hfold⟩ := bind_eq_ok h + simp only at htl' + rw [hjeq, hend] at htl' + obtain ⟨htfull, htonly⟩ := ih false _ tl (by omega) htl' + simp only [Bool.false_eq_true, if_false] at htfull + obtain ⟨_, hfull, honly⟩ := spineFold_size sc p.family[t]! _ + (fun n => gCost p wd avail n.sideChild) _ _ _ hfam hsz + (htonly _ (Ne.symm htf)) hfold + refine ⟨?_, honly hne⟩ + rw [hfull hne, hlen, hsum, htfull] + rcases hcase with ⟨_, hcv⟩ | ⟨hjl', _, _⟩ + · rw [hcv, hjeq] + unfold naturalCost + omega + · omega + · cases h + · cases h + +/-! ## Writings at per-term widths -/ + +mutual +/-- Length of a writing (the Share of `x` priced `wd x`). -/ +def WTree.gcost (p : Prep) (wd : Nat → Nat) : WTree → Nat + | .share x => wd x + | .node x kids => (p.dag.node x).head.ownBytes + WTree.gcosts p wd kids + | .tele x j sides tail => + tag4Size j + j * (p.dag.node x).sideExtra + WTree.gcosts p wd sides + WTree.gcost p wd tail +/-- Total length of a list of writings. -/ +def WTree.gcosts (p : Prep) (wd : Nat → Nat) : List WTree → Nat + | [] => 0 + | k :: ks => WTree.gcost p wd k + WTree.gcosts p wd ks +end + +theorem WTree.gcosts_eq (p : Prep) (wd : Nat → Nat) (l : List WTree) : + WTree.gcosts p wd l = (l.map (WTree.gcost p wd)).sum := by + induction l with + | nil => rfl + | cons k ks ih => simp [WTree.gcosts, ih] + +theorem gCostOf_le_inl (p : Prep) (wd : Nat → Nat) (S : Nat → Bool) (f : Nat → Nat) (x : Nat) : + gCostOf p wd S f x ≤ gInlOf p wd S f x := by + unfold gCostOf; split <;> omega + +theorem PrepWF.gInl_node {p : Prep} (hp : PrepWF p) (wd : Nat → Nat) (S : Nat → Bool) (f : Nat → Nat) + {x : Nat} (hx : x < p.dag.size) (hf : p.family[x]! = .none) : + gInlOf p wd S f x = (p.dag.node x).head.ownBytes + + ((List.range (p.dag.node x).head.arity).map fun i => f ((p.dag.node x).child i)).sum := by + unfold gInlOf + rw [if_pos hf, ← Array.foldl_toList, foldl_add_eq_sum] + have har := hp.dag.arity x hx + rw [← dag_node_eq hx] at har + rw [children_toList har, List.map_map] + rfl + +theorem gInl_tele {p : Prep} (wd : Nat → Nat) (S : Nat → Bool) (f : Nat → Nat) + {x : Nat} (hf : p.family[x]! ≠ .none) : + gInlOf p wd S f x = (gCutCosts p wd S f x).foldl min (naturalCost p f x) := by + unfold gInlOf + rw [if_neg hf] + +theorem gCut_mem_cutCosts (p : Prep) (wd : Nat → Nat) (S : Nat → Bool) (f : Nat → Nat) {x j : Nat} + (hj1 : 1 ≤ j) (hj : j < p.spineLen[x]!) (hS : S (spineAt p x j) = true) : + gCutCost p wd f x j ∈ gCutCosts p wd S f x := by + rw [gCutCosts_eq] + unfold gCutsFrom + apply List.mem_filterMap.mpr + refine ⟨j, List.mem_range'_1.mpr ⟨hj1, by omega⟩, ?_⟩ + rw [if_pos hS] + +theorem gcosts_eq_range (p : Prep) (wd : Nat → Nat) (l : List WTree) : + WTree.gcosts p wd l = ((List.range l.length).map fun k => (l[k]?.getD default).gcost p wd).sum := by + rw [WTree.gcosts_eq] + congr 1 + apply List.ext_getElem (by simp) + intro k h1 h2 + simp only [List.getElem_map, List.getElem_range] + rw [List.getElem?_eq_getElem (by simpa using h1)] + rfl + +/-- **Lower bound.** Every writing of `x` is at least `C_S(x)` long, and +every inline writing at least `inl_S(x)`. -/ +theorem PrepWF.gValid_cost {p : Prep} (hp : PrepWF p) (wd : Nat → Nat) (S : Nat → Bool) : + ∀ {x : Nat} {T : WTree}, Valid p S x T → x < p.dag.size → + gCost p wd S x ≤ T.gcost p wd ∧ (T.isShare = false → gInl p wd S x ≤ T.gcost p wd) := by + intro x T h + induction h with + | share hS => + intro hx + refine ⟨?_, fun h => by simp [WTree.isShare] at h⟩ + rw [hp.gCost_eq wd S _ hx] + unfold gCostOf + simp only [hS, if_true, WTree.gcost] + omega + | @node x kids hf hlen _ ih => + intro hx + have hinl : gInl p wd S x ≤ (WTree.node x kids).gcost p wd := by + unfold gInl + rw [hp.gInl_node wd S _ hx hf] + simp only [WTree.gcost] + rw [gcosts_eq_range, hlen] + have : ∀ i ∈ List.range (p.dag.node x).head.arity, + gCost p wd S ((p.dag.node x).child i) ≤ (kids[i]?.getD default).gcost p wd := by + intro i hi + rw [List.mem_range] at hi + have hc := hp.dag.childAt_lt hx hi + rw [show kids[i]?.getD default = kids[i]'(by omega) by simp [hlen ▸ hi]] + exact (ih i (by omega) (by omega)).1 + have := sum_le_sum_of_le _ this + omega + refine ⟨?_, fun _ => hinl⟩ + rw [hp.gCost_eq wd S _ hx] + exact Nat.le_trans (gCostOf_le_inl _ _ _ _ _) hinl + | @teleCut x j sides hf hj1 hj hlen _ hS ih => + intro hx + have hinl : gInl p wd S x ≤ (WTree.tele x j sides (.share (spineAt p x j))).gcost p wd := by + unfold gInl + rw [gInl_tele wd S _ hf] + refine Nat.le_trans (foldl_min_le _ _ _ (List.mem_cons_of_mem _ + (gCut_mem_cutCosts p wd S _ hj1 hj hS))) ?_ + unfold gCutCost + rw [hp.prefixSides_eq _ hx hf (by omega)] + simp only [WTree.gcost] + rw [gcosts_eq_range, hlen] + have : ∀ k ∈ List.range j, gCost p wd S (sideAt p x k) ≤ (sides[k]?.getD default).gcost p wd := by + intro k hk + rw [List.mem_range] at hk + rw [show sides[k]?.getD default = sides[k]'(by omega) by simp [hlen ▸ hk]] + exact (ih k (by omega) (by have := hp.sideAt_lt hx hf (k := k) (by omega); omega)).1 + have := sum_le_sum_of_le _ this + omega + refine ⟨?_, fun _ => hinl⟩ + rw [hp.gCost_eq wd S _ hx] + exact Nat.le_trans (gCostOf_le_inl _ _ _ _ _) hinl + | @teleFull x sides tail hf hlen _ _ ih iht => + intro hx + obtain ⟨_, _, _, htl, _⟩ := hp.spine x hx hf + have hinl : gInl p wd S x ≤ (WTree.tele x p.spineLen[x]! sides tail).gcost p wd := by + unfold gInl + rw [gInl_tele wd S _ hf] + refine Nat.le_trans (foldl_min_le _ _ _ List.mem_cons_self) ?_ + unfold naturalCost + rw [hp.prefixSides_eq _ hx hf (Nat.le_refl _)] + simp only [WTree.gcost] + rw [gcosts_eq_range, hlen] + have : ∀ k ∈ List.range p.spineLen[x]!, + gCost p wd S (sideAt p x k) ≤ (sides[k]?.getD default).gcost p wd := by + intro k hk + rw [List.mem_range] at hk + rw [show sides[k]?.getD default = sides[k]'(by omega) by simp [hlen ▸ hk]] + exact (ih k (by omega) (by have := hp.sideAt_lt hx hf (k := k) (by omega); omega)).1 + have := sum_le_sum_of_le _ this + have ht := (iht (by omega)).1 + omega + refine ⟨?_, fun _ => hinl⟩ + rw [hp.gCost_eq wd S _ hx] + exact Nat.le_trans (gCostOf_le_inl _ _ _ _ _) hinl + +theorem mem_gCutCosts {p : Prep} {wd : Nat → Nat} {S : Nat → Bool} {f : Nat → Nat} {x c : Nat} + (h : c ∈ gCutCosts p wd S f x) : + ∃ j, 1 ≤ j ∧ j < p.spineLen[x]! ∧ S (spineAt p x j) = true ∧ c = gCutCost p wd f x j := by + rw [gCutCosts_eq] at h + unfold gCutsFrom at h + obtain ⟨j, hj, hjv⟩ := List.mem_filterMap.mp h + rw [List.mem_range'_1] at hj + split at hjv + · rename_i hS + simp only [Option.some.injEq] at hjv + exact ⟨j, hj.1, by omega, hS, hjv.symm⟩ + · cases hjv + +theorem gcosts_map_range (p : Prep) (wd : Nat → Nat) (g : Nat → WTree) (n : Nat) : + WTree.gcosts p wd ((List.range n).map g) = ((List.range n).map fun k => (g k).gcost p wd).sum := by + rw [WTree.gcosts_eq, List.map_map] + rfl + +/-- **Attainment.** Some writing of `x` has length `C_S(x)`, and some inline +writing has length `inl_S(x)`. -/ +theorem PrepWF.gExists_opt {p : Prep} (hp : PrepWF p) (wd : Nat → Nat) (S : Nat → Bool) : + ∀ x, x < p.dag.size → + (∃ T, Valid p S x T ∧ T.gcost p wd = gCost p wd S x) ∧ + ∃ T, Valid p S x T ∧ T.isShare = false ∧ T.gcost p wd = gInl p wd S x := by + intro x + induction x using Nat.strongRecOn with + | _ x ih => + intro hx + classical + let g : Nat → WTree := fun c => + if h : c < x ∧ c < p.dag.size then Classical.choose (ih c h.1 h.2).1 else default + have hg : ∀ c, c < x → Valid p S c (g c) ∧ (g c).gcost p wd = gCost p wd S c := by + intro c hc + have hcn : c < p.dag.size := by omega + simp only [g, dif_pos (And.intro hc hcn)] + exact Classical.choose_spec (ih c hc hcn).1 + -- an optimal inline writing + have hinl : ∃ T, Valid p S x T ∧ T.isShare = false ∧ T.gcost p wd = gInl p wd S x := by + by_cases hf : p.family[x]! = .none + · let ar := (p.dag.node x).head.arity + refine ⟨.node x ((List.range ar).map fun i => g ((p.dag.node x).child i)), ?_, rfl, ?_⟩ + · refine Valid.node hf (by simp [ar]) fun i hi => ?_ + simp only [List.length_map, List.length_range] at hi + simp only [List.getElem_map, List.getElem_range] + exact (hg _ (hp.dag.childAt_lt hx hi)).1 + · simp only [WTree.gcost, gcosts_map_range] + unfold gInl + rw [hp.gInl_node wd S _ hx hf] + simp only [ar] + congr 2 + apply List.map_congr_left + intro i hi + rw [List.mem_range] at hi + exact (hg _ (hp.dag.childAt_lt hx hi)).2 + · obtain ⟨hl1, _, hend, htl, _⟩ := hp.spine x hx hf + have hmin := foldl_min_mem (gCutCosts p wd S (gCost p wd S) x) + (naturalCost p (gCost p wd S) x) + rw [← gInl_tele wd S _ hf] at hmin + have hsides : ∀ j, j ≤ p.spineLen[x]! → + WTree.gcosts p wd ((List.range j).map fun k => g (sideAt p x k)) = + ((List.range j).map fun k => gCost p wd S (sideAt p x k)).sum := by + intro j hj + rw [gcosts_map_range] + congr 1 + apply List.map_congr_left + intro k hk + rw [List.mem_range] at hk + exact (hg _ (hp.sideAt_lt hx hf (by omega))).2 + have hsv : ∀ j, j ≤ p.spineLen[x]! → ∀ (k : Nat) + (h : k < ((List.range j).map fun k => g (sideAt p x k)).length), + Valid p S (sideAt p x k) ((List.range j).map fun k => g (sideAt p x k))[k] := by + intro j hj k hk + simp only [List.length_map, List.length_range] at hk + simp only [List.getElem_map, List.getElem_range] + exact (hg _ (hp.sideAt_lt hx hf (by omega))).1 + rcases List.mem_cons.mp hmin with hnat | hcut + · refine ⟨.tele x p.spineLen[x]! ((List.range p.spineLen[x]!).map fun k => g (sideAt p x k)) + (g p.tail[x]!), Valid.teleFull hf (by simp) (hsv _ (Nat.le_refl _)) + (hg _ htl).1, rfl, ?_⟩ + simp only [WTree.gcost] + rw [hsides _ (Nat.le_refl _), (hg _ htl).2] + unfold gInl + rw [hnat] + unfold naturalCost + rw [hp.prefixSides_eq _ hx hf (Nat.le_refl _)] + omega + · obtain ⟨j, hj1, hjl, hS, hc⟩ := mem_gCutCosts hcut + refine ⟨.tele x j ((List.range j).map fun k => g (sideAt p x k)) + (.share (spineAt p x j)), Valid.teleCut hf hj1 hjl (by simp) (hsv _ (by omega)) hS, + rfl, ?_⟩ + simp only [WTree.gcost] + rw [hsides _ (by omega)] + unfold gInl + rw [hc] + unfold gCutCost + rw [hp.prefixSides_eq _ hx hf (by omega)] + omega + refine ⟨?_, hinl⟩ + obtain ⟨T, hT, hTs, hTc⟩ := hinl + rw [hp.gCost_eq wd S x hx] + unfold gCostOf + by_cases hS : S x = true + · by_cases hle : wd x ≤ gInlOf p wd S (gCost p wd S) x + · refine ⟨.share x, Valid.share hS, ?_⟩ + simp only [hS, if_true, WTree.gcost] + omega + · refine ⟨T, hT, ?_⟩ + simp only [hS, if_true] + unfold gInl at hTc + omega + · refine ⟨T, hT, ?_⟩ + simp only [hS, Bool.false_eq_true, if_false] + exact hTc + +/-! ## Locality and the incremental re-evaluation -/ + +open Ix.Compile.Verify.SharingExact (Desc Desc.trans) in +/-- The spine nodes of `y` up to its tail are below it. -/ +theorem desc_spineAt {dag : Dag} (hwf : DagWF dag) {y : Nat} (hy : y < dag.size) + (hf : (Prep.ofDag dag).family[y]! ≠ .none) : + ∀ k, k ≤ (Prep.ofDag dag).spineLen[y]! → Desc dag y (spineAt (Prep.ofDag dag) y k) := by + have hp := prepWF_ofDag hwf + obtain ⟨_, hk, _, _, _⟩ := hp.spine y hy hf + intro k + induction k with + | zero => intro _; exact .refl _ + | succ k ih => + intro hkl + have hd := ih (by omega) + obtain ⟨hle, hkf, _, _⟩ := hk k (by omega) + have hks : spineAt (Prep.ofDag dag) y k < dag.size := by + have : spineAt (Prep.ofDag dag) y k ≤ y := hle + omega + have hfk : (Prep.ofDag dag).family[spineAt (Prep.ofDag dag) y k]! ≠ .none := by + rw [hkf]; exact hf + obtain ⟨m, hm, he⟩ := hp.snext_edge hks hfk + rw [← snext_spineAt, ← he] + exact desc_snoc hd (by rw [hwf.children_size hks]; exact hm) + +open Ix.Compile.Verify.SharingExact (Desc Desc.trans) in +theorem desc_sideAt {dag : Dag} (hwf : DagWF dag) {y : Nat} (hy : y < dag.size) + (hf : (Prep.ofDag dag).family[y]! ≠ .none) {k : Nat} (hk : k < (Prep.ofDag dag).spineLen[y]!) : + Desc dag y (sideAt (Prep.ofDag dag) y k) := by + have hp := prepWF_ofDag hwf + obtain ⟨_, hk', _, _, _⟩ := hp.spine y hy hf + obtain ⟨hle, hkf, _, _⟩ := hk' k hk + have hks : spineAt (Prep.ofDag dag) y k < dag.size := by + have : spineAt (Prep.ofDag dag) y k ≤ y := hle + omega + have hfk : (Prep.ofDag dag).family[spineAt (Prep.ofDag dag) y k]! ≠ .none := by + rw [hkf]; exact hf + obtain ⟨m, hm, he⟩ := hp.side_edge hks hfk + unfold sideAt + rw [← he] + exact desc_snoc (desc_spineAt hwf hy hf k (by omega)) + (by rw [hwf.children_size hks]; exact hm) + +open Ix.Compile.Verify.SharingExact (Desc Desc.trans) in +/-- **Locality.** The model cost of `y` depends only on the dictionary on the +terms at or below `y`. -/ +theorem gCost_local {dag : Dag} (hwf : DagWF dag) {wdA wdB : Nat → Nat} {A B : Nat → Bool} : + ∀ y, y < dag.size → (∀ v, Desc dag y v → A v = B v ∧ wdA v = wdB v) → + gCost (Prep.ofDag dag) wdA A y = gCost (Prep.ofDag dag) wdB B y := by + have hp := prepWF_ofDag hwf + intro y + induction y using Nat.strongRecOn with + | _ y ih => + intro hy hag + have hsub : ∀ c, c < y → Desc dag y c → + gCost (Prep.ofDag dag) wdA A c = gCost (Prep.ofDag dag) wdB B c := + fun c hc hd => ih c hc (by omega) fun v hv => hag v (hd.trans hv) + rw [hp.gCost_eq wdA A y hy, hp.gCost_eq wdB B y hy] + obtain ⟨hAy, hwy⟩ := hag y (.refl _) + have hinl : gInlOf (Prep.ofDag dag) wdA A (gCost (Prep.ofDag dag) wdA A) y = + gInlOf (Prep.ofDag dag) wdB B (gCost (Prep.ofDag dag) wdB B) y := by + unfold gInlOf + split + · apply foldl_add_congr + intro c hc + have hc' : c ∈ (dag.node y).children := hc + have hlt := hwf.child_lt hy hc' + obtain ⟨k, hk, rfl⟩ := Array.mem_iff_getElem.mp hc' + have hd : Desc dag ((dag.node y).child k) (dag.node y).children[k] := by + rw [child_eq_getElem _ k hk]; exact .refl _ + exact hsub _ hlt (.child k hk hd) + · rename_i hf + obtain ⟨_, _, hend, htl, _⟩ := hp.spine y hy hf + have hsides : ∀ j, j ≤ (Prep.ofDag dag).spineLen[y]! → + prefixSides (Prep.ofDag dag) (gCost (Prep.ofDag dag) wdA A) y j = + prefixSides (Prep.ofDag dag) (gCost (Prep.ofDag dag) wdB B) y j := by + intro j hj + apply prefixSides_local + intro i hi + exact hsub _ (hp.sideAt_lt hy hf (by omega)) (desc_sideAt hwf hy hf (by omega)) + have hcuts : gCutCosts (Prep.ofDag dag) wdA A (gCost (Prep.ofDag dag) wdA A) y = + gCutCosts (Prep.ofDag dag) wdB B (gCost (Prep.ofDag dag) wdB B) y := by + unfold gCutCosts gCutsFrom + apply filterMap_congr' + intro j hj + rw [List.mem_range'_1] at hj + obtain ⟨hA, hw⟩ := hag _ (desc_spineAt hwf hy hf j (by omega)) + unfold gCutCost + rw [hA, hw, hsides j (by omega)] + rw [hcuts] + unfold naturalCost + rw [hsides _ (Nat.le_refl _), hsub _ htl (by + rw [← hend]; exact desc_spineAt hwf hy hf _ (Nat.le_refl _))] + unfold gCostOf + rw [hinl, hAy, hwy] + +open Ix.Compile.Verify.SharingExact (Desc Desc.trans) in +/-- The evaluation rows of `t` carry over between dictionaries that agree +at and below `t`. -/ +theorem gEvalRow_local {dag : Dag} (hwf : DagWF dag) {wdA wdB : Nat → Nat} {A B : Nat → Bool} + {st : DictEval} {t : Nat} (ht : t < dag.size) + (hag : ∀ v, Desc dag t v → A v = B v ∧ wdA v = wdB v) + (h : GEvalRow (Prep.ofDag dag) wdA A st t) : GEvalRow (Prep.ofDag dag) wdB B st t := by + have hp := prepWF_ofDag hwf + obtain ⟨hc, hs⟩ := h + refine ⟨by rw [hc]; exact gCost_local hwf t ht hag, fun hf => ?_⟩ + obtain ⟨hsd, hfa⟩ := hs hf + refine ⟨?_, ?_⟩ + · rw [hsd] + apply prefixSides_local + intro i hi + have hlt := hp.sideAt_lt ht hf hi + have hd := desc_sideAt hwf ht hf hi + exact gCost_local hwf _ (by omega) fun v hv => hag v (hd.trans hv) + · have hagk : ∀ k, k < (Prep.ofDag dag).spineLen[t]! → + A (spineAt (Prep.ofDag dag) t k) = B (spineAt (Prep.ofDag dag) t k) := + fun k hk => (hag _ (desc_spineAt hwf ht hf k (by omega))).1 + cases hb : st.below[t]! with + | none => + rw [hb] at hfa + intro k hk1 hk2 + rw [← hagk k hk2]; exact hfa k hk1 hk2 + | some u => + rw [hb] at hfa + obtain ⟨k, hk1, hk2, hu, hau, hnone⟩ := hfa + refine ⟨k, hk1, hk2, hu, by rw [hu, ← hagk k hk2, ← hu]; exact hau, fun k' h1 h2 => ?_⟩ + rw [← hagk k' (by omega)]; exact hnone k' h1 h2 + +open Ix.Compile.Verify.SharingExact (Desc) in +theorem desc_inv {dag : Dag} {a b : Nat} (h : Desc dag a b) : + a = b ∨ ∃ k, ∃ _ : k < (dag.node a).children.size, Desc dag ((dag.node a).child k) b := by + cases h with + | refl => exact Or.inl rfl + | child k hk h => exact Or.inr ⟨k, hk, h⟩ + +open Ix.Compile.Verify.SharingExact (Desc Desc.trans) in +/-- The marks of `ancestorMarks`: `u` is marked iff `t` is at or below it. -/ +theorem ancestorMarks_iff {dag : Dag} (hwf : DagWF dag) {t : Nat} (ht : t < dag.size) : + ∀ u, u < dag.size → ((ancestorMarks dag t)[u]! = true ↔ Desc dag u t) := by + let f := fun (acc : Array Bool) u => + acc.set! u (u == t || (dag.node u).children.any (acc[·]!)) + have hinv : ∀ m, m ≤ dag.size - t → + let acc := (List.range' t m).foldl f (Array.replicate dag.size false) + acc.size = dag.size ∧ (∀ u, u < dag.size → (u < t ∨ t + m ≤ u) → acc[u]! = false) ∧ + ∀ u, t ≤ u → u < t + m → (acc[u]! = true ↔ Desc dag u t) := by + intro m + induction m with + | zero => + intro _ + refine ⟨by simp, fun u hu _ => ?_, fun u h1 h2 => absurd h2 (by omega)⟩ + simp [hu] + | succ m ih => + intro hm + obtain ⟨hs, hz, hrows⟩ := ih (by omega) + simp only at hs hz hrows ⊢ + rw [List.range'_1_concat, List.foldl_append, List.foldl_cons, List.foldl_nil] + generalize hacc : (List.range' t m).foldl f (Array.replicate dag.size false) = acc + at hs hz hrows + have hkeep : ∀ u, u ≠ t + m → (f acc (t + m))[u]! = acc[u]! := + fun u hu => setBang_getElem!_ne _ _ hu + refine ⟨by simp [f, hs], fun u hu hr => ?_, fun u h1 h2 => ?_⟩ + · rw [hkeep u (by omega)] + exact hz u hu (by omega) + · by_cases hum : u = t + m + · subst hum + simp only [f] + rw [setBang_getElem!_self _ _ (by omega)] + rw [Bool.or_eq_true, beq_iff_eq, Array.any_eq_true] + constructor + · rintro (h | ⟨k, hk, hc⟩) + · rw [h]; exact .refl _ + · have hlt : (dag.node (t + m)).children[k] < t + m := + hwf.child_lt (by omega) (Array.getElem_mem _) + refine .child k hk ?_ + rw [child_eq_getElem _ k hk] + by_cases hct : (dag.node (t + m)).children[k] < t + · rw [hz _ (by omega) (Or.inl hct)] at hc; cases hc + · exact (hrows _ (by omega) hlt).mp hc + · intro hd + rcases desc_inv hd with heq | ⟨k, hk, hd⟩ + · exact Or.inl (by omega) + · right + refine ⟨k, hk, ?_⟩ + rw [child_eq_getElem _ k hk] at hd + have hlt : (dag.node (t + m)).children[k] < t + m := + hwf.child_lt (by omega) (Array.getElem_mem _) + have hge : t ≤ (dag.node (t + m)).children[k] := + Desc.le_of_wf hwf hd (by omega) + exact (hrows _ hge hlt).mpr hd + · rw [hkeep u hum] + exact hrows u h1 (by omega) + intro u hu + obtain ⟨_, hz, hrows⟩ := hinv (dag.size - t) (Nat.le_refl _) + unfold ancestorMarks + rw [foldRange_eq] + by_cases hut : t ≤ u + · exact hrows u hut (by omega) + · rw [hz u hu (Or.inl (by omega))] + constructor + · intro h; cases h + · intro hd; have := Desc.le_of_wf hwf hd hu; omega + +theorem gEvalRow_of_agree {p : Prep} {wd : Nat → Nat} {A : Nat → Bool} {st st' : DictEval} + {t : Nat} (h1 : st'.cost[t]! = st.cost[t]!) (h2 : st'.sides[t]! = st.sides[t]!) + (h3 : st'.below[t]! = st.below[t]!) (h : GEvalRow p wd A st t) : GEvalRow p wd A st' t := by + obtain ⟨hc, hs⟩ := h + exact ⟨by rw [h1, hc], fun hf => by rw [h2, h3]; exact hs hf⟩ + +open Ix.Compile.Verify.SharingExact (Desc Desc.trans) in +/-- **Incremental re-evaluation.** If `ev` gives the model rows of a +dictionary and the new dictionary (`width`, model `A'`, `wd'`) differs from +it only at `t`, then `Prep.evalUp ev width t` gives the new model rows. -/ +theorem evalUp_ok {dag : Dag} (hwf : DagWF dag) {wd wd' : Nat → Nat} {A A' : Nat → Bool} + {ev : DictEval} (hev : GEvalOK (Prep.ofDag dag) wd A ev) {t : Nat} (ht : t < dag.size) + (hdiff : ∀ v, v ≠ t → A' v = A v ∧ wd' v = wd v) (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if A' u then some (wd' u) else none) : + GEvalOK (Prep.ofDag dag) wd' A' ((Prep.ofDag dag).evalUp ev width t) := by + have hp := prepWF_ofDag hwf + let p := Prep.ofDag dag + have hag : ∀ u, u < dag.size → ¬ Desc dag u t → ∀ v, Desc dag u v → A v = A' v ∧ wd v = wd' v := by + intro u hu hnd v hv + have hvt : v ≠ t := fun h => hnd (h ▸ hv) + exact ⟨(hdiff v hvt).1.symm, (hdiff v hvt).2.symm⟩ + let marks := ancestorMarks dag t + let step := evalStep p.dag p.family p.spineLen p.tail width marks + have hinv : ∀ m, m ≤ dag.size - t → + let st := (List.range' t m).foldl step { ev with work := 0 } + (st.cost.size = dag.size ∧ st.sides.size = dag.size ∧ st.below.size = dag.size) ∧ + (∀ u, u < t + m → GEvalRow p wd' A' st u) ∧ + ∀ u, t + m ≤ u → st.cost[u]! = ev.cost[u]! ∧ st.sides[u]! = ev.sides[u]! ∧ + st.below[u]! = ev.below[u]! := by + intro m + induction m with + | zero => + intro _ + refine ⟨hev.1, fun u hu => ?_, fun u _ => ⟨rfl, rfl, rfl⟩⟩ + have hud : u < dag.size := by omega + exact gEvalRow_local hwf hud (hag u hud fun hd => by + have := Desc.le_of_wf hwf hd hud; omega) (hev.2 u hud) + | succ m ih => + intro hm + obtain ⟨hs, hrows, hrest⟩ := ih (by omega) + simp only at hs hrows hrest ⊢ + rw [List.range'_1_concat, List.foldl_append, List.foldl_cons, List.foldl_nil] + generalize hst : (List.range' t m).foldl step { ev with work := 0 } = st + at hs hrows hrest + have hkeep : ∀ u, u ≠ t + m → (step st (t + m)).cost[u]! = st.cost[u]! ∧ + (step st (t + m)).sides[u]! = st.sides[u]! ∧ + (step st (t + m)).below[u]! = st.below[u]! := + fun u hu => evalStep_keep _ _ _ _ width marks st hu + have htm : t + m < dag.size := by omega + by_cases hmark : marks[t + m]! = true + · obtain ⟨hs', hrows'⟩ := hp.gEvalStep_spec width hwidth marks st (t + m) htm hmark hs + hrows + refine ⟨hs', fun u hu => hrows' u (by omega), fun u hu => ?_⟩ + obtain ⟨k1, k2, k3⟩ := hkeep u (by omega) + obtain ⟨r1, r2, r3⟩ := hrest u (by omega) + exact ⟨k1.trans r1, k2.trans r2, k3.trans r3⟩ + · have hid : step st (t + m) = st := by + simp only [step, evalStep] + rw [if_neg hmark] + rw [hid] + refine ⟨hs, fun u hu => ?_, fun u hu => hrest u (by omega)⟩ + by_cases hum : u < t + m + · exact hrows u hum + · have hu' : u = t + m := by omega + subst hu' + have hnd : ¬ Desc dag (t + m) t := fun hd => + hmark ((ancestorMarks_iff hwf ht (t + m) htm).mpr hd) + obtain ⟨r1, r2, r3⟩ := hrest (t + m) (Nat.le_refl _) + refine gEvalRow_local hwf htm (hag _ htm hnd) ?_ + exact gEvalRow_of_agree r1 r2 r3 (hev.2 _ htm) + obtain ⟨hs, hrows, _⟩ := hinv (dag.size - t) (Nat.le_refl _) + have hn : (Prep.ofDag dag).dag.size = dag.size := rfl + refine ⟨?_, fun u hu => ?_⟩ + · unfold Prep.evalUp + rw [foldRange_eq] + exact hs + · unfold Prep.evalUp + rw [foldRange_eq] + exact hrows u (by rw [hn] at hu; omega) + +/-! ## Locality of options and builds, and the work of an evaluation + +Used by the one-pass phase 3 (`materializeTableOnePass_eq`): `build_congr` +(a build depends only on the dictionary at and below its term), +`rows_agree_strict` and `cost_agree` (evaluation rows of two dictionaries +that agree below a term), `evalUp_work` (the work `Prep.evalUp` counts). -/ + +section OnePass + +open Ix.Compile.Verify.SharingExact (Desc Desc.trans) + +/-! ## Agreement of evaluations below a term -/ + +theorem FirstAvail.unique {p : Prep} {avail : Nat → Bool} {t j : Nat} {x y : Option Nat} + (hx : FirstAvail p avail t j x) (hy : FirstAvail p avail t j y) : x = y := by + cases x with + | none => + cases y with + | none => rfl + | some v => + obtain ⟨k, h1, h2, rfl, hav, _⟩ := hy + rw [hx k h1 h2] at hav; cases hav + | some u => + cases y with + | none => + obtain ⟨k, h1, h2, rfl, hav, _⟩ := hx + rw [hy k h1 h2] at hav; cases hav + | some v => + obtain ⟨k, h1, h2, rfl, hav, hn⟩ := hx + obtain ⟨k', h1', h2', rfl, hav', hn'⟩ := hy + rcases Nat.lt_trichotomy k k' with hlt | rfl | hgt + · rw [hn' k h1 hlt] at hav; cases hav + · rfl + · rw [hn k' h1' hgt] at hav'; cases hav' + +theorem FirstAvail.congr {p : Prep} {A B : Nat → Bool} {t j : Nat} {x : Option Nat} + (hag : ∀ k, j ≤ k → k < p.spineLen[t]! → A (spineAt p t k) = B (spineAt p t k)) + (h : FirstAvail p A t j x) : FirstAvail p B t j x := by + cases x with + | none => intro k h1 h2; rw [← hag k h1 h2]; exact h k h1 h2 + | some u => + obtain ⟨k, h1, h2, hu, hau, hn⟩ := h + refine ⟨k, h1, h2, hu, by rw [hu, ← hag k h1 h2, ← hu]; exact hau, fun k' h1' h2' => ?_⟩ + rw [← hag k' h1' (by omega)]; exact hn k' h1' h2' + +/-- Two evaluations with the model rows of dictionaries that agree strictly +below a telescope term `v` have the same spine sums and descendant links at +`v`. -/ +theorem rows_agree_strict {dag : Dag} (hwf : DagWF dag) {wdA wdB : Nat → Nat} {A B : Nat → Bool} + {ev ev' : DictEval} (hev : GEvalOK (Prep.ofDag dag) wdA A ev) + (hev' : GEvalOK (Prep.ofDag dag) wdB B ev') {v : Nat} (hv : v < dag.size) + (hf : (Prep.ofDag dag).family[v]! ≠ .none) + (hag : ∀ w, Desc dag v w → w ≠ v → A w = B w ∧ wdA w = wdB w) : + ev.sides[v]! = ev'.sides[v]! ∧ ev.below[v]! = ev'.below[v]! := by + have hp := prepWF_ofDag hwf + obtain ⟨hsd, hfa⟩ := (hev.2 v hv).2 hf + obtain ⟨hsd', hfa'⟩ := (hev'.2 v hv).2 hf + refine ⟨?_, ?_⟩ + · rw [hsd, hsd'] + apply prefixSides_local + intro i hi + have hlt := hp.sideAt_lt hv hf hi + have hd := desc_sideAt hwf hv hf hi + exact gCost_local hwf _ (by omega) fun w hw => + hag w (hd.trans hw) (by have := Desc.le_of_wf hwf hw (by omega); omega) + · apply FirstAvail.unique _ hfa' + refine FirstAvail.congr (fun k h1 h2 => ?_) hfa + have hlt := hp.spineAt_lt hv hf h1 h2 + exact (hag _ (desc_spineAt hwf hv hf k (by omega)) (by omega)).1 + +theorem cost_agree {dag : Dag} (hwf : DagWF dag) {wdA wdB : Nat → Nat} {A B : Nat → Bool} + {ev ev' : DictEval} (hev : GEvalOK (Prep.ofDag dag) wdA A ev) + (hev' : GEvalOK (Prep.ofDag dag) wdB B ev') {v : Nat} (hv : v < dag.size) + (hag : ∀ w, Desc dag v w → A w = B w ∧ wdA w = wdB w) : + ev.cost[v]! = ev'.cost[v]! := by + rw [hev.cost, hev'.cost] + exact gCost_local hwf v hv hag + + +/-! ## Options and builds depend only on the dictionary at and below the term -/ + +/-- The Share option of `t`, if `t` is in the dictionary. -/ +def optShare (index width : Array (Option Nat)) (t : Nat) : Array (Choice × Nat × ByteArray) := + match index[t]?.getD none with + | some i => #[(.share, (widthOf width t).getD 0, tag4Bytes Ixon.Expr.FLAG_SHARE i)] + | none => #[] + +/-- The options of `t` written inline. -/ +def optRest (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) (t : Nat) : + Array (Choice × Nat × ByteArray) := + let node := p.dag.node t + if p.family[t]! == .none then + #[(.inline, node.children.foldl (fun acc c => acc + ev.cost[c]!) node.head.ownBytes, + Ixon.runPut (Ixon.putTagN 4 node.head.flag node.head.tag4Field))] + else + p.cutOptions ev index width node.head.flag p.spineLen[t]! ev.sides[t]! p.spineLen[t]! + ev.below[t]! #[(.cut p.spineLen[t]!, + tag4Size p.spineLen[t]! + ev.sides[t]! + ev.cost[p.tail[t]!]!, + tag4Bytes node.head.flag p.spineLen[t]!)] + +theorem cutOptions_append (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (flag : UInt8) (l s : Nat) : + ∀ (fuel : Nat) (cur : Option Nat) (a b : Array (Choice × Nat × ByteArray)), + p.cutOptions ev index width flag l s fuel cur (a ++ b) = + a ++ p.cutOptions ev index width flag l s fuel cur b + | 0, _, _, _ => rfl + | _ + 1, none, _, _ => rfl + | fuel + 1, some u, a, b => by + simp only [Prep.cutOptions] + split + · rw [← Array.append_push, cutOptions_append p ev index width flag l s fuel] + · rw [cutOptions_append p ev index width flag l s fuel] + +theorem cutOptions_noShare (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (flag : UInt8) (l s : Nat) : + ∀ (fuel : Nat) (cur : Option Nat) (b : Array (Choice × Nat × ByteArray)), + (∀ o ∈ b.toList, o.1 ≠ .share) → + ∀ o ∈ (p.cutOptions ev index width flag l s fuel cur b).toList, o.1 ≠ .share + | 0, _, _, hb => hb + | _ + 1, none, _, hb => hb + | fuel + 1, some u, b, hb => by + simp only [Prep.cutOptions] + split + · apply cutOptions_noShare p ev index width flag l s fuel + intro o ho + rw [Array.toList_push, List.mem_append] at ho + rcases ho with ho | ho + · exact hb o ho + · simp at ho; rw [ho]; simp + · exact cutOptions_noShare p ev index width flag l s fuel _ _ hb + +theorem options_split (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) (t : Nat) : + p.options ev index width t = optShare index width t ++ optRest p ev index width t := by + unfold Prep.options optShare optRest + by_cases hf : (p.family[t]! == Family.none) = true + · simp only [hf, if_true] + rw [Array.push_eq_append] + rfl + · simp only [hf, if_false, Bool.false_eq_true] + rw [Array.push_eq_append, cutOptions_append] + rfl + +theorem optRest_noShare (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) (t : Nat) : + ∀ o ∈ (optRest p ev index width t).toList, o.1 ≠ .share := by + unfold optRest + split + · intro o ho; simp at ho; rw [ho]; simp + · exact cutOptions_noShare _ _ _ _ _ _ _ _ _ _ (by intro o ho; simp at ho; rw [ho]; simp) + +theorem options_filter (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) (t : Nat) : + (p.options ev index width t).filter (·.1 != .share) = optRest p ev index width t := by + rw [options_split] + apply Array.ext' + rw [Array.toList_filter, Array.toList_append, List.filter_append] + have h1 : (optShare index width t).toList.filter (·.1 != .share) = [] := by + unfold optShare + split + · rfl + · rfl + rw [h1, List.nil_append, List.filter_eq_self] + intro o ho + have := optRest_noShare p ev index width t o ho + cases h : o.1 with + | share => exact absurd h this + | inline => rfl + | cut j => rfl + + +section Congr + +variable {dag : Dag} (hwf : DagWF dag) {wdA wdB : Nat → Nat} {A B : Nat → Bool} + {ev ev' : DictEval} {index index' width width' : Array (Option Nat)} + (hev : GEvalOK (Prep.ofDag dag) wdA A ev) (hev' : GEvalOK (Prep.ofDag dag) wdB B ev') + (hwA : ∀ u, widthOf width u = if A u then some (wdA u) else none) + (hwB : ∀ u, widthOf width' u = if B u then some (wdB u) else none) + (hiA : ∀ u, (index[u]?.getD none).isSome = A u) + (hiB : ∀ u, (index'[u]?.getD none).isSome = B u) + +include hiA hiB hwA hwB in +theorem agree_dict {w : Nat} + (h : index[w]?.getD none = index'[w]?.getD none ∧ wdA w = wdB w) : + A w = B w ∧ wdA w = wdB w ∧ widthOf width w = widthOf width' w := by + have hA : A w = B w := by rw [← hiA, ← hiB, h.1] + exact ⟨hA, h.2, by rw [hwA, hwB, hA, h.2]⟩ + +include hwf hev hev' hwA hwB hiA hiB in +/-- The internal-cut options of a telescope term agree when the dictionaries +agree strictly below it. -/ +theorem cutOptions_congr {t : Nat} (ht : t < dag.size) + (hf : (Prep.ofDag dag).family[t]! ≠ .none) + (hag : ∀ w, Desc dag t w → w ≠ t → + index[w]?.getD none = index'[w]?.getD none ∧ wdA w = wdB w) + (flag : UInt8) (l s : Nat) : + ∀ (fuel j : Nat) (cur : Option Nat) (opts : Array (Choice × Nat × ByteArray)), + 1 ≤ j → FirstAvail (Prep.ofDag dag) A t j cur → + (Prep.ofDag dag).cutOptions ev index width flag l s fuel cur opts = + (Prep.ofDag dag).cutOptions ev' index' width' flag l s fuel cur opts := by + have hp := prepWF_ofDag hwf + obtain ⟨_, hk, _, _, _⟩ := hp.spine t ht hf + intro fuel + induction fuel with + | zero => intro _ _ _ _ _; rfl + | succ fuel ih => + intro j cur opts hj hcur + cases cur with + | none => rfl + | some u => + obtain ⟨k, hjk, hkl, rfl, _, _⟩ := hcur + have hlt := hp.spineAt_lt ht hf (by omega) hkl + have hkn : spineAt (Prep.ofDag dag) t k < dag.size := Nat.lt_trans hlt ht + have hdk := desc_spineAt hwf ht hf k (by omega) + obtain ⟨_, hkf, hlenk, _⟩ := hk k hkl + have hfk : (Prep.ofDag dag).family[spineAt (Prep.ofDag dag) t k]! ≠ .none := by + rw [hkf]; exact hf + obtain ⟨hi, hw, hwid⟩ := agree_dict hwA hwB hiA hiB (hag _ hdk (by omega)) + obtain ⟨hs, hb⟩ := rows_agree_strict hwf hev hev' hkn hfk fun w hw hne => + agree_dict hwA hwB hiA hiB (hag w (hdk.trans hw) + (by have := Desc.le_of_wf hwf hw hkn; omega)) |>.elim fun a b => ⟨a, b.1⟩ + simp only [Prep.cutOptions] + rw [hs, hb, hwid] + have hidx : (index[spineAt (Prep.ofDag dag) t k]?.getD none).isSome = + (index'[spineAt (Prep.ofDag dag) t k]?.getD none).isSome := by + rw [(hag _ hdk (by omega)).1] + have hnext : FirstAvail (Prep.ofDag dag) A t (k + 1) + ev'.below[spineAt (Prep.ofDag dag) t k]! := by + rw [← hb] + exact FirstAvail.shift hlenk ((hev.2 _ hkn).2 hfk).2 + rw [hidx] + split + · exact ih (k + 1) _ _ (by omega) hnext + · exact ih (k + 1) _ _ (by omega) hnext + +theorem desc_of_child {dag : Dag} {t c : Nat} (hc : c ∈ (dag.node t).children) : Desc dag t c := by + obtain ⟨k, hk, rfl⟩ := Array.mem_iff_getElem.mp hc + exact .child k hk (by rw [child_eq_getElem _ k hk]; exact .refl _) + +include hwf hev hev' hwA hwB hiA hiB in +/-- The inline options of `t` agree when the dictionaries agree strictly +below it. -/ +theorem optRest_congr {t : Nat} (ht : t < dag.size) + (hag : ∀ w, Desc dag t w → w ≠ t → + index[w]?.getD none = index'[w]?.getD none ∧ wdA w = wdB w) : + optRest (Prep.ofDag dag) ev index width t = optRest (Prep.ofDag dag) ev' index' width' t := by + have hp := prepWF_ofDag hwf + have hagB : ∀ w, Desc dag t w → w ≠ t → A w = B w ∧ wdA w = wdB w := fun w hw hne => + (agree_dict hwA hwB hiA hiB (hag w hw hne)).elim fun a b => ⟨a, b.1⟩ + have hcostBelow : ∀ c, Desc dag t c → c < t → ev.cost[c]! = ev'.cost[c]! := by + intro c hc hlt + exact cost_agree hwf hev hev' (by omega) fun w hw => + hagB w (hc.trans hw) (by have := Desc.le_of_wf hwf hw (by omega); omega) + unfold optRest + by_cases hf : ((Prep.ofDag dag).family[t]! == .none) = true + · simp only [hf, if_true, ofDag_dag] + rw [foldl_add_congr _ _ fun c hc => hcostBelow c (desc_of_child hc) (hwf.child_lt ht hc)] + · simp only [hf, if_false, Bool.false_eq_true] + have hf' : (Prep.ofDag dag).family[t]! ≠ .none := by simpa using hf + obtain ⟨_, _, hend, htl, _⟩ := hp.spine t ht hf' + obtain ⟨hs, hb⟩ := rows_agree_strict hwf hev hev' ht hf' hagB + have htail : ev.cost[(Prep.ofDag dag).tail[t]!]! = ev'.cost[(Prep.ofDag dag).tail[t]!]! := + hcostBelow _ (by rw [← hend]; exact desc_spineAt hwf ht hf' _ (Nat.le_refl _)) htl + rw [hs, hb, htail] + apply cutOptions_congr hwf hev hev' hwA hwB hiA hiB ht hf' hag _ _ _ _ 1 _ _ (Nat.le_refl _) + rw [← hb] + exact ((hev.2 t ht).2 hf').2 + +include hwf hev hev' hwA hwB hiA hiB in +theorem options_congr {t : Nat} (ht : t < dag.size) + (hag : ∀ w, Desc dag t w → index[w]?.getD none = index'[w]?.getD none ∧ wdA w = wdB w) : + (Prep.ofDag dag).options ev index width t = (Prep.ofDag dag).options ev' index' width' t := by + rw [options_split, options_split, + optRest_congr hwf hev hev' hwA hwB hiA hiB ht fun w hw _ => hag w hw] + obtain ⟨_, _, hwid⟩ := agree_dict hwA hwB hiA hiB (hag t (.refl _)) + unfold optShare + rw [(hag t (.refl _)).1, hwid] + +theorem foldrM_congr_mem {β : Type} {l : List Node} {f g : Node → β → Except SharingError β} + (h : ∀ n ∈ l, ∀ b, f n b = g n b) (init : β) : l.foldrM f init = l.foldrM g init := by + induction l with + | nil => rfl + | cons a l ih => + simp only [List.foldrM_cons] + rw [ih (fun n hn b => h n (List.mem_cons_of_mem _ hn) b)] + congr 1 + funext b + exact h a List.mem_cons_self b + +include hwf hev hev' hwA hwB hiA hiB in +/-- **Build locality.** `build` at `t` depends only on the dictionary at and +below `t`: two evaluations with the model rows of dictionaries that agree +there build the same expression. -/ +theorem build_congr : + ∀ (fuel : Nat) (entry : Bool) (t : Nat), t < dag.size → + (∀ w, Desc dag t w → index[w]?.getD none = index'[w]?.getD none ∧ wdA w = wdB w) → + (Prep.ofDag dag).build ev index width entry fuel t = + (Prep.ofDag dag).build ev' index' width' entry fuel t := by + have hp := prepWF_ofDag hwf + intro fuel + induction fuel with + | zero => intro _ _ _ _; rfl + | succ fuel ih => + intro entry t ht hag + have hopt := options_congr hwf hev hev' hwA hwB hiA hiB ht hag + have hcost := cost_agree hwf hev hev' ht fun w hw => + (agree_dict hwA hwB hiA hiB (hag w hw)).elim fun a b => ⟨a, b.1⟩ + have hsub : ∀ c, Desc dag t c → c < dag.size → + (Prep.ofDag dag).build ev index width false fuel c = + (Prep.ofDag dag).build ev' index' width' false fuel c := + fun c hc hcn => ih false c hcn fun w hw => hag w (hc.trans hw) + simp only [Prep.build, hopt, hcost] + generalize hpk : pickOption (if entry = true then + Array.filter (fun x => x.fst != Choice.share) ((Prep.ofDag dag).options ev' index' width' t) + else (Prep.ofDag dag).options ev' index' width' t) = pk + rcases pk with _ | ⟨choice, c⟩ + · rfl + · obtain ⟨b, hb⟩ := pickOption_mem _ hpk + have hmem : (choice, c, b) ∈ ((Prep.ofDag dag).options ev' index' width' t).toList := by + split at hb + · rw [Array.toList_filter] at hb; exact (List.mem_filter.mp hb).1 + · exact hb + have hopt' := hp.gOptions_mem ev' hev' index' width' hwB hiB ht hmem + simp only [ofDag_dag] + by_cases hchk : (entry || c == ev'.cost[t]!) = true + · simp only [hchk, if_true] + cases choice with + | share => rw [(hag t (.refl _)).1] + | inline => + have har := hwf.children_size ht + have hchild : ∀ k, k < (dag.node t).head.arity → + Desc dag t ((dag.node t).child k) ∧ (dag.node t).child k < dag.size := by + intro k hk + have hk' : k < (dag.node t).children.size := by rw [har]; exact hk + refine ⟨.child k hk' (.refl _), ?_⟩ + have := hwf.childAt_lt ht hk + omega + cases hh : (dag.node t).head + case prj ti f => + have h0 := hchild 0 (by simp [hh, Head.arity]) + simp only + rw [hsub _ h0.1 h0.2] + case letE lc => + have h0 := hchild 0 (by simp [hh, Head.arity]) + have h1 := hchild 1 (by simp [hh, Head.arity]) + have h2 := hchild 2 (by simp [hh, Head.arity]) + simp only + rw [hsub _ h0.1 h0.2, hsub _ h1.1 h1.2, hsub _ h2.1 h2.2] + all_goals rfl + | cut j => + obtain ⟨h1, _⟩ | ⟨h1, _⟩ | ⟨j', hj', hf, hj1, hjl, _⟩ := hopt' + · cases h1 + · cases h1 + cases hj' + dsimp only + rw [spineWalk_eq] + simp only + have hside : ∀ n ∈ (List.range j).map (fun k => (Prep.ofDag dag).dag.node + (spineAt (Prep.ofDag dag) t k)), ∀ acc, + (do let side ← (Prep.ofDag dag).build ev index width false fuel n.sideChild + rebuildSpineNode n acc side : Except SharingError Ixon.Expr) = + (do let side ← (Prep.ofDag dag).build ev' index' width' false fuel n.sideChild + rebuildSpineNode n acc side) := by + intro n hn acc + obtain ⟨k, hk', rfl⟩ := List.mem_map.mp hn + rw [List.mem_range] at hk' + have hd := desc_sideAt hwf ht hf (k := k) (by omega) + have hlt := hp.sideAt_lt ht hf (k := k) (by omega) + unfold sideAt at hd hlt + rw [hsub _ hd (by omega)] + split + · rfl + · split + · rename_i hjlt + have hdj := desc_spineAt hwf ht hf j (by omega) + rw [(hag _ hdj).1] + split + · simp only [pure_bind] + exact foldrM_congr_mem hside _ + · rfl + · rename_i hjlt + have hdj := desc_spineAt hwf ht hf j (by omega) + have hjn : spineAt (Prep.ofDag dag) t j < dag.size := by + have := Desc.le_of_wf hwf hdj ht; omega + rw [hsub _ hdj hjn] + cases (Prep.ofDag dag).build ev' index' width' false fuel + (spineAt (Prep.ofDag dag) t j) with + | error e => rfl + | ok tl => exact foldrM_congr_mem hside _ + · simp only [hchk, Bool.false_eq_true, if_false] + rfl + +end Congr + +/-! ## The work of an evaluation step -/ + +/-- The available terms of `t`'s spine at positions `j, …, spineLen t - 1`. -/ +def spineAvailCount (p : Prep) (avail : Nat → Bool) (t j : Nat) : Nat := + ((List.range' j (p.spineLen[t]! - j)).filter fun k => avail (spineAt p t k)).length + +theorem spineAvailCount_nil (p : Prep) (avail : Nat → Bool) (t j : Nat) + (hnone : ∀ k, j ≤ k → k < p.spineLen[t]! → avail (spineAt p t k) = false) : + spineAvailCount p avail t j = 0 := by + unfold spineAvailCount + rw [List.length_eq_zero_iff, List.filter_eq_nil_iff] + intro a ha + rw [List.mem_range'_1] at ha + rw [hnone a ha.1 (by omega)] + simp + +theorem spineAvailCount_split (p : Prep) (avail : Nat → Bool) (t j k : Nat) + (hjk : j ≤ k) (hk : k < p.spineLen[t]!) (hav : avail (spineAt p t k) = true) + (hnone : ∀ k', j ≤ k' → k' < k → avail (spineAt p t k') = false) : + spineAvailCount p avail t j = spineAvailCount p avail t (k + 1) + 1 := by + unfold spineAvailCount + rw [show p.spineLen[t]! - j = (k - j) + (1 + (p.spineLen[t]! - (k + 1))) by omega, + ← List.range'_append_1, ← List.range'_append_1, List.filter_append, List.filter_append] + have hpre : (List.range' j (k - j)).filter (fun k => avail (spineAt p t k)) = [] := by + rw [List.filter_eq_nil_iff] + intro a ha + rw [List.mem_range'_1] at ha + rw [hnone a ha.1 (by omega)] + simp + rw [hpre, show j + (k - j) = k by omega] + simp [hav] + +theorem PrepWF.gCutScan_work {p : Prep} (hp : PrepWF p) {avail : Nat → Bool} + (sides : Array Nat) (below : Array (Option Nat)) (width : Array (Option Nat)) + {t : Nat} (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) (l s : Nat) + (hbelow : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + FirstAvail p avail (spineAt p t k) 1 below[spineAt p t k]!) : + ∀ (fuel j : Nat) (cur : Option Nat) (best work : Nat), 1 ≤ j → j ≤ p.spineLen[t]! → + p.spineLen[t]! - j ≤ fuel → FirstAvail p avail t j cur → + (cutScan p.spineLen sides below width l s fuel cur best work).2 = + work + spineAvailCount p avail t j := by + obtain ⟨_, hk, _, _, _⟩ := hp.spine t ht hf + intro fuel + induction fuel with + | zero => + intro j cur best work _ hj hfuel _ + have : spineAvailCount p avail t j = 0 := by + unfold spineAvailCount + rw [show p.spineLen[t]! - j = 0 by omega] + rfl + rw [this] + rfl + | succ fuel ih => + intro j cur best work hj1 hj hfuel hcur + cases cur with + | none => + rw [spineAvailCount_nil p avail t j hcur] + rfl + | some u => + obtain ⟨k, hjk, hkl, rfl, hav, hnone⟩ := hcur + obtain ⟨_, _, hlenk, _⟩ := hk k hkl + simp only [cutScan] + rw [spineAvailCount_split p avail t j k hjk hkl hav hnone, + ih (k + 1) _ _ _ (by omega) (by omega) (by omega) + (FirstAvail.shift hlenk (hbelow k (by omega) hkl))] + omega + +/-- The work `evalStep` counts at an affected term whose descendants already +have their model rows: 1, plus for a telescope term one per available term +strictly below it on its spine. -/ +theorem PrepWF.gEvalStep_work {p : Prep} (hp : PrepWF p) {wd : Nat → Nat} {avail : Nat → Bool} + (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some (wd u) else none) + (affected : Array Bool) (st : DictEval) (m : Nat) (hm : m < p.dag.size) + (haff : affected[m]! = true) + (hsz : st.cost.size = p.dag.size ∧ st.sides.size = p.dag.size ∧ + st.below.size = p.dag.size) + (hrows : ∀ t, t < m → GEvalRow p wd avail st t) : + (evalStep p.dag p.family p.spineLen p.tail width affected st m).work = + st.work + 1 + (if p.family[m]! = .none then 0 else spineAvailCount p avail m 1) := by + obtain ⟨_, _, hbs⟩ := hsz + have keepO : ∀ (v : Option Nat) (arr : Array (Option Nat)) (i : Nat), i ≠ m → + (arr.set! m v)[i]! = arr[i]! := by + intro v arr i hi + rw [setBang_getElem!, if_neg (by intro h; exact hi h.1.symm)] + by_cases hf : p.family[m]! = .none + · simp only [evalStep, haff, if_true, hf, beq_self_eq_true] + · obtain ⟨hl1, hk, _, _, _⟩ := hp.spine m hm hf + have hlt := hp.snext_lt hm hf + have hB : FirstAvail p avail m 1 + (if p.family[snext p m]! = p.family[m]! then + (if (widthOf width (snext p m)).isSome then some (snext p m) + else st.below[snext p m]!) else none) := by + rcases hp.spine_step hm hf with ⟨hs, hl, _⟩ | ⟨hs, hl, _⟩ + · rw [if_pos hs, hwidth] + have hn1 := (hp.spine (snext p m) (by omega) (by rw [hs]; exact hf)).1 + by_cases hav : avail (snext p m) = true + · rw [if_pos hav] + exact ⟨1, Nat.le_refl _, by omega, rfl, hav, fun k' h1 h2 => by omega⟩ + · rw [if_neg hav] + simp only [Option.isSome_none, Bool.false_eq_true, if_false] + have hrow := ((hrows _ hlt).2 (by rw [hs]; exact hf)).2 + have hlen1 : p.spineLen[spineAt p m 1]! = p.spineLen[m]! - 1 := by + simp only [spineAt]; omega + exact FirstAvail.unshift (by omega) (by simpa [spineAt] using hav) + (FirstAvail.shift hlen1 hrow) + · rw [if_neg hs] + intro k h1 h2 + omega + generalize hBdef : (if p.family[snext p m]! = p.family[m]! then + (if (widthOf width (snext p m)).isSome then some (snext p m) + else st.below[snext p m]!) else none) = B at hB + have hbelow : ∀ k, 1 ≤ k → k < p.spineLen[m]! → + FirstAvail p avail (spineAt p m k) 1 (st.below.set! m B)[spineAt p m k]! := by + intro k h1 h2 + have hlt' := hp.spineAt_lt hm hf h1 h2 + obtain ⟨_, hkf, _, _⟩ := hk k h2 + rw [keepO _ _ _ (by omega)] + exact ((hrows _ hlt').2 (by rw [hkf]; exact hf)).2 + have hwork := fun best => hp.gCutScan_work (st.sides.set! m + ((p.dag.node m).sideExtra + st.cost[(p.dag.node m).sideChild]! + + (if p.family[snext p m]! = p.family[m]! then st.sides[snext p m]! else 0))) + (st.below.set! m B) width hm hf p.spineLen[m]! + ((p.dag.node m).sideExtra + st.cost[(p.dag.node m).sideChild]! + + (if p.family[snext p m]! = p.family[m]! then st.sides[snext p m]! else 0)) + hbelow p.spineLen[m]! 1 B best st.work (Nat.le_refl _) (by omega) (by omega) hB + simp only [evalStep, haff, if_true] + have hfb : (p.family[m]! == Family.none) = false := by simpa using hf + simp only [hfb, Bool.false_eq_true, if_false] + simp only [ite_beq_family] + rw [show (p.dag.node m).spineNext = snext p m from rfl, hBdef, if_neg hf] + rw [hwork] + omega + +/-- The work an evaluation counts at `u` (`gEvalStep_work`). -/ +def nodeWork (p : Prep) (avail : Nat → Bool) (u : Nat) : Nat := + 1 + (if p.family[u]! = .none then 0 else spineAvailCount p avail u 1) + +/-- **Re-evaluation work.** The work `Prep.evalUp` counts is `nodeWork` under +the new dictionary summed over `t` and the terms above it. -/ +theorem evalUp_work {dag : Dag} (hwf : DagWF dag) {wd wd' : Nat → Nat} {A A' : Nat → Bool} + {ev : DictEval} (hev : GEvalOK (Prep.ofDag dag) wd A ev) {t : Nat} (ht : t < dag.size) + (hdiff : ∀ v, v ≠ t → A' v = A v ∧ wd' v = wd v) (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if A' u then some (wd' u) else none) : + ((Prep.ofDag dag).evalUp ev width t).work = + (((List.range' t (dag.size - t)).filter fun u => (ancestorMarks dag t)[u]!).map + (nodeWork (Prep.ofDag dag) A')).sum := by + have hp := prepWF_ofDag hwf + have hag : ∀ u, u < dag.size → ¬ Desc dag u t → ∀ v, Desc dag u v → A v = A' v ∧ wd v = wd' v := by + intro u hu hnd v hv + have hvt : v ≠ t := fun h => hnd (h ▸ hv) + exact ⟨(hdiff v hvt).1.symm, (hdiff v hvt).2.symm⟩ + let marks := ancestorMarks dag t + let step := evalStep (Prep.ofDag dag).dag (Prep.ofDag dag).family (Prep.ofDag dag).spineLen (Prep.ofDag dag).tail width marks + have hinv : ∀ m, m ≤ dag.size - t → + let st := (List.range' t m).foldl step { ev with work := 0 } + (st.cost.size = dag.size ∧ st.sides.size = dag.size ∧ st.below.size = dag.size) ∧ + (∀ u, u < t + m → GEvalRow (Prep.ofDag dag) wd' A' st u) ∧ + (∀ u, t + m ≤ u → st.cost[u]! = ev.cost[u]! ∧ st.sides[u]! = ev.sides[u]! ∧ + st.below[u]! = ev.below[u]!) ∧ + st.work = (((List.range' t m).filter fun u => marks[u]!).map (nodeWork (Prep.ofDag dag) A')).sum := by + intro m + induction m with + | zero => + intro _ + refine ⟨hev.1, fun u hu => ?_, fun u _ => ⟨rfl, rfl, rfl⟩, rfl⟩ + have hud : u < dag.size := by omega + exact gEvalRow_local hwf hud (hag u hud fun hd => by + have := Desc.le_of_wf hwf hd hud; omega) (hev.2 u hud) + | succ m ih => + intro hm + obtain ⟨hs, hrows, hrest, hwork⟩ := ih (by omega) + simp only at hs hrows hrest hwork ⊢ + rw [List.range'_1_concat, List.foldl_append, List.foldl_cons, List.foldl_nil, + List.filter_append, List.map_append, List.sum_append] + generalize hst : (List.range' t m).foldl step { ev with work := 0 } = st + at hs hrows hrest hwork + have hkeep : ∀ u, u ≠ t + m → (step st (t + m)).cost[u]! = st.cost[u]! ∧ + (step st (t + m)).sides[u]! = st.sides[u]! ∧ + (step st (t + m)).below[u]! = st.below[u]! := + fun u hu => evalStep_keep _ _ _ _ width marks st hu + have htm : t + m < dag.size := by omega + by_cases hmark : marks[t + m]! = true + · obtain ⟨hs', hrows'⟩ := hp.gEvalStep_spec width hwidth marks st (t + m) htm hmark hs + hrows + have hw' := hp.gEvalStep_work width hwidth marks st (t + m) htm hmark hs hrows + refine ⟨hs', fun u hu => hrows' u (by omega), fun u hu => ?_, ?_⟩ + · obtain ⟨k1, k2, k3⟩ := hkeep u (by omega) + obtain ⟨r1, r2, r3⟩ := hrest u (by omega) + exact ⟨k1.trans r1, k2.trans r2, k3.trans r3⟩ + · rw [hw', hwork] + simp only [List.filter_cons, List.filter_nil, hmark, if_true, List.map_cons, + List.map_nil, List.sum_cons, List.sum_nil] + unfold nodeWork + omega + · have hid : step st (t + m) = st := by + simp only [step, evalStep] + rw [if_neg hmark] + rw [hid] + refine ⟨hs, fun u hu => ?_, fun u hu => hrest u (by omega), ?_⟩ + · by_cases hum : u < t + m + · exact hrows u hum + · have hu' : u = t + m := by omega + subst hu' + have hnd : ¬ Desc dag (t + m) t := fun hd => + hmark ((ancestorMarks_iff hwf ht (t + m) htm).mpr hd) + obtain ⟨r1, r2, r3⟩ := hrest (t + m) (Nat.le_refl _) + refine gEvalRow_local hwf htm (hag _ htm hnd) ?_ + exact gEvalRow_of_agree r1 r2 r3 (hev.2 _ htm) + · rw [hwork] + simp [hmark] + obtain ⟨_, _, _, hw⟩ := hinv (dag.size - t) (Nat.le_refl _) + unfold Prep.evalUp + rw [foldRange_eq] + exact hw + +/-- **Empty-dictionary work.** Evaluating the empty dictionary counts one +per term: no term has an available term on its spine. -/ +theorem evalAll_none_work {dag : Dag} (hwf : DagWF dag) : + ((Prep.ofDag dag).evalAll (Array.replicate dag.size none)).work = dag.size := by + have hp := prepWF_ofDag hwf + have hwidth : ∀ u, widthOf (Array.replicate dag.size none) u = + if (fun _ => false) u then some ((fun _ => 0) u) else none := by + intro u + simp only [widthOf, Array.getElem?_replicate, Bool.false_eq_true, if_false] + split <;> rfl + let step := evalStep (Prep.ofDag dag).dag (Prep.ofDag dag).family (Prep.ofDag dag).spineLen + (Prep.ofDag dag).tail (Array.replicate dag.size none) (Array.replicate dag.size true) + have hinv : ∀ m, m ≤ dag.size → + let st := (List.range m).foldl step { (Prep.ofDag dag).empty with work := 0 } + (st.cost.size = dag.size ∧ st.sides.size = dag.size ∧ st.below.size = dag.size) ∧ + (∀ t, t < m → GEvalRow (Prep.ofDag dag) (fun _ => 0) (fun _ => false) st t) ∧ + st.work = m := by + intro m + induction m with + | zero => intro _; exact ⟨ofDag_empty_size dag, fun t h => absurd h (Nat.not_lt_zero _), rfl⟩ + | succ m ih => + intro hm + obtain ⟨hs, hrows, hw⟩ := ih (by omega) + simp only at hs hrows hw ⊢ + rw [foldl_range_succ] + have haff : (Array.replicate dag.size true)[m]! = true := by simp [show m < dag.size by omega] + obtain ⟨hs', hrows'⟩ := hp.gEvalStep_spec _ hwidth _ _ m (by simp [ofDag_dag]; omega) haff hs + hrows + refine ⟨hs', hrows', ?_⟩ + rw [hp.gEvalStep_work _ hwidth _ _ m (by simp [ofDag_dag]; omega) haff hs hrows, hw, + spineAvailCount_nil _ _ _ _ fun _ _ _ => rfl] + split <;> rfl + unfold Prep.evalAll Prep.eval evalFrom + rw [foldRange_zero] + exact (hinv dag.size (Nat.le_refl _)).2.2 + + +end OnePass + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/TieredPhase3.lean b/Ix/Compile/Verify/TieredPhase3.lean new file mode 100644 index 000000000..bac5d4983 --- /dev/null +++ b/Ix/Compile/Verify/TieredPhase3.lean @@ -0,0 +1,1653 @@ +import Ix.Compile.Verify.TieredModel +import Ix.Compile.Verify.TieredTier + +/-! +# Tiered construction, phase 3: re-materialization + +`materializeTable` writes table entry `k` against the dictionary of the +entries before it and the roots against the whole table, every Share priced +by the layout width of its index. Each part it writes is a minimum for its +dictionary at those widths: its layout length is `gCost` of the part's term +under that dictionary (`materializeTable_spec`), which is the minimum length +over all writings of the term with that dictionary, and is attained +(`materializeTable_min`). The predicted length is the layout length of the +output. + +For the tiered construction (`rematerialize_spec`): the parts are minimal +as above, the output expands to the same terms (entry `k` to `order[k]`, +the roots to the input roots), entry `k` only references entries below `k`, +and the layout length is at most the phase-1 candidate's layout length. +Each part is exact for its dictionary; the composition of the phases is NOT +claimed to be a global byte minimum. +-/ + +namespace Ix.Compile.Verify.Tiered + +open Ix.Sharing.Exact +open Ix.Compile.Verify.UniformModel +open Ix.Compile.Verify.SharingExact (bind_eq_ok indexOfPrefix_succ indexOfPrefix_zero + foldlM_range_inv materializeStep_spec materializeTable_parts toNat_toUInt64_of_lt + indexOfPrefix_spec mapM_ok_forall₂ forall₂_getElem) + +/-! ## The prefix dictionaries -/ + +/-- The terms of the first `k` table entries. -/ +def prefixAvail (n : Nat) (table : Array Nat) (k u : Nat) : Bool := + ((indexOfPrefix n table k)[u]?.getD none).isSome + +/-- Their Share widths: the layout width of the entry's index. -/ +def prefixWd (n : Nat) (table : Array Nat) (widthAt : Nat → Nat) (k u : Nat) : Nat := + match (indexOfPrefix n table k)[u]?.getD none with + | some i => widthAt i + | none => 0 + +theorem prefix_width (n : Nat) (table : Array Nat) (widthAt : Nat → Nat) (k u : Nat) : + widthOf ((indexOfPrefix n table k).map (·.map widthAt)) u = + if prefixAvail n table k u then some (prefixWd n table widthAt k u) else none := by + rw [widthOf_eq] + unfold prefixAvail prefixWd + simp only [getElem!_def, Array.getElem?_map] + cases h : (indexOfPrefix n table k)[u]? with + | none => rfl + | some o => cases o <;> simp + +theorem prefix_succ_agree (n : Nat) (table : Array Nat) (widthAt : Nat → Nat) {k : Nat} + (hk : k < table.size) (v : Nat) (hv : v ≠ table[k]!) : + prefixAvail n table (k + 1) v = prefixAvail n table k v ∧ + prefixWd n table widthAt (k + 1) v = prefixWd n table widthAt k v := by + unfold prefixAvail prefixWd + rw [indexOfPrefix_succ n table hk] + simp [Array.set!, Ne.symm hv] + +/-- The index bound of a prefix dictionary. -/ +theorem prefix_index_lt {n : Nat} {table : Array Nat} {k u i : Nat} + (h : (indexOfPrefix n table k)[u]?.getD none = some i) : i < k := + (indexOfPrefix_spec n table k u i h).1 + +/-! ## The table loop -/ + +/-- The table loop after `k` entries: the dictionary is the prefix +dictionary of the first `k` entries, the evaluation gives its model rows, +every entry so far has the layout length of its model cost under its own +prefix dictionary, and the predicted length is the count plus those. -/ +def TableEvInv (dag : Dag) (table : Array Nat) (widthAt : Nat → Nat) (k : Nat) + (st : TableState) : Prop := + k ≤ table.size ∧ st.index = indexOfPrefix dag.size table k ∧ + st.width = (indexOfPrefix dag.size table k).map (·.map widthAt) ∧ + GEvalOK (Prep.ofDag dag) (prefixWd dag.size table widthAt k) (prefixAvail dag.size table k) + st.ev ∧ + st.entries.size = k ∧ + (∀ j (hj : j < st.entries.size), (sizeInfoWith widthAt st.entries[j]).full = + gCost (Prep.ofDag dag) (prefixWd dag.size table widthAt j) (prefixAvail dag.size table j) + table[j]!) ∧ + st.predicted = tag0Size table.size + + ((List.range k).map fun j => gCost (Prep.ofDag dag) (prefixWd dag.size table widthAt j) + (prefixAvail dag.size table j) table[j]!).sum + +/-- The layout length of an expression built against a prefix dictionary is +the model cost there. -/ +theorem build_prefix_size {dag : Dag} (hwf : DagWF dag) {table : Array Nat} + (hsize : table.size < UInt64.size) (widthAt : Nat → Nat) {k : Nat} (hk : k ≤ table.size) + {ev : DictEval} + (hev : GEvalOK (Prep.ofDag dag) (prefixWd dag.size table widthAt k) + (prefixAvail dag.size table k) ev) + {t : Nat} (ht : t < dag.size) {e : Ixon.Expr} + (h : (Prep.ofDag dag).build ev (indexOfPrefix dag.size table k) + ((indexOfPrefix dag.size table k).map (·.map widthAt)) false (dag.size + 1) t = .ok e) : + (sizeInfoWith widthAt e).full = + gCost (Prep.ofDag dag) (prefixWd dag.size table widthAt k) (prefixAvail dag.size table k) t := by + have hp := prepWF_ofDag hwf + have := (hp.gBuild_size ev hev (indexOfPrefix dag.size table k) + ((indexOfPrefix dag.size table k).map (·.map widthAt)) + (prefix_width dag.size table widthAt k) (fun u => rfl) widthAt (fun u i hi => ⟨by + have := prefix_index_lt hi; omega, by unfold prefixWd; rw [hi]⟩) + (dag.size + 1) false t e ht h).1 + simpa using this + +theorem tableEvInv_step {dag : Dag} (hwf : DagWF dag) {table : Array Nat} {limits : Limits} + {widthAt : Nat → Nat} (hsize : table.size < UInt64.size) + (hrange : ∀ k, k < table.size → table[k]! < dag.size) {i : Nat} {st st' : TableState} + (hI : TableEvInv dag table widthAt i st) (hi : i < table.size) + (h : materializeStep (Prep.ofDag dag) table limits widthAt st i = .ok st') : + TableEvInv dag table widthAt (i + 1) st' := by + obtain ⟨_, hidx, hwid, hev, hsz, hent, hpred⟩ := hI + obtain ⟨e, he, hent', hidx', hwid', hev', hpred', -⟩ := materializeStep_spec h + have hsucc := indexOfPrefix_succ dag.size table hi + have ht := hrange i hi + have hwidth' : st.width.set! table[i]! (some (widthAt i)) = + (indexOfPrefix dag.size table (i + 1)).map (·.map widthAt) := by + rw [hwid, hsucc] + simp [Array.set!, Array.map_setIfInBounds] + have hsize_e : (sizeInfoWith widthAt e).full = gCost (Prep.ofDag dag) + (prefixWd dag.size table widthAt i) (prefixAvail dag.size table i) table[i]! := by + rw [hidx, hwid] at he + exact build_prefix_size hwf hsize widthAt (by omega) hev ht he + refine ⟨by omega, by rw [hidx', hidx, hsucc], by rw [hwid', hwidth'], ?_, ?_, ?_, ?_⟩ + · rw [hev', hwidth'] + exact evalUp_ok hwf hev ht (fun v hv => prefix_succ_agree dag.size table widthAt hi v hv) _ + (prefix_width dag.size table widthAt (i + 1)) + · rw [hent']; simp [hsz] + · intro j hj + have hj2 : j < (st.entries.push e).size := hent' ▸ hj + have heq : st'.entries[j] = (st.entries.push e)[j] := by simp only [hent'] + rw [heq] + by_cases hji : j < st.entries.size + · rw [Array.getElem_push_lt hji] + exact hent j hji + · have : j = st.entries.size := by simp at hj2; omega + simp only [this, Array.getElem_push_eq] + rw [hsz] + exact hsize_e + · rw [hpred', hpred, List.range_succ, List.map_append, List.sum_append, hev.cost] + simp only [List.map_cons, List.map_nil, List.sum_cons, List.sum_nil] + omega + +theorem tableEvInv_loop {dag : Dag} (hwf : DagWF dag) {table : Array Nat} {limits : Limits} + {widthAt : Nat → Nat} (hsize : table.size < UInt64.size) + (hrange : ∀ k, k < table.size → table[k]! < dag.size) {st : TableState} + (h : (List.range table.size).foldlM (materializeStep (Prep.ofDag dag) table limits widthAt) + { entries := #[], index := Array.replicate (Prep.ofDag dag).dag.size none, + width := Array.replicate (Prep.ofDag dag).dag.size none, + ev := (Prep.ofDag dag).evalAll (Array.replicate (Prep.ofDag dag).dag.size none), + predicted := tag0Size table.size, work := 0 } = .ok st) : + TableEvInv dag table widthAt table.size st := by + have hp := prepWF_ofDag hwf + refine foldlM_range_inv _ (fun k st => k ≤ table.size → TableEvInv dag table widthAt k st) + (fun i s s' hI hs hle => tableEvInv_step hwf hsize hrange (hI (by omega)) (by omega) hs) + table.size _ st (fun _ => ?_) h (Nat.le_refl _) + have hidx0 := indexOfPrefix_zero dag.size table + refine ⟨Nat.zero_le _, by rw [hidx0]; rfl, by rw [hidx0]; simp; rfl, ?_, rfl, + fun j hj => absurd hj (by simp), by simp⟩ + refine hp.evalAll_ok (ofDag_empty_size dag) _ fun u => ?_ + rw [widthOf_eq] + unfold prefixAvail + rw [hidx0] + simp only [ofDag_dag] + by_cases hu : u < dag.size + · simp [hu] + · simp [hu]; rfl + +theorem forall₂_imp_mem {α β : Type} {R S : α → β → Prop} : + ∀ {xs : List α} {ys : List β}, List.Forall₂ R xs ys → + (∀ a ∈ xs, ∀ b, R a b → S a b) → List.Forall₂ S xs ys + | _, _, .nil, _ => .nil + | _, _, .cons hr hs, h => .cons (h _ List.mem_cons_self _ hr) + (forall₂_imp_mem hs fun a ha b hab => h a (List.mem_cons_of_mem _ ha) b hab) + +theorem sum_range_eq {α : Type} (g : α → Nat) (arr : Array α) {f : Nat → Nat} + (h : ∀ j (hj : j < arr.size), f j = g arr[j]) : + ((List.range arr.size).map f).sum = (arr.toList.map g).sum := by + congr 1 + apply List.ext_getElem (by simp) + intro j h1 h2 + simp only [List.getElem_map, List.getElem_range, Array.getElem_toList] + exact h j (by simpa using h1) + +/-! ## The materialized table -/ + +/-- **Re-materialization lengths.** A successful `materializeTable` over a +canonical DAG writes every entry `k` with the layout length `gCost` of +`table[k]` under the dictionary of the entries before it (Shares priced +`widthAt (index)`), every root with `gCost` under the whole table, and +predicts exactly the layout length of its output. -/ +theorem materializeTable_spec {dag : Dag} (hwf : DagWF dag) {table roots : Array Nat} + {limits : Limits} {widthAt : Nat → Nat} {entries rs : Array Ixon.Expr} {predicted work : Nat} + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (h : materializeTable (Prep.ofDag dag) table roots limits widthAt = + .ok (entries, rs, predicted, work)) : + entries.size = table.size ∧ + (∀ k (hk : k < entries.size), (sizeInfoWith widthAt entries[k]).full = + gCost (Prep.ofDag dag) (prefixWd dag.size table widthAt k) + (prefixAvail dag.size table k) table[k]!) ∧ + List.Forall₂ (fun r e => (sizeInfoWith widthAt e).full = + gCost (Prep.ofDag dag) (prefixWd dag.size table widthAt table.size) + (prefixAvail dag.size table table.size) r) roots.toList rs.toList ∧ + predicted = tag0Size entries.size + + (entries.toList.map fun e => (sizeInfoWith widthAt e).full).sum + + (rs.toList.map fun e => (sizeInfoWith widthAt e).full).sum := by + have hp := prepWF_ofDag hwf + obtain ⟨hsize, hrange, st, hst, rfl, hrs, hpred⟩ := materializeTable_parts _ _ _ _ _ h + obtain ⟨_, hidx, hwid, hev, hsz, hent, hstpred⟩ := tableEvInv_loop hwf hsize hrange hst + -- the roots + rw [Array.mapM_eq_mapM_toList] at hrs + cases hm : List.mapM (fun r => (Prep.ofDag dag).build st.ev st.index st.width false + ((Prep.ofDag dag).dag.size + 1) r) roots.toList with + | error err => rw [hm] at hrs; cases hrs + | ok l => + rw [hm] at hrs + have hl : rs = l.toArray := by cases hrs; rfl + subst hl + have hfor := mapM_ok_forall₂ _ _ _ hm + have hroots' : List.Forall₂ (fun r e => (sizeInfoWith widthAt e).full = + gCost (Prep.ofDag dag) (prefixWd dag.size table widthAt table.size) + (prefixAvail dag.size table table.size) r) roots.toList l := by + refine forall₂_imp_mem hfor fun r hr e he => ?_ + rw [hidx, hwid] at he + exact build_prefix_size hwf hsize widthAt (Nat.le_refl _) hev (hroots r hr) he + refine ⟨hsz, hent, hroots', ?_⟩ + rw [hpred, hstpred, ← hsz, sum_range_eq (fun e => (sizeInfoWith widthAt e).full) _ + (fun j hj => (hent j hj).symm)] + unfold rootsCost + rw [Ix.Compile.Verify.UniformModel.array_foldl_add_sum] + have hr := forall₂_sum (f := fun r => gCost (Prep.ofDag dag) + (prefixWd dag.size table widthAt table.size) (prefixAvail dag.size table table.size) r) + (g := fun e => (sizeInfoWith widthAt e).full) hroots' (fun a _ b h => h) + have hc : (roots.toList.map fun r => st.ev.cost[r]!) = roots.toList.map fun r => + gCost (Prep.ofDag dag) (prefixWd dag.size table widthAt table.size) + (prefixAvail dag.size table table.size) r := + List.map_congr_left fun r _ => hev.cost r + rw [hc, ← hr] + +/-- **Re-materialized parts are minimal.** Entry `k` of a successful +`materializeTable` is no longer than any writing of `table[k]` with the +dictionary of the entries before it (Shares priced by the layout width of +their index), and some writing attains its length; likewise every root with +the whole table. -/ +theorem materializeTable_min {dag : Dag} (hwf : DagWF dag) {table roots : Array Nat} + {limits : Limits} {widthAt : Nat → Nat} {entries rs : Array Ixon.Expr} {predicted work : Nat} + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (h : materializeTable (Prep.ofDag dag) table roots limits widthAt = + .ok (entries, rs, predicted, work)) : + (∀ k (hk : k < entries.size), + (∀ T, Valid (Prep.ofDag dag) (prefixAvail dag.size table k) table[k]! T → + (sizeInfoWith widthAt entries[k]).full ≤ + T.gcost (Prep.ofDag dag) (prefixWd dag.size table widthAt k)) ∧ + ∃ T, Valid (Prep.ofDag dag) (prefixAvail dag.size table k) table[k]! T ∧ + T.gcost (Prep.ofDag dag) (prefixWd dag.size table widthAt k) = + (sizeInfoWith widthAt entries[k]).full) ∧ + List.Forall₂ (fun r e => + (∀ T, Valid (Prep.ofDag dag) (prefixAvail dag.size table table.size) r T → + (sizeInfoWith widthAt e).full ≤ + T.gcost (Prep.ofDag dag) (prefixWd dag.size table widthAt table.size)) ∧ + ∃ T, Valid (Prep.ofDag dag) (prefixAvail dag.size table table.size) r T ∧ + T.gcost (Prep.ofDag dag) (prefixWd dag.size table widthAt table.size) = + (sizeInfoWith widthAt e).full) roots.toList rs.toList := by + have hp := prepWF_ofDag hwf + obtain ⟨hsz, hent, hrs, _⟩ := materializeTable_spec hwf hroots h + obtain ⟨_, hrange, -⟩ := materializeTable_parts _ _ _ _ _ h + refine ⟨fun k hk => ?_, forall₂_imp_mem hrs fun r hr e he => ?_⟩ + · have ht := hrange k (by omega) + rw [hent k hk] + exact ⟨fun T hT => (hp.gValid_cost _ _ hT ht).1, + (hp.gExists_opt _ _ _ ht).1⟩ + · rw [he] + exact ⟨fun T hT => (hp.gValid_cost _ _ hT (hroots r hr)).1, + (hp.gExists_opt _ _ _ (hroots r hr)).1⟩ + +/-! ## One evaluation for an order closed under stored descendants + +`materializeTableOnePass` (the materialization `rematerialize` runs) prices +and builds every entry from one evaluation of the whole dictionary when the +table order passes `onePassOrder`, and recomputes the work `materializeTable` +counts from the spine counts (`spineAdd`) and a walk up the parent lists +(`ancestorWork`). `materializeTableOnePass_eq` proves it equal to +`materializeTable` on every input, so every statement about `materializeTable` +below holds for it: +* under the order check, below an entry the whole dictionary and the + dictionary of the entries before it agree (`prefix_agree_below`), so the + entry's cost with its own Share hidden is its cost there + (`evalHidden_model`) and `buildTop` writes what `build` writes there + (`buildTop_eq`); +* the spine count of a term is the number of available terms strictly below + it on its spine (`spineAdd_spec`, `spineCount_add`), and the walk sums the + work of a re-evaluation over the entry and the terms above it + (`ancestorWork_spec`, `evalUp_work`); +* step by step the loop returns what the table loop returns + (`onePassLoop_sim`). -/ + +section OnePass + +open Ix.Compile.Verify.SharingExact (Desc Desc.trans setBang_getElem! child_eq_getElem + pickOption_mem) + +/-! ## Spine counts -/ + +/-- `t` lies strictly below `u` on `u`'s spine. -/ +def OnSpine (p : Prep) (t u : Nat) : Prop := + p.family[u]! ≠ .none ∧ ∃ k, 1 ≤ k ∧ k < p.spineLen[u]! ∧ spineAt p u k = t + +/-- The terms whose spine continues into `x`, in increasing order. -/ +theorem spineParentLists_spec {dag : Dag} (x : Nat) (hx : x < dag.size) : + ((spineParentLists dag (Prep.ofDag dag).family)[x]?.getD #[]).toList = + (List.range dag.size).filter fun u => + ((Prep.ofDag dag).family[u]! != .none && + (Prep.ofDag dag).family[(dag.node u).spineNext]! == (Prep.ofDag dag).family[u]!) && + (dag.node u).spineNext == x := by + let cond := fun u => + ((Prep.ofDag dag).family[u]! != .none && + (Prep.ofDag dag).family[(dag.node u).spineNext]! == (Prep.ofDag dag).family[u]!) + have hinv : ∀ j, (foldRange (fun (sp : Array (Array Nat)) u => + let fam := (Prep.ofDag dag).family[u]! + let nxt := (dag.node u).spineNext + if (fam != .none && (Prep.ofDag dag).family[nxt]! == fam) = true then + sp.modify nxt (·.push u) else sp) + 0 j (Array.replicate dag.size #[])).size = dag.size ∧ + ∀ x, x < dag.size → + ((foldRange (fun (sp : Array (Array Nat)) u => + let fam := (Prep.ofDag dag).family[u]! + let nxt := (dag.node u).spineNext + if (fam != .none && (Prep.ofDag dag).family[nxt]! == fam) = true then + sp.modify nxt (·.push u) else sp) + 0 j (Array.replicate dag.size #[]))[x]?.getD #[]).toList = + (List.range j).filter fun u => cond u && (dag.node u).spineNext == x := by + intro j + induction j with + | zero => + refine ⟨by simp [foldRange], fun x hx => ?_⟩ + simp [foldRange, hx] + | succ j ih => + obtain ⟨hs, hl⟩ := ih + rw [foldRange_eq] at hs hl ⊢ + rw [List.range'_1_concat, List.foldl_append, List.foldl_cons, List.foldl_nil] + generalize (List.range' 0 j).foldl _ _ = sp at hs hl + simp only [Nat.zero_add] + refine ⟨?_, fun x hx => ?_⟩ + · split <;> simp [hs] + · rw [List.range_succ, List.filter_append] + split + · rename_i hc + rw [Array.getElem?_modify] + by_cases hxj : (dag.node j).spineNext = x + · subst hxj + rw [if_pos rfl, Array.getElem?_eq_getElem (by rw [hs]; exact hx)] + simp only [Option.map_some, Option.getD_some, Array.toList_push] + rw [← hl _ hx, Array.getElem?_eq_getElem (by rw [hs]; exact hx)] + simp [cond, hc] + · rw [if_neg hxj, hl x hx] + simp [hxj] + · rename_i hc + rw [hl x hx] + simp [cond, hc] + unfold spineParentLists + exact (hinv dag.size).2 x hx + +section Spine + +variable {dag : Dag} (hwf : DagWF dag) + +theorem sp_mem {x : Nat} (hx : x < dag.size) (y : Nat) : + y ∈ ((spineParentLists dag (Prep.ofDag dag).family)[x]?.getD #[]).toList ↔ + y < dag.size ∧ (Prep.ofDag dag).family[y]! ≠ .none ∧ + (Prep.ofDag dag).family[snext (Prep.ofDag dag) y]! = (Prep.ofDag dag).family[y]! ∧ + snext (Prep.ofDag dag) y = x := by + rw [spineParentLists_spec x hx, List.mem_filter, List.mem_range] + simp only [snext, ofDag_dag, Bool.and_eq_true, bne_iff_ne, ne_eq, beq_iff_eq] + constructor + · rintro ⟨h1, ⟨h2, h3⟩, h4⟩; exact ⟨h1, h2, h3, h4⟩ + · rintro ⟨h1, h2, h3, h4⟩; exact ⟨h1, ⟨h2, h3⟩, h4⟩ + +theorem sp_nodup (x : Nat) (hx : x < dag.size) : + ((spineParentLists dag (Prep.ofDag dag).family)[x]?.getD #[]).toList.Nodup := by + rw [spineParentLists_spec x hx] + exact (List.nodup_range).filter _ + +include hwf in +/-- A spine parent of `x` has `x` at position 1 of its spine. -/ +theorem sp_onSpine {x y : Nat} (hx : x < dag.size) + (hy : y ∈ ((spineParentLists dag (Prep.ofDag dag).family)[x]?.getD #[]).toList) : + OnSpine (Prep.ofDag dag) x y ∧ 2 ≤ (Prep.ofDag dag).spineLen[y]! ∧ + spineAt (Prep.ofDag dag) y 1 = x := by + have hp := prepWF_ofDag hwf + obtain ⟨hyn, hfy, hfs, hsn⟩ := (sp_mem hx y).mp hy + have hlen : 2 ≤ (Prep.ofDag dag).spineLen[y]! := by + rcases hp.spine_step hyn hfy with ⟨_, hl, _⟩ | ⟨hne, _, _⟩ + · have := (hp.spine (snext (Prep.ofDag dag) y) (Nat.lt_trans (hp.snext_lt hyn hfy) hyn) + (by rw [hfs]; exact hfy)).1 + omega + · exact absurd hfs hne + exact ⟨⟨hfy, 1, Nat.le_refl _, by omega, hsn⟩, hlen, hsn⟩ + +include hwf in +/-- The terms with `x` strictly below them on their spine are the spine +parents of `x` and the terms with one of those below them. -/ +theorem onSpine_decomp {x : Nat} (hx : x < dag.size) {u : Nat} (hu : u < dag.size) : + OnSpine (Prep.ofDag dag) x u ↔ + ∃ y ∈ ((spineParentLists dag (Prep.ofDag dag).family)[x]?.getD #[]).toList, + u = y ∨ OnSpine (Prep.ofDag dag) y u := by + have hp := prepWF_ofDag hwf + constructor + · rintro ⟨hfu, k, hk1, hkl, hkx⟩ + obtain ⟨_, hsp, _, _, _⟩ := hp.spine u hu hfu + by_cases hk : k = 1 + · subst hk + refine ⟨u, (sp_mem hx u).mpr ⟨hu, hfu, ?_, ?_⟩, Or.inl rfl⟩ + · obtain ⟨_, hf1, _, _⟩ := hsp 1 hkl + simpa [spineAt] using hf1 + · simpa [spineAt] using hkx + · obtain ⟨hle, hfk, _, _⟩ := hsp (k - 1) (by omega) + obtain ⟨_, hfk', _, _⟩ := hsp k hkl + have hstep : spineAt (Prep.ofDag dag) u k = + snext (Prep.ofDag dag) (spineAt (Prep.ofDag dag) u (k - 1)) := by + have := spineAt_add (Prep.ofDag dag) (k - 1) 1 u + rw [show k - 1 + 1 = k by omega] at this + rw [this]; rfl + refine ⟨spineAt (Prep.ofDag dag) u (k - 1), (sp_mem hx _).mpr ⟨by omega, + by rw [hfk]; exact hfu, by rw [← hstep, hfk', hfk], by rw [← hstep, hkx]⟩, Or.inr ?_⟩ + exact ⟨hfu, k - 1, by omega, by omega, rfl⟩ + · rintro ⟨y, hy, hu'⟩ + obtain ⟨⟨hfy, _⟩, hlen, hyx⟩ := sp_onSpine hwf hx hy + rcases hu' with rfl | ⟨hfu, k, hk1, hkl, hky⟩ + · exact ⟨hfy, 1, Nat.le_refl _, by omega, hyx⟩ + · obtain ⟨_, hsp, _, _, _⟩ := hp.spine u hu hfu + obtain ⟨_, _, hlenk, _⟩ := hsp k hkl + have hadd := spineAt_add (Prep.ofDag dag) k 1 u + refine ⟨hfu, k + 1, by omega, ?_, ?_⟩ + · rw [hky] at hlenk; omega + · rw [hadd, hky]; exact hyx + +include hwf in +/-- At most one spine parent of `x` is at or below `u` on `u`'s spine. -/ +theorem onSpine_unique {x : Nat} (hx : x < dag.size) {u : Nat} (hu : u < dag.size) + {y₁ y₂ : Nat} + (h₁ : y₁ ∈ ((spineParentLists dag (Prep.ofDag dag).family)[x]?.getD #[]).toList) + (h₂ : y₂ ∈ ((spineParentLists dag (Prep.ofDag dag).family)[x]?.getD #[]).toList) + (hu₁ : u = y₁ ∨ OnSpine (Prep.ofDag dag) y₁ u) (hu₂ : u = y₂ ∨ OnSpine (Prep.ofDag dag) y₂ u) : + y₁ = y₂ := by + have hp := prepWF_ofDag hwf + -- the position of a spine parent `y` of `x` on `u`'s spine, followed by `x` + have hpos : ∀ y, y ∈ ((spineParentLists dag (Prep.ofDag dag).family)[x]?.getD #[]).toList → + (u = y ∨ OnSpine (Prep.ofDag dag) y u) → + (Prep.ofDag dag).family[u]! ≠ .none ∧ ∃ k, k + 1 < (Prep.ofDag dag).spineLen[u]! ∧ + spineAt (Prep.ofDag dag) u k = y ∧ spineAt (Prep.ofDag dag) u (k + 1) = x := by + intro y hy huy + obtain ⟨⟨hfy, _⟩, hlen, hyx⟩ := sp_onSpine hwf hx hy + rcases huy with rfl | ⟨hfu, k, hk1, hkl, hky⟩ + · exact ⟨hfy, 0, by omega, rfl, hyx⟩ + · obtain ⟨_, hsp, _, _, _⟩ := hp.spine u hu hfu + obtain ⟨_, _, hlenk, _⟩ := hsp k hkl + have hadd := spineAt_add (Prep.ofDag dag) k 1 u + refine ⟨hfu, k, ?_, hky, by rw [hadd, hky]; exact hyx⟩ + rw [hky] at hlenk; omega + obtain ⟨hfu, k₁, hk₁, hy₁, hx₁⟩ := hpos y₁ h₁ hu₁ + obtain ⟨_, k₂, hk₂, hy₂, hx₂⟩ := hpos y₂ h₂ hu₂ + have : k₁ = k₂ := by + rcases Nat.lt_trichotomy k₁ k₂ with hlt | heq | hgt + · have := hp.spineAt_strict hu hfu (show k₁ + 1 < k₂ + 1 by omega) (Nat.le_of_lt hk₂) + omega + · exact heq + · have := hp.spineAt_strict hu hfu (show k₂ + 1 < k₁ + 1 by omega) (Nat.le_of_lt hk₁) + omega + subst this + rw [← hy₁, ← hy₂] + +theorem filter_length_unique {L : List Nat} (hL : L.Nodup) (q : Nat → Prop) [DecidablePred q] + (huniq : ∀ a ∈ L, ∀ b ∈ L, q a → q b → a = b) : + (L.filter fun y => decide (q y)).length = if ∃ y ∈ L, q y then 1 else 0 := by + induction L with + | nil => simp + | cons a L ih => + have hL' := (List.nodup_cons.mp hL).2 + have ha := (List.nodup_cons.mp hL).1 + have ih' := ih hL' fun x hx y hy => huniq x (List.mem_cons_of_mem _ hx) y (List.mem_cons_of_mem _ hy) + by_cases hqa : q a + · have hnone : (L.filter fun y => decide (q y)) = [] := by + rw [List.filter_eq_nil_iff] + intro y hy hqy + have := huniq a List.mem_cons_self y (List.mem_cons_of_mem _ hy) hqa (by simpa using hqy) + subst this + exact ha hy + simp [hqa, hnone] + · simp only [List.filter_cons, hqa, decide_false, Bool.false_eq_true, if_false, ih'] + congr 1 + apply propext + constructor + · rintro ⟨y, hy, hqy⟩; exact ⟨y, List.mem_cons_of_mem _ hy, hqy⟩ + · rintro ⟨y, hy, hqy⟩ + rcases List.mem_cons.mp hy with rfl | hy + · exact absurd hqy hqa + · exact ⟨y, hy, hqy⟩ + +open Classical in +include hwf in +theorem sp_count {x : Nat} (hx : x < dag.size) {u : Nat} (hu : u < dag.size) : + (((spineParentLists dag (Prep.ofDag dag).family)[x]?.getD #[]).toList.filter + fun y => decide (u = y ∨ OnSpine (Prep.ofDag dag) y u)).length = + if OnSpine (Prep.ofDag dag) x u then 1 else 0 := by + classical + rw [filter_length_unique (sp_nodup x hx) _ fun a ha b hb hqa hqb => + onSpine_unique hwf hx hu ha hb hqa hqb] + congr 1 + apply propext + exact (onSpine_decomp hwf hx hu).symm + +theorem modify_getElem!_nat (a : Array Nat) (x u : Nat) (f : Nat → Nat) (hx : x < a.size) : + (a.modify x f)[u]! = if x = u then f a[u]! else a[u]! := by + simp only [getElem!_def, Array.getElem?_modify] + by_cases h : x = u + · subst h; simp [Array.getElem?_eq_getElem hx] + · simp [h] + +include hwf in +theorem onSpine_ne {x u : Nat} (hu : u < dag.size) (h : OnSpine (Prep.ofDag dag) x u) : u ≠ x := by + obtain ⟨hf, k, hk1, hkl, rfl⟩ := h + have := (prepWF_ofDag hwf).spineAt_lt hu hf hk1 hkl + omega + +open Classical in +include hwf in +theorem spineAddGo_spec : + ∀ (fuel : Nat) (stack : List Nat) (sc sc' : Array Nat), sc.size = dag.size → + (∀ x ∈ stack, x < dag.size) → + spineAddGo (spineParentLists dag (Prep.ofDag dag).family) fuel stack sc = some sc' → + sc'.size = dag.size ∧ ∀ u, u < dag.size → + sc'[u]! = sc[u]! + (stack.filter fun y => decide (u = y ∨ OnSpine (Prep.ofDag dag) y u)).length := by + intro fuel + induction fuel with + | zero => + intro stack sc sc' hs _ h + cases stack with + | nil => simp only [spineAddGo, Option.some.injEq] at h; subst h; exact ⟨hs, fun u _ => by simp⟩ + | cons _ _ => simp [spineAddGo] at h + | succ fuel ih => + intro stack sc sc' hs hst h + cases stack with + | nil => simp only [spineAddGo, Option.some.injEq] at h; subst h; exact ⟨hs, fun u _ => by simp⟩ + | cons x S => + simp only [spineAddGo] at h + have hx := hst x List.mem_cons_self + have hst' : ∀ y ∈ ((spineParentLists dag (Prep.ofDag dag).family)[x]?.getD #[]).toList ++ S, + y < dag.size := by + intro y hy + rcases List.mem_append.mp hy with hy | hy + · exact ((sp_mem hx y).mp hy).1 + · exact hst y (List.mem_cons_of_mem _ hy) + obtain ⟨hs', hrow⟩ := ih _ _ sc' (by simp [hs]) hst' h + refine ⟨hs', fun u hu => ?_⟩ + rw [hrow u hu, modify_getElem!_nat sc x u _ (by omega), List.filter_append, List.length_append, + sp_count hwf hx hu, List.filter_cons] + have hne : OnSpine (Prep.ofDag dag) x u → u ≠ x := fun h => onSpine_ne hwf hu h + by_cases hux : x = u + · subst hux + have : ¬ OnSpine (Prep.ofDag dag) x x := fun h => hne h rfl + simp [this] + omega + · have hux' : u ≠ x := fun h => hux h.symm + by_cases hon : OnSpine (Prep.ofDag dag) x u + · simp [hux, hux', hon]; omega + · simp [hux, hux', hon] + +open Classical in +include hwf in +/-- **Spine counts.** After `t` becomes available, `spineAdd` adds one to the +count of exactly the terms with `t` strictly below them on their spine. -/ +theorem spineAdd_spec {sc sc' : Array Nat} (hs : sc.size = dag.size) {t : Nat} (ht : t < dag.size) + (h : spineAdd (spineParentLists dag (Prep.ofDag dag).family) sc t = some sc') : + sc'.size = dag.size ∧ ∀ u, u < dag.size → + sc'[u]! = sc[u]! + if OnSpine (Prep.ofDag dag) t u then 1 else 0 := by + unfold spineAdd at h + obtain ⟨hs', hrow⟩ := spineAddGo_spec hwf _ _ sc sc' hs (fun y hy => ((sp_mem ht y).mp hy).1) h + exact ⟨hs', fun u hu => by rw [hrow u hu, sp_count hwf ht hu]⟩ + +theorem filter_length_or (L : List Nat) (p p' q : Nat → Bool) + (h : ∀ k ∈ L, p' k = (p k || q k)) (hd : ∀ k ∈ L, ¬ (p k = true ∧ q k = true)) : + (L.filter p').length = (L.filter p).length + (L.filter q).length := by + induction L with + | nil => rfl + | cons a L ih => + have ih' := ih (fun k hk => h k (List.mem_cons_of_mem _ hk)) + (fun k hk => hd k (List.mem_cons_of_mem _ hk)) + have ha := h a List.mem_cons_self + have hda := hd a List.mem_cons_self + simp only [List.filter_cons] + cases hp : p a <;> cases hq : q a <;> simp_all <;> omega + +open Classical in +include hwf in +/-- A spine count after `t` becomes available: one more exactly for the +terms with `t` strictly below them on their spine. -/ +theorem spineCount_add {A A' : Nat → Bool} {t : Nat} (hA't : A' t = true) (hAt : A t = false) + (hsame : ∀ v, v ≠ t → A' v = A v) {u : Nat} (hu : u < dag.size) : + (if (Prep.ofDag dag).family[u]! = .none then 0 + else spineAvailCount (Prep.ofDag dag) A' u 1) = + (if (Prep.ofDag dag).family[u]! = .none then 0 + else spineAvailCount (Prep.ofDag dag) A u 1) + + if OnSpine (Prep.ofDag dag) t u then 1 else 0 := by + have hp := prepWF_ofDag hwf + by_cases hf : (Prep.ofDag dag).family[u]! = .none + · have : ¬ OnSpine (Prep.ofDag dag) t u := fun h => h.1 hf + simp [hf, this] + · simp only [hf, if_false] + unfold spineAvailCount + rw [filter_length_or _ (fun k => A (spineAt (Prep.ofDag dag) u k)) + (fun k => A' (spineAt (Prep.ofDag dag) u k)) (fun k => decide (spineAt (Prep.ofDag dag) u k = t)) + (fun k _ => by + by_cases hk : spineAt (Prep.ofDag dag) u k = t + · rw [hk, hA't, hAt]; simp + · rw [hsame _ hk]; simp [hk]) + (fun k _ h => by + obtain ⟨h1, h2⟩ := h + have hk : spineAt (Prep.ofDag dag) u k = t := by simpa using h2 + rw [hk, hAt] at h1; cases h1)] + congr 1 + rw [filter_length_unique List.nodup_range' _ fun a ha b hb hqa hqb => ?_] + · congr 1 + apply propext + constructor + · rintro ⟨k, hk, hkt⟩ + rw [List.mem_range'_1] at hk + exact ⟨hf, k, hk.1, by omega, hkt⟩ + · rintro ⟨_, k, hk1, hkl, hkt⟩ + exact ⟨k, List.mem_range'_1.mpr ⟨hk1, by omega⟩, hkt⟩ + · rw [List.mem_range'_1] at ha hb + rcases Nat.lt_trichotomy a b with hlt | heq | hgt + · have := hp.spineAt_strict hu hf hlt (by omega); omega + · exact heq + · have := hp.spineAt_strict hu hf hgt (by omega); omega + +end Spine + +/-! ## The ancestor walk -/ + +/-- Invariant of `awGo`. -/ +structure AwInv (dag : Dag) (sc : Array Nat) (epoch t k j : Nat) (mark queue : Array Nat) + (sum : Nat) : Prop where + size : mark.size = dag.size + marked : ∀ u : Nat, mark[u]! = epoch ↔ u ∈ queue + le : ∀ u : Nat, mark[u]! ≤ epoch + anc : ∀ u ∈ queue, u < dag.size ∧ Desc dag u t + nodup : queue.toList.Nodup + start : t ∈ queue + sum : sum = (queue.toList.map fun u => 1 + sc[u]!).sum + closed : ∀ i, i < k → ∀ p ∈ ((parentEdgeLists dag)[queue[i]!]?.getD #[]).toList, p ∈ queue + part : k < queue.size → + ∀ p ∈ (((parentEdgeLists dag)[queue[k]!]?.getD #[]).toList.take j), p ∈ queue + kle : k ≤ queue.size + +section Walk + +variable {dag : Dag} (sc : Array Nat) (epoch t : Nat) + +theorem push_getElem! {queue : Array Nat} {u i : Nat} (hi : i < queue.size) : + (queue.push u)[i]! = queue[i]! := by + rw [getElem!_pos (queue.push u) i (by simp; omega), getElem!_pos queue i hi] + simp [Array.getElem_push, hi] + +theorem awGo_spec : + ∀ (fuel k j : Nat) (mark queue : Array Nat) (sum : Nat) (r : Nat × Array Nat × Array Nat), + AwInv dag sc epoch t k j mark queue sum → + awGo (parentEdgeLists dag) sc epoch fuel k j mark queue sum = some r → + AwInv dag sc epoch t r.2.2.size 0 r.2.1 r.2.2 r.1 := by + intro fuel + induction fuel with + | zero => intro _ _ _ _ _ _ _ h; simp [awGo] at h + | succ fuel ih => + intro k j mark queue sum r hinv h + unfold awGo at h + split at h + · rename_i hk + have hqk : queue[k]! = queue[k] := getElem!_pos queue k hk + dsimp only at h + split at h + · rename_i hj + have hpk := hinv.anc _ (Array.getElem_mem hk) + have hu := Array.getElem_mem hj + have hpar := (parentEdgeLists_ok dag _ hpk.1 _).mp hu + have hdesc : Desc dag (((parentEdgeLists dag)[queue[k]]?.getD #[])[j]) t := + (desc_of_child hpar.2).trans hpk.2 + have htake : ∀ p, p ∈ (((parentEdgeLists dag)[queue[k]!]?.getD #[]).toList.take (j + 1)) → + p ∈ (((parentEdgeLists dag)[queue[k]!]?.getD #[]).toList.take j) ∨ + p = ((parentEdgeLists dag)[queue[k]]?.getD #[])[j] := by + intro p hp + rw [hqk] at hp ⊢ + rw [List.take_add_one, List.mem_append] at hp + rcases hp with hp | hp + · exact Or.inl hp + · right + rw [List.getElem?_toArray] at hp + simp [Array.getElem?_eq_getElem hj] at hp + exact hp + split at h + · rename_i hm + have hin : ((parentEdgeLists dag)[queue[k]]?.getD #[])[j] ∈ queue := + (hinv.marked _).mp (by simpa using hm) + refine ih k (j + 1) mark queue sum r { hinv with part := fun hk' p hp => ?_ } h + rcases htake p hp with hp | rfl + · exact hinv.part hk' p hp + · exact hin + · rename_i hm + have hnot : ((parentEdgeLists dag)[queue[k]]?.getD #[])[j] ∉ queue := fun hin => + hm (by simpa using (hinv.marked _).mpr hin) + apply ih k (j + 1) _ _ _ r _ h + refine ⟨by simp [Array.set!_eq_setIfInBounds, hinv.size], fun v => ?_, fun v => ?_, + fun v hv => ?_, ?_, Array.mem_push.mpr (Or.inl hinv.start), ?_, fun i hik p hp => ?_, + fun hk' p hp => ?_, by simp; have := hinv.kle; omega⟩ + · rw [setBang_getElem!, Array.mem_push] + by_cases hv : v = ((parentEdgeLists dag)[queue[k]]?.getD #[])[j] + · subst hv; simp [hinv.size, hpar.1] + · simp only [hv, false_and, if_false, Ne.symm hv] + rw [hinv.marked v] + simp + · rw [setBang_getElem!] + split + · exact Nat.le_refl _ + · exact hinv.le v + · rcases Array.mem_push.mp hv with hv | rfl + · exact hinv.anc v hv + · exact ⟨hpar.1, hdesc⟩ + · rw [Array.toList_push, List.nodup_append] + refine ⟨hinv.nodup, by simp, ?_⟩ + intro a ha b hb + simp at hb + subst hb + intro hab + subst hab + exact hnot (Array.mem_toList_iff.mp ha) + · rw [Array.toList_push, List.map_append, List.sum_append, hinv.sum] + simp + omega + · have hi' : i < queue.size := by have := hinv.kle; omega + rw [push_getElem! hi'] at hp + exact Array.mem_push.mpr (Or.inl (hinv.closed i hik p hp)) + · rw [push_getElem! hk] at hp + rcases htake p hp with hp | rfl + · exact Array.mem_push.mpr (Or.inl (hinv.part hk p hp)) + · exact Array.mem_push.mpr (Or.inr rfl) + · rename_i hj + apply ih (k + 1) 0 mark queue sum r _ h + refine { hinv with + closed := fun i hik p hp => ?_ + part := fun _ p hp => by simp at hp + kle := by omega } + by_cases hik' : i < k + · exact hinv.closed i hik' p hp + · have hik'' : i = k := by omega + subst hik'' + have := hinv.part hk p + rw [hqk, List.take_of_length_le (by simp; omega)] at this + exact this (by rw [hqk] at hp; exact hp) + · rename_i hk + simp only [Option.some.injEq] at h + subst h + have hke : k = queue.size := by have := hinv.kle; omega + show AwInv dag sc epoch t queue.size 0 mark queue sum + exact { hinv with + closed := fun i hi => hinv.closed i (by omega) + part := fun hk' => absurd hk' (Nat.lt_irrefl _) + kle := Nat.le_refl _ } + +theorem awInv_complete (hwf : DagWF dag) {mark queue : Array Nat} {w : Nat} + (hinv : AwInv dag sc epoch t queue.size 0 mark queue w) : + ∀ u, u < dag.size → Desc dag u t → u ∈ queue := by + suffices h : ∀ u, Desc dag u t → u < dag.size → u ∈ queue from fun u hu hd => h u hd hu + intro u hd + induction hd with + | refl => intro _; exact hinv.start + | @child v u' k hk hc ih => + intro hu + have hck : (dag.node v).child k ∈ (dag.node v).children := by + rw [child_eq_getElem _ k hk]; exact Array.getElem_mem hk + have hlt := hwf.child_lt hu hck + have hcin : (dag.node v).child k ∈ queue := by + exact ih hinv (Nat.lt_trans hlt hu) + obtain ⟨i, hi, hqi⟩ := Array.mem_iff_getElem.mp hcin + have hpar := (parentEdgeLists_ok dag _ (Nat.lt_trans hlt hu) v).mpr ⟨hu, hck⟩ + apply hinv.closed i hi v + rw [getElem!_pos queue i hi, hqi] + exact Array.mem_toList_iff.mpr hpar + +/-- **Ancestor work.** The walk sums `1 + sc` over `t` and the terms above it +(as `ancestorMarks` lists them), leaving its marks at most `epoch`. -/ +theorem ancestorWork_spec (hwf : DagWF dag) {mark queue mark' queue' : Array Nat} + {fuel w : Nat} (ht : t < dag.size) (hms : mark.size = dag.size) + (hlt : ∀ u : Nat, mark[u]! < epoch) + (h : ancestorWork (parentEdgeLists dag) sc epoch t fuel mark queue = some (w, mark', queue')) : + w = (((List.range' t (dag.size - t)).filter fun u => (ancestorMarks dag t)[u]!).map + fun u => 1 + sc[u]!).sum ∧ + mark'.size = dag.size ∧ ∀ u : Nat, mark'[u]! ≤ epoch := by + have hq0 : ((queue.shrink 0).push t).toList = [t] := by + simp + have hinv0 : AwInv dag sc epoch t 0 0 (mark.set! t epoch) ((queue.shrink 0).push t) + (1 + sc[t]!) := by + refine ⟨by simp [Array.set!_eq_setIfInBounds, hms], fun u => ?_, fun u => ?_, + fun u hu => ?_, ?_, ?_, ?_, fun i hi => absurd hi (Nat.not_lt_zero _), + fun _ p hp => by simp at hp, Nat.zero_le _⟩ + · rw [setBang_getElem!, ← Array.mem_toList_iff, hq0, List.mem_singleton] + by_cases hut : u = t + · subst hut; simp [hms, ht] + · rw [if_neg (fun h => hut h.1.symm)] + have := hlt u + constructor + · intro h; omega + · intro h; exact absurd h hut + · rw [setBang_getElem!] + split + · exact Nat.le_refl _ + · exact Nat.le_of_lt (hlt u) + · rw [← Array.mem_toList_iff, hq0, List.mem_singleton] at hu + subst hu + exact ⟨ht, .refl _⟩ + · rw [hq0]; simp + · rw [← Array.mem_toList_iff, hq0]; simp + · rw [hq0]; simp + unfold ancestorWork at h + have hfin := awGo_spec sc epoch t fuel 0 0 _ _ _ _ hinv0 h + simp only at hfin + refine ⟨?_, hfin.size, hfin.le⟩ + rw [hfin.sum] + apply List.Perm.sum_nat + apply List.Perm.map + rw [List.perm_ext_iff_of_nodup hfin.nodup ((List.nodup_range').filter _)] + intro u + rw [Array.mem_toList_iff, List.mem_filter, List.mem_range'_1] + constructor + · intro hu + obtain ⟨hun, hd⟩ := hfin.anc u hu + have hle := Desc.le_of_wf hwf hd hun + exact ⟨⟨hle, by omega⟩, (ancestorMarks_iff hwf ht u hun).mpr hd⟩ + · rintro ⟨⟨h1, h2⟩, hm⟩ + have hun : u < dag.size := by omega + exact awInv_complete sc epoch t hwf hfin u hun ((ancestorMarks_iff hwf ht u hun).mp hm) + +end Walk + +/-! ## An entry priced and built under the whole dictionary -/ + +section Entry + +variable {dag : Dag} (hwf : DagWF dag) + +include hwf in +/-- **Hidden cost.** Under an evaluation of a dictionary `(wdK, AK)`, the cost +of `t` with its own Share hidden is its cost under any dictionary without +`t` that agrees strictly below it. -/ +theorem evalHidden_model {wdK wdi : Nat → Nat} {AK Ai : Nat → Bool} {ev : DictEval} + (hev : GEvalOK (Prep.ofDag dag) wdK AK ev) (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if AK u then some (wdK u) else none) + {t : Nat} (ht : t < dag.size) (hAi : Ai t = false) (hwdi : wdi t = 0) + (hag : ∀ w, Desc dag t w → w ≠ t → AK w = Ai w ∧ wdK w = wdi w) : + evalHidden (Prep.ofDag dag).dag (Prep.ofDag dag).family (Prep.ofDag dag).spineLen + (Prep.ofDag dag).tail width (Array.replicate dag.size true) ev t = + gCost (Prep.ofDag dag) wdi Ai t := by + have hp := prepWF_ofDag hwf + rw [← evalHidden_eq] + have hwidth' : ∀ u, widthOf (width.set! t none) u = + if (if u = t then false else AK u) then some (if u = t then 0 else wdK u) else none := by + intro u + rw [widthOf_setBang_none] + by_cases hu : u = t + · simp [hu] + · simp only [hu, if_false]; exact hwidth u + have hrows : ∀ u, u < t → GEvalRow (Prep.ofDag dag) (fun u => if u = t then 0 else wdK u) + (fun u => if u = t then false else AK u) ev u := by + intro u hu + refine gEvalRow_local hwf (by omega) (fun v hv => ?_) (hev.2 u (by simp [ofDag_dag]; omega)) + have := Desc.le_of_wf hwf hv (by omega) + have hvt : v ≠ t := by omega + simp [hvt] + have haff : (Array.replicate dag.size true)[t]! = true := by simp [ht] + obtain ⟨_, hrows'⟩ := hp.gEvalStep_spec (width.set! t none) hwidth' + (Array.replicate dag.size true) ev t ht haff hev.1 hrows + rw [(hrows' t (Nat.lt_succ_self t)).1] + refine gCost_local hwf t ht fun v hv => ?_ + by_cases hvt : v = t + · subst hvt; simp [hAi, hwdi] + · simp only [hvt, if_false]; exact hag v hv hvt + +variable {wdA wdB : Nat → Nat} {A B : Nat → Bool} + {ev ev' : DictEval} {index index' width width' : Array (Option Nat)} + (hev : GEvalOK (Prep.ofDag dag) wdA A ev) (hev' : GEvalOK (Prep.ofDag dag) wdB B ev') + (hwA : ∀ u, widthOf width u = if A u then some (wdA u) else none) + (hwB : ∀ u, widthOf width' u = if B u then some (wdB u) else none) + (hiA : ∀ u, (index[u]?.getD none).isSome = A u) + (hiB : ∀ u, (index'[u]?.getD none).isSome = B u) + +include hwf hev hev' hwA hwB hiA hiB in +/-- **Entry body.** `buildTop` under a dictionary with `t` writes what `build` +writes under a dictionary without `t` that agrees strictly below it, when +given that dictionary's cost of `t`. -/ +theorem buildTop_eq {t : Nat} (ht : t < dag.size) (hnone : index'[t]?.getD none = none) + (hag : ∀ w, Desc dag t w → w ≠ t → + index[w]?.getD none = index'[w]?.getD none ∧ wdA w = wdB w) (fuel : Nat) : + (Prep.ofDag dag).buildTop ev index width ev'.cost[t]! (fuel + 1) t = + (Prep.ofDag dag).build ev' index' width' false (fuel + 1) t := by + have hp := prepWF_ofDag hwf + have hsub : ∀ c, Desc dag t c → c ≠ t → c < dag.size → + (Prep.ofDag dag).build ev index width false fuel c = + (Prep.ofDag dag).build ev' index' width' false fuel c := by + intro c hc hne hcn + refine build_congr hwf hev hev' hwA hwB hiA hiB fuel false c hcn fun w hw => hag w (hc.trans hw) ?_ + have := Desc.le_of_wf hwf hw hcn + have := Desc.le_of_wf hwf hc ht + omega + have hshare : optShare index' width' t = #[] := by unfold optShare; rw [hnone] + have hopts : (Prep.ofDag dag).options ev' index' width' t = + optRest (Prep.ofDag dag) ev' index' width' t := by + rw [options_split, hshare, Array.empty_append] + have hpick : (Prep.ofDag dag).pickBuild ev index width true t = + pickOption ((Prep.ofDag dag).options ev' index' width' t) := by + have h1 := pick_options_lazy (Prep.ofDag dag) ev index width true t + rw [pickLazy_eq_pickBuild, if_pos rfl] at h1 + rw [← h1, options_filter, hopts, optRest_congr hwf hev hev' hwA hwB hiA hiB ht hag] + simp only [Prep.buildTop, Prep.build, hpick, Bool.false_eq_true, if_false, Bool.false_or] + generalize hpk : pickOption ((Prep.ofDag dag).options ev' index' width' t) = pk + rcases pk with _ | ⟨choice, c⟩ + · rfl + · obtain ⟨b, hb⟩ := pickOption_mem _ hpk + have hopt' := hp.gOptions_mem ev' hev' index' width' hwB hiB ht hb + simp only [ofDag_dag] + by_cases hchk : (c == ev'.cost[t]!) = true + · simp only [hchk, if_true] + cases choice with + | share => + rw [hopts] at hb + exact absurd rfl (optRest_noShare _ _ _ _ _ _ hb) + | inline => + have har := hwf.children_size ht + have hchild : ∀ k, k < (dag.node t).head.arity → + Desc dag t ((dag.node t).child k) ∧ (dag.node t).child k ≠ t ∧ + (dag.node t).child k < dag.size := by + intro k hk + have hk' : k < (dag.node t).children.size := by rw [har]; exact hk + have := hwf.childAt_lt ht hk + exact ⟨.child k hk' (.refl _), by omega, by omega⟩ + cases hh : (dag.node t).head + case prj ti f => + have h0 := hchild 0 (by simp [hh, Head.arity]) + simp only + rw [hsub _ h0.1 h0.2.1 h0.2.2] + case letE lc => + have h0 := hchild 0 (by simp [hh, Head.arity]) + have h1 := hchild 1 (by simp [hh, Head.arity]) + have h2 := hchild 2 (by simp [hh, Head.arity]) + simp only + rw [hsub _ h0.1 h0.2.1 h0.2.2, hsub _ h1.1 h1.2.1 h1.2.2, hsub _ h2.1 h2.2.1 h2.2.2] + all_goals rfl + | cut j => + obtain ⟨h1, _⟩ | ⟨h1, _⟩ | ⟨j', hj', hf, hj1, hjl, _⟩ := hopt' + · cases h1 + · cases h1 + cases hj' + dsimp only + rw [spineWalk_eq] + simp only + have hside : ∀ n ∈ (List.range j).map (fun k => (Prep.ofDag dag).dag.node + (spineAt (Prep.ofDag dag) t k)), ∀ acc, + (do let side ← (Prep.ofDag dag).build ev index width false fuel n.sideChild + rebuildSpineNode n acc side : Except SharingError Ixon.Expr) = + (do let side ← (Prep.ofDag dag).build ev' index' width' false fuel n.sideChild + rebuildSpineNode n acc side) := by + intro n hn acc + obtain ⟨k, hk', rfl⟩ := List.mem_map.mp hn + rw [List.mem_range] at hk' + have hd := desc_sideAt hwf ht hf (k := k) (by omega) + have hlt := hp.sideAt_lt ht hf (k := k) (by omega) + unfold sideAt at hd hlt + rw [hsub _ hd (by omega) (by omega)] + split + · rfl + · split + · rename_i hjlt + have hdj := desc_spineAt hwf ht hf j (by omega) + have hjt := hp.spineAt_lt ht hf (k := j) (by omega) hjlt + rw [(hag _ hdj (by omega)).1] + split + · simp only [pure_bind] + exact foldrM_congr_mem hside _ + · rfl + · rename_i hjlt + have hdj := desc_spineAt hwf ht hf j (by omega) + obtain ⟨_, _, hend, htl, _⟩ := hp.spine t ht hf + have hjeq : j = (Prep.ofDag dag).spineLen[t]! := by omega + have hjt : spineAt (Prep.ofDag dag) t j < t := by rw [hjeq, hend]; exact htl + rw [hsub _ hdj (by omega) (by omega)] + cases (Prep.ofDag dag).build ev' index' width' false fuel + (spineAt (Prep.ofDag dag) t j) with + | error e => rfl + | ok tl => exact foldrM_congr_mem hside _ + · simp only [hchk, Bool.false_eq_true, if_false] + rfl + +end Entry + +/-! ## The order check -/ + +section Guard + +theorem foldl_max_bound (f : Nat → Nat) : ∀ (l : List Nat) (init : Nat), + init ≤ l.foldl (fun m c => max m (f c)) init ∧ + ∀ c ∈ l, f c ≤ l.foldl (fun m c => max m (f c)) init + | [], _ => ⟨Nat.le_refl _, fun _ h => absurd h (List.not_mem_nil)⟩ + | a :: l, init => by + obtain ⟨h1, h2⟩ := foldl_max_bound f l (max init (f a)) + simp only [List.foldl_cons] + refine ⟨Nat.le_trans (Nat.le_max_left _ _) h1, fun c hc => ?_⟩ + rcases List.mem_cons.mp hc with rfl | hc + · exact Nat.le_trans (Nat.le_max_right _ _) h1 + · exact h2 c hc + +/-- The running maximum of the check: at least `pos v` for every term `v` +strictly below `u`. -/ +theorem maxBelow_ge {dag : Dag} (hwf : DagWF dag) (pos : Nat → Nat) : + ∀ u v, Desc dag u v → u < dag.size → v ≠ u → + pos v ≤ (foldRange (fun (mb : Array Nat) u => + mb.set! u ((dag.node u).children.foldl (fun m c => max m (max (pos c) mb[c]!)) 0)) + 0 dag.size (Array.replicate dag.size 0))[u]! := by + let F := fun (mb : Array Nat) u => + mb.set! u ((dag.node u).children.foldl (fun m c => max m (max (pos c) mb[c]!)) 0) + have hinv : ∀ m, m ≤ dag.size → + ((List.range' 0 m).foldl F (Array.replicate dag.size 0)).size = dag.size ∧ + ∀ u, u < m → ∀ c ∈ (dag.node u).children, + pos c ≤ ((List.range' 0 m).foldl F (Array.replicate dag.size 0))[u]! ∧ + ((List.range' 0 m).foldl F (Array.replicate dag.size 0))[c]! ≤ + ((List.range' 0 m).foldl F (Array.replicate dag.size 0))[u]! := by + intro m + induction m with + | zero => intro _; exact ⟨by simp, fun u hu => absurd hu (Nat.not_lt_zero _)⟩ + | succ m ih => + intro hm + obtain ⟨hs, hrow⟩ := ih (by omega) + rw [List.range'_1_concat, List.foldl_append, List.foldl_cons, List.foldl_nil, Nat.zero_add] + generalize (List.range' 0 m).foldl F (Array.replicate dag.size 0) = st at hs hrow + have hkeep : ∀ x, x ≠ m → (F st m)[x]! = st[x]! := by + intro x hx + simp only [F] + rw [setBang_getElem!, if_neg (fun h => hx h.1.symm)] + refine ⟨by simp [F, hs], fun u hu c hc => ?_⟩ + have hcu := hwf.child_lt (by omega) hc + rw [hkeep c (by omega)] + by_cases hum : u = m + · subst hum + have hset : (F st u)[u]! = (dag.node u).children.foldl + (fun m c => max m (max (pos c) st[c]!)) 0 := by + simp only [F] + rw [setBang_getElem!, if_pos ⟨rfl, by omega⟩] + rw [hset, ← Array.foldl_toList] + have := (foldl_max_bound (fun c => max (pos c) st[c]!) (dag.node u).children.toList 0).2 c + (Array.mem_toList_iff.mpr hc) + exact ⟨Nat.le_trans (Nat.le_max_left _ _) this, Nat.le_trans (Nat.le_max_right _ _) this⟩ + · rw [hkeep u hum] + exact hrow u (by omega) c hc + obtain ⟨_, hrow⟩ := hinv dag.size (Nat.le_refl _) + rw [foldRange_eq] + intro u v hd + induction hd with + | refl => intro _ h; exact absurd rfl h + | @child u' v' k hk hc ih => + intro hu hne + have hck : (dag.node u').child k ∈ (dag.node u').children := by + rw [child_eq_getElem _ k hk]; exact Array.getElem_mem hk + have hlt := hwf.child_lt hu hck + obtain ⟨h1, h2⟩ := hrow u' hu _ hck + by_cases hvc : v' = (dag.node u').child k + · rw [hvc]; exact h1 + · exact Nat.le_trans (ih (by omega) hvc) h2 + +/-- The prefix dictionaries of a table of distinct terms. -/ +theorem indexOfPrefix_iff {n : Nat} {table : Array Nat} + (htab : ∀ i, i < table.size → table[i]! < n) + (hdist : ∀ i j, i < table.size → j < table.size → table[i]! = table[j]! → i = j) : + ∀ k, k ≤ table.size → (indexOfPrefix n table k).size = n ∧ + ∀ u j, (indexOfPrefix n table k)[u]?.getD none = some j ↔ j < k ∧ table[j]! = u := by + intro k + induction k with + | zero => + intro _ + rw [indexOfPrefix_zero] + refine ⟨by simp, fun u j => ?_⟩ + by_cases hu : u < n <;> simp [hu] + | succ k ih => + intro hk + obtain ⟨hs, hiff⟩ := ih (by omega) + rw [indexOfPrefix_succ n table (by omega)] + refine ⟨by simp [hs], fun u j => ?_⟩ + rw [getD_setBang, hs] + have htk := htab k (by omega) + by_cases hut : u = table[k]! + · subst hut + rw [if_pos ⟨rfl, htk⟩, Option.some.injEq] + constructor + · rintro rfl; exact ⟨by omega, rfl⟩ + · rintro ⟨hj, hjk⟩ + exact (hdist j k (by omega) (by omega) hjk).symm + · rw [if_neg (fun h => hut h.1.symm), hiff] + constructor + · rintro ⟨hj, rfl⟩; exact ⟨by omega, rfl⟩ + · rintro ⟨hj, rfl⟩ + refine ⟨?_, rfl⟩ + by_cases hjk : j = k + · subst hjk; exact absurd rfl hut + · omega + +/-- What a passing order check gives. -/ +theorem onePassOrder_spec {dag : Dag} {table roots : Array Nat} {index : Array (Option Nat)} + (h : onePassOrder dag table roots index = true) : + DagWF dag ∧ (∀ r ∈ roots.toList, r < dag.size) ∧ + ∀ i, i < table.size → index[table[i]!]?.getD none = some i ∧ + (table[i]! < dag.size → ∀ v j, Desc dag table[i]! v → v ≠ table[i]! → + index[v]?.getD none = some j → j < i) := by + unfold onePassOrder at h + simp only [Bool.and_eq_true, List.all_eq_true, List.mem_range, decide_eq_true_eq, + beq_iff_eq] at h + obtain ⟨⟨⟨hcp, har⟩, hroots⟩, hord⟩ := h + have hwf := dagWF_of_checks hcp har + refine ⟨hwf, fun r hr => ?_, fun i hi => ⟨(hord i hi).1, fun ht v j hd hne hv => ?_⟩⟩ + · rw [Array.all_eq_true] at hroots + obtain ⟨k, hk, rfl⟩ := List.mem_iff_getElem.mp hr + simpa using hroots k (by simpa using hk) + · have h2 := (hord i hi).2 + have := Nat.le_trans (maxBelow_ge hwf _ _ v hd ht hne) h2 + simp only [hv] at this + have h3 : j + 1 ≤ i := this + omega + +end Guard + +/-! ## The loop -/ + +section Loop + +theorem materializeStep_eq (p : Prep) (table : Array Nat) (limits : Limits) (widthAt : Nat → Nat) + (st : TableState) (i : Nat) : + materializeStep p table limits widthAt st i = + if st.ev.cost[table[i]!]! > limits.maxMaterialize then + .error (.resourceExhausted .materialize limits.maxMaterialize) + else match p.build st.ev st.index st.width false (p.dag.size + 1) table[i]! with + | .error e => .error e + | .ok e => + if st.work + st.ev.work + st.ev.cost[table[i]!]! > limits.maxMaterializeWork then + .error (.resourceExhausted .materializeWork limits.maxMaterializeWork) + else .ok { entries := st.entries.push e, + index := st.index.set! table[i]! (some i), + width := st.width.set! table[i]! (some (widthAt i)), + ev := p.evalUp st.ev (st.width.set! table[i]! (some (widthAt i))) table[i]!, + predicted := st.predicted + st.ev.cost[table[i]!]!, + work := st.work + st.ev.work + st.ev.cost[table[i]!]! } := by + unfold materializeStep + by_cases h1 : st.ev.cost[table[i]!]! > limits.maxMaterialize + · simp [h1, bind, Except.bind, throw, throwThe, MonadExceptOf.throw] + · cases hb : p.build st.ev st.index st.width false (p.dag.size + 1) table[i]! with + | error e => simp [h1, hb, bind, Except.bind] + | ok e => + by_cases h2 : st.work + st.ev.work + st.ev.cost[table[i]!]! > limits.maxMaterializeWork + · simp [h1, h2, hb, bind, Except.bind, throw, throwThe, MonadExceptOf.throw] + · simp [h1, h2, hb, bind, Except.bind, pure, Except.pure] + +/-- The spine counts after `i` entries. -/ +def ScInv (dag : Dag) (table : Array Nat) (i : Nat) (sc : Array Nat) : Prop := + sc.size = dag.size ∧ ∀ u, u < dag.size → + sc[u]! = if (Prep.ofDag dag).family[u]! = .none then 0 + else spineAvailCount (Prep.ofDag dag) (prefixAvail dag.size table i) u 1 + +/-- What the loop returns, against the table loop of `materializeTable`. -/ +def LoopRel (p : Prep) (table : Array Nat) (limits : Limits) (widthAt : Nat → Nat) (i k : Nat) + (st : TableState) (r : Except SharingError (Array Ixon.Expr × Nat × Nat × Nat)) + (inv : TableState → Prop) : Prop := + match r with + | .error e => (List.range' i k).foldlM (materializeStep p table limits widthAt) st = .error e + | .ok (entries, work, evWork, predicted) => + ∃ st', (List.range' i k).foldlM (materializeStep p table limits widthAt) st = .ok st' ∧ + inv st' ∧ st'.entries = entries ∧ st'.work = work ∧ st'.ev.work = evWork ∧ + st'.predicted = predicted + +theorem loopRel_step {p : Prep} {table : Array Nat} {limits : Limits} {widthAt : Nat → Nat} + {i k : Nat} {st st' : TableState} {r : Except SharingError (Array Ixon.Expr × Nat × Nat × Nat)} + {inv : TableState → Prop} (h : materializeStep p table limits widthAt st i = .ok st') + (hr : LoopRel p table limits widthAt (i + 1) k st' r inv) : + LoopRel p table limits widthAt i (k + 1) st r inv := by + have hf : (List.range' i (k + 1)).foldlM (materializeStep p table limits widthAt) st = + (List.range' (i + 1) k).foldlM (materializeStep p table limits widthAt) st' := by + rw [List.range'_succ, List.foldlM_cons, h]; rfl + unfold LoopRel at hr ⊢ + rw [hf] + exact hr + +theorem loopRel_error {p : Prep} {table : Array Nat} {limits : Limits} {widthAt : Nat → Nat} + {i k : Nat} {st : TableState} {e : SharingError} {inv : TableState → Prop} + (h : materializeStep p table limits widthAt st i = .error e) : + LoopRel p table limits widthAt i (k + 1) st (.error e) inv := by + unfold LoopRel + rw [List.range'_succ, List.foldlM_cons, h] + rfl + +variable {dag : Dag} (hwf : DagWF dag) {table : Array Nat} {limits : Limits} {widthAt : Nat → Nat} + (hsize : table.size < UInt64.size) + (hrange : ∀ k, k < table.size → table[k]! < dag.size) + (hiff : ∀ k, k ≤ table.size → ∀ u j, + (indexOfPrefix dag.size table k)[u]?.getD none = some j ↔ j < k ∧ table[j]! = u) + (hcl : ∀ i, i < table.size → ∀ v j, Desc dag table[i]! v → v ≠ table[i]! → + (indexOfPrefix dag.size table table.size)[v]?.getD none = some j → j < i) + +include hiff hcl in +theorem prefix_agree_below {i : Nat} (hi : i < table.size) {v : Nat} (hd : Desc dag table[i]! v) + (hne : v ≠ table[i]!) : + (indexOfPrefix dag.size table i)[v]?.getD none = + (indexOfPrefix dag.size table table.size)[v]?.getD none := by + cases hK : (indexOfPrefix dag.size table table.size)[v]?.getD none with + | some j => + have hj := hcl i hi v j hd hne hK + have := ((hiff table.size (Nat.le_refl _) v j).mp hK).2 + exact (hiff i (by omega) v j).mpr ⟨hj, this⟩ + | none => + cases hI : (indexOfPrefix dag.size table i)[v]?.getD none with + | none => rfl + | some j => + obtain ⟨hj, hjv⟩ := (hiff i (by omega) v j).mp hI + have := (hiff table.size (Nat.le_refl _) v j).mpr ⟨by omega, hjv⟩ + rw [hK] at this; cases this + +include hiff in +theorem prefix_none_self {i : Nat} (hi : i < table.size) : + (indexOfPrefix dag.size table i)[table[i]!]?.getD none = none := by + cases hI : (indexOfPrefix dag.size table i)[table[i]!]?.getD none with + | none => rfl + | some j => + obtain ⟨hj, hjv⟩ := (hiff i (by omega) _ j).mp hI + have h1 := (hiff table.size (Nat.le_refl _) _ j).mpr ⟨by omega, hjv⟩ + have h2 := (hiff table.size (Nat.le_refl _) table[i]! i).mpr ⟨hi, rfl⟩ + rw [h1] at h2 + cases h2; omega + +open Classical in +include hwf hsize hrange hiff hcl in +/-- **The loop.** From the state of `materializeTable` after `i` entries, +`onePassLoop` returns what the table loop returns (when its walks do not run +out of fuel). -/ +theorem onePassLoop_sim : + ∀ (k i : Nat) (st : TableState) (ew : Nat) (sc mark queue : Array Nat) + (r : Except SharingError (Array Ixon.Expr × Nat × Nat × Nat)), + i + k = table.size → TableEvInv dag table widthAt i st → ew = st.ev.work → + ScInv dag table i sc → + mark.size = dag.size → (∀ u : Nat, mark[u]! < i + 1) → + onePassLoop (Prep.ofDag dag) table limits + ((Prep.ofDag dag).evalAll ((indexOfPrefix dag.size table table.size).map (·.map widthAt))) + (indexOfPrefix dag.size table table.size) + ((indexOfPrefix dag.size table table.size).map (·.map widthAt)) + (Array.replicate dag.size true) (parentEdgeLists dag) + (spineParentLists dag (Prep.ofDag dag).family) k i st.entries st.work ew + st.predicted sc mark queue = some r → + LoopRel (Prep.ofDag dag) table limits widthAt i k st r + (TableEvInv dag table widthAt table.size) := by + have hp := prepWF_ofDag hwf + have hevK : GEvalOK (Prep.ofDag dag) (prefixWd dag.size table widthAt table.size) + (prefixAvail dag.size table table.size) + ((Prep.ofDag dag).evalAll ((indexOfPrefix dag.size table table.size).map (·.map widthAt))) := + hp.evalAll_ok (ofDag_empty_size dag) _ (prefix_width dag.size table widthAt table.size) + intro k + induction k with + | zero => + intro i st ew sc mark queue r hik hI hew _ _ _ h + subst hew + simp only [onePassLoop, Option.some.injEq] at h + subst h + have : i = table.size := by omega + subst this + exact ⟨st, rfl, hI, rfl, rfl, rfl, rfl⟩ + | succ k ih => + intro i st ew sc mark queue r hik hI hew hsc hms hml h + subst hew + have hi : i < table.size := by omega + have ht := hrange i hi + obtain ⟨_, hidx, hwid, hev, _, _, _⟩ := hI + -- the dictionaries below the entry + have hag : ∀ w, Desc dag table[i]! w → w ≠ table[i]! → + (indexOfPrefix dag.size table table.size)[w]?.getD none = + (indexOfPrefix dag.size table i)[w]?.getD none ∧ + prefixWd dag.size table widthAt table.size w = prefixWd dag.size table widthAt i w := by + intro w hw hne + have := prefix_agree_below hiff hcl hi hw hne + refine ⟨this.symm, ?_⟩ + unfold prefixWd + rw [this] + have hnone := prefix_none_self hiff hi + have hE1 : evalHidden (Prep.ofDag dag).dag (Prep.ofDag dag).family (Prep.ofDag dag).spineLen + (Prep.ofDag dag).tail ((indexOfPrefix dag.size table table.size).map (·.map widthAt)) + (Array.replicate dag.size true) + ((Prep.ofDag dag).evalAll ((indexOfPrefix dag.size table table.size).map (·.map widthAt))) + table[i]! = st.ev.cost[table[i]!]! := by + rw [hev.cost] + refine evalHidden_model hwf hevK _ (prefix_width dag.size table widthAt table.size) ht + (by unfold prefixAvail; rw [hnone]; rfl) (by unfold prefixWd; rw [hnone]) + fun w hw hne => ⟨?_, (hag w hw hne).2⟩ + unfold prefixAvail + rw [(hag w hw hne).1] + have hE2 : (Prep.ofDag dag).buildTop + ((Prep.ofDag dag).evalAll ((indexOfPrefix dag.size table table.size).map (·.map widthAt))) + (indexOfPrefix dag.size table table.size) + ((indexOfPrefix dag.size table table.size).map (·.map widthAt)) st.ev.cost[table[i]!]! + (dag.size + 1) table[i]! = + (Prep.ofDag dag).build st.ev st.index st.width false (dag.size + 1) table[i]! := by + rw [hidx, hwid] + exact buildTop_eq hwf hevK hev (prefix_width dag.size table widthAt table.size) + (prefix_width dag.size table widthAt i) (fun u => rfl) (fun u => rfl) ht hnone hag _ + simp only [onePassLoop] at h + simp only [hE1] at h + simp only [ofDag_dag] at h + by_cases hc : st.ev.cost[table[i]!]! > limits.maxMaterialize + · simp only [hc, if_true, Option.some.injEq] at h + subst h + apply loopRel_error + rw [materializeStep_eq] + simp [hc] + · simp only [hc, if_false] at h + rw [hE2] at h + cases hb : (Prep.ofDag dag).build st.ev st.index st.width false (dag.size + 1) table[i]! with + | error e => + rw [hb] at h + simp only [Option.some.injEq] at h + subst h + apply loopRel_error + rw [materializeStep_eq] + simp [hc, hb, ofDag_dag] + | ok e => + rw [hb] at h + simp only at h + by_cases hw : st.work + st.ev.work + st.ev.cost[table[i]!]! > limits.maxMaterializeWork + · simp only [hw, if_true, Option.some.injEq] at h + subst h + apply loopRel_error + rw [materializeStep_eq] + simp [hc, hb, hw, ofDag_dag] + · simp only [hw, if_false] at h + cases hsa : spineAdd (spineParentLists dag (Prep.ofDag dag).family) sc table[i]! with + | none => rw [hsa] at h; cases h + | some sc' => + rw [hsa] at h + simp only at h + cases haw : ancestorWork (parentEdgeLists dag) sc' (i + 1) table[i]! + (4 * dag.size + 2) mark queue with + | none => rw [haw] at h; cases h + | some x => + obtain ⟨w, mark', queue'⟩ := x + rw [haw] at h + simp only at h + let st' : TableState := ⟨st.entries.push e, st.index.set! table[i]! (some i), + st.width.set! table[i]! (some (widthAt i)), + (Prep.ofDag dag).evalUp st.ev (st.width.set! table[i]! (some (widthAt i))) table[i]!, + st.predicted + st.ev.cost[table[i]!]!, st.work + st.ev.work + st.ev.cost[table[i]!]!⟩ + have hstep : materializeStep (Prep.ofDag dag) table limits widthAt st i = .ok st' := by + rw [materializeStep_eq] + simp only [ofDag_dag, hc, if_false, hb, hw] + rfl + have hI' := tableEvInv_step hwf hsize hrange ⟨by omega, hidx, hwid, hev, by assumption, + by assumption, by assumption⟩ hi hstep + -- spine counts + obtain ⟨hs', hrow'⟩ := spineAdd_spec hwf hsc.1 ht hsa + have hsucc_avail : ∀ v, v ≠ table[i]! → + prefixAvail dag.size table (i + 1) v = prefixAvail dag.size table i v := + fun v hv => (prefix_succ_agree dag.size table widthAt hi v hv).1 + have hAt' : prefixAvail dag.size table (i + 1) table[i]! = true := by + unfold prefixAvail + rw [(hiff (i + 1) (by omega) _ i).mpr ⟨by omega, rfl⟩] + rfl + have hAt : prefixAvail dag.size table i table[i]! = false := by + unfold prefixAvail; rw [hnone]; rfl + have hsc' : ScInv dag table (i + 1) sc' := by + refine ⟨hs', fun u hu => ?_⟩ + rw [hrow' u hu, hsc.2 u hu] + exact (spineCount_add hwf hAt' hAt hsucc_avail hu).symm + -- the walk + obtain ⟨hwsum, hms', hml'⟩ := ancestorWork_spec sc' (i + 1) table[i]! hwf ht hms hml haw + have hwidth' : st.width.set! table[i]! (some (widthAt i)) = + (indexOfPrefix dag.size table (i + 1)).map (·.map widthAt) := by + rw [hwid, indexOfPrefix_succ dag.size table hi] + simp [Array.set!, Array.map_setIfInBounds] + have hwork := evalUp_work hwf hev ht + (fun v hv => prefix_succ_agree dag.size table widthAt hi v hv) + (st.width.set! table[i]! (some (widthAt i))) + (by rw [hwidth']; exact prefix_width dag.size table widthAt (i + 1)) + have hw' : w = st'.ev.work := by + show w = ((Prep.ofDag dag).evalUp st.ev + (st.width.set! table[i]! (some (widthAt i))) table[i]!).work + rw [hwork, hwsum] + congr 1 + apply List.map_congr_left + intro u hu + have hun : u < dag.size := by + have := (List.mem_range'_1.mp (List.mem_filter.mp hu).1); omega + unfold nodeWork + rw [hsc'.2 u hun] + have := ih (i + 1) st' w sc' mark' queue' r (by omega) hI' hw' hsc' hms' + (fun u => Nat.lt_succ_of_le (hml' u)) h + exact loopRel_step hstep this + +end Loop + +/-! ## The one-pass materialization -/ + +theorem list_mapM_congr {α β ε : Type} {f g : α → Except ε β} : + ∀ (l : List α), (∀ x ∈ l, f x = g x) → l.mapM f = l.mapM g + | [], _ => rfl + | a :: l, h => by + rw [List.mapM_cons, List.mapM_cons, h a List.mem_cons_self, + list_mapM_congr l fun x hx => h x (List.mem_cons_of_mem _ hx)] + +/-- **One-pass phase 3.** `materializeTableOnePass` returns exactly what +`materializeTable` returns, on every input: entries, roots, predicted length, +work, errors and the points where the limits are checked. -/ +theorem materializeTableOnePass_eq (dag : Dag) (table roots : Array Nat) (limits : Limits) + (widthAt : Nat → Nat) : + materializeTableOnePass (Prep.ofDag dag) table roots limits widthAt = + materializeTable (Prep.ofDag dag) table roots limits widthAt := by + unfold materializeTableOnePass + by_cases h1 : table.size ≥ wordBound + · unfold materializeTable; simp [h1] + cases h2 : table.all (· < (Prep.ofDag dag).dag.size) + · unfold materializeTable; simp [h1, h2] + simp only [h1, if_false, Bool.not_true, Bool.false_eq_true] + by_cases h3f : onePassOrder (Prep.ofDag dag).dag table roots + (indexOfPrefix (Prep.ofDag dag).dag.size table table.size) = false + · simp [h3f] + have h3 : onePassOrder dag table roots (indexOfPrefix dag.size table table.size) = true := by + cases hb : onePassOrder dag table roots (indexOfPrefix dag.size table table.size) with + | true => rfl + | false => exact absurd hb h3f + have h3' : (!onePassOrder (Prep.ofDag dag).dag table roots + (indexOfPrefix (Prep.ofDag dag).dag.size table table.size)) = false := by + rw [ofDag_dag, h3]; rfl + simp only [h3', Bool.false_eq_true, if_false] + obtain ⟨hwf, hroots, hord⟩ := onePassOrder_spec h3 + have hp := prepWF_ofDag hwf + have htab : ∀ i, i < table.size → table[i]! < dag.size := by + intro i hi + rw [getElem!_pos table i hi] + exact of_decide_eq_true (Array.all_eq_true.mp h2 i hi) + have hdist : ∀ i j, i < table.size → j < table.size → table[i]! = table[j]! → i = j := by + intro i j hi hj hij + have h1 := (hord i hi).1 + rw [hij, (hord j hj).1] at h1 + cases h1; rfl + have hiff := fun k hk => (indexOfPrefix_iff htab hdist k hk).2 + have hcl : ∀ i, i < table.size → ∀ v j, Desc dag table[i]! v → v ≠ table[i]! → + (indexOfPrefix dag.size table table.size)[v]?.getD none = some j → j < i := + fun i hi v j hd hne hv => (hord i hi).2 (htab i hi) v j hd hne hv + have hsize : table.size < UInt64.size := by unfold wordBound at h1; omega + have hI0 : TableEvInv dag table widthAt 0 + { entries := #[], index := Array.replicate (Prep.ofDag dag).dag.size none, + width := Array.replicate (Prep.ofDag dag).dag.size none, + ev := (Prep.ofDag dag).evalAll (Array.replicate (Prep.ofDag dag).dag.size none), + predicted := tag0Size table.size, work := 0 } := by + have hidx0 := indexOfPrefix_zero dag.size table + refine ⟨Nat.zero_le _, by rw [hidx0]; rfl, by rw [hidx0]; simp; rfl, ?_, rfl, + fun j hj => absurd hj (by simp), by simp⟩ + refine hp.evalAll_ok (ofDag_empty_size dag) _ fun u => ?_ + rw [widthOf_eq] + unfold prefixAvail + rw [hidx0] + simp only [ofDag_dag] + by_cases hu : u < dag.size + · simp [hu] + · simp [hu]; rfl + have hsc0 : ScInv dag table 0 (Array.replicate dag.size 0) := by + refine ⟨by simp, fun u hu => ?_⟩ + rw [spineAvailCount_nil] + · simp [hu] + · intro k _ _ + unfold prefixAvail + rw [indexOfPrefix_zero] + simp only [Array.getElem?_replicate] + split <;> rfl + have hevK : GEvalOK (Prep.ofDag dag) (prefixWd dag.size table widthAt table.size) + (prefixAvail dag.size table table.size) + ((Prep.ofDag dag).evalAll ((indexOfPrefix dag.size table table.size).map (·.map widthAt))) := + hp.evalAll_ok (ofDag_empty_size dag) _ (prefix_width dag.size table widthAt table.size) + generalize hloop : onePassLoop (Prep.ofDag dag) table limits + ((Prep.ofDag dag).evalAll + ((indexOfPrefix (Prep.ofDag dag).dag.size table table.size).map (·.map widthAt))) + (indexOfPrefix (Prep.ofDag dag).dag.size table table.size) + ((indexOfPrefix (Prep.ofDag dag).dag.size table table.size).map (·.map widthAt)) + (Array.replicate (Prep.ofDag dag).dag.size true) (parentEdgeLists (Prep.ofDag dag).dag) + (spineParentLists (Prep.ofDag dag).dag (Prep.ofDag dag).family) table.size 0 #[] 0 + (Prep.ofDag dag).dag.size (tag0Size table.size) + (Array.replicate (Prep.ofDag dag).dag.size 0) (Array.replicate (Prep.ofDag dag).dag.size 0) + #[] = res + rcases res with _ | res + · rfl + have hrel := onePassLoop_sim hwf hsize htab hiff hcl table.size 0 _ _ _ _ _ res (by omega) hI0 + (evalAll_none_work hwf).symm hsc0 + (by simp [ofDag_dag]) (fun u => by by_cases hu : u < dag.size <;> simp [hu, ofDag_dag]) + hloop + unfold materializeTable + simp only [h1, h2, if_false, Bool.not_true, Bool.false_eq_true] + rw [List.range_eq_range'] + rcases res with e | ⟨entries, work, evWork, predicted⟩ + · simp only [LoopRel] at hrel + rw [hrel] + rfl + · obtain ⟨st', hfold, hI', rfl, rfl, rfl, rfl⟩ := hrel + rw [hfold] + obtain ⟨_, hidx, hwid, hev', _, _, _⟩ := hI' + have hcost : ((Prep.ofDag dag).evalAll + ((indexOfPrefix (Prep.ofDag dag).dag.size table table.size).map (·.map widthAt))).cost = + st'.ev.cost := by + apply Array.ext + · exact hevK.1.1.trans hev'.1.1.symm + · intro j hj1 hj2 + have := (hevK.cost j).trans (hev'.cost j).symm + rwa [getElem!_pos _ j hj1, getElem!_pos _ j hj2] at this + have hbuild : roots.mapM (fun r => (Prep.ofDag dag).build + ((Prep.ofDag dag).evalAll + ((indexOfPrefix (Prep.ofDag dag).dag.size table table.size).map (·.map widthAt))) + (indexOfPrefix (Prep.ofDag dag).dag.size table table.size) + ((indexOfPrefix (Prep.ofDag dag).dag.size table table.size).map (·.map widthAt)) false + ((Prep.ofDag dag).dag.size + 1) r) = + roots.mapM (fun r => (Prep.ofDag dag).build st'.ev st'.index st'.width false + ((Prep.ofDag dag).dag.size + 1) r) := by + rw [Array.mapM_eq_mapM_toList, Array.mapM_eq_mapM_toList, hidx, hwid] + congr 1 + exact list_mapM_congr _ fun r hr => build_congr hwf hevK hev' + (prefix_width dag.size table widthAt table.size) + (prefix_width dag.size table widthAt table.size) (fun u => rfl) (fun u => rfl) + (dag.size + 1) false r (hroots r hr) fun w _ => ⟨rfl, rfl⟩ + simp only [hcost, hbuild] + rfl + +end OnePass + +/-! ## Phase 3 of the tiered construction -/ + +theorem layoutBytes_eq (l : ShareLayout) (sharing roots : Array Ixon.Expr) : + layoutBytes l sharing roots = tag0Size sharing.size + + (sharing.toList.map fun e => (sizeInfoWith l.widthAt e).full).sum + + (roots.toList.map fun e => (sizeInfoWith l.widthAt e).full).sum := by + unfold layoutBytes + simp only + rw [Ix.Compile.Verify.UniformModel.array_foldl_add_sum, + Ix.Compile.Verify.UniformModel.array_foldl_add_sum] + +/-- The parts of a successful phase 3. -/ +theorem rematerialize_parts {layout : ShareLayout} {limits : Limits} {ex : Expanded} + {order : Array Nat} {phase1Layout : Nat} {m : Rematerialized} + (h : rematerialize layout limits ex order phase1Layout = .ok m) : + ∃ work, materializeTable (Prep.ofDag ex.dag) order ex.roots limits layout.widthAt = + .ok (m.entries, m.roots, m.bytes, work) ∧ + m.bytes ≤ phase1Layout ∧ + (∃ k, reexpand limits ex.dag m.entries m.roots = .ok (order, ex.roots, k)) ∧ + (m.entries ++ m.roots).all (fun e => (wireCounts e).isSome) = true := by + unfold rematerialize at h + obtain ⟨⟨entries, roots, predicted, work⟩, hmat, h⟩ := bind_eq_ok h + rw [materializeTableOnePass_eq] at hmat + dsimp only at h + obtain ⟨_, _, h⟩ := bind_eq_ok h + obtain ⟨_, hc2, h⟩ := bind_eq_ok h + obtain ⟨⟨entryIds, rootIds, k⟩, hre, h⟩ := bind_eq_ok h + dsimp only at h + obtain ⟨_, hc3, h⟩ := bind_eq_ok h + obtain ⟨_, hc4, h⟩ := bind_eq_ok h + obtain ⟨_, hc6, h⟩ := bind_eq_ok h + simp only [pure, Except.pure, Except.ok.injEq] at h + subst h + have h6 := checkInternal_ok hc6 + have h2 := checkInternal_ok hc2 + have h3 := checkInternal_ok hc3 + have h4 := checkInternal_ok hc4 + simp only [decide_eq_true_eq, beq_iff_eq] at h2 h3 h4 + subst h3 h4 + exact ⟨work, hmat, h2, ⟨k, hre⟩, h6⟩ + +/-- The length phase 3 records: the layout length of its output, as both +`bytes` and `measured`. -/ +theorem rematerialize_measured {layout : ShareLayout} {limits : Limits} {ex : Expanded} + {order : Array Nat} {phase1Layout : Nat} {m : Rematerialized} + (h : rematerialize layout limits ex order phase1Layout = .ok m) : + m.measured = layoutBytes layout m.entries m.roots ∧ m.bytes = m.measured := by + unfold rematerialize at h + obtain ⟨⟨entries, roots, predicted, work⟩, -, h⟩ := bind_eq_ok h + dsimp only at h + obtain ⟨_, hc1, h⟩ := bind_eq_ok h + obtain ⟨_, -, h⟩ := bind_eq_ok h + obtain ⟨⟨entryIds, rootIds, k⟩, -, h⟩ := bind_eq_ok h + dsimp only at h + obtain ⟨_, -, h⟩ := bind_eq_ok h + obtain ⟨_, -, h⟩ := bind_eq_ok h + obtain ⟨_, -, h⟩ := bind_eq_ok h + simp only [pure, Except.pure, Except.ok.injEq] at h + subst h + have h1 := checkInternal_ok hc1 + simp only [beq_iff_eq] at h1 + exact ⟨rfl, h1.symm⟩ + +/-- **Phase 3.** A successful re-materialization of the allocated order +`order` (on an input whose DAG and roots passed the phase-1 checks): +* entry `k` has the minimum layout length over all writings of `order[k]` + with the entries before it as the dictionary, and each root the minimum + with the whole table (Shares priced by the layout width of their index); +* the predicted length is the layout length of the output, and it is at + most the phase-1 candidate's layout length; +* entry `k` references only entries below `k`, the roots only table entries; +* with every `Share(i)` replaced by the term of entry `i`, entry `k` is the + term `order[k]` and each root is its input term, and the output re-expands + to the table terms `order` and the input roots. +Each part is exact for its dictionary; the composition is not claimed to be +a global byte minimum. -/ +theorem rematerialize_spec {layout : ShareLayout} {limits : Limits} {ex : Expanded} + {order : Array Nat} {phase1Layout : Nat} {m : Rematerialized} + (hwf : DagWF ex.dag) (hroots : ∀ r ∈ ex.roots.toList, r < ex.dag.size) + (h : rematerialize layout limits ex order phase1Layout = .ok m) : + m.entries.size = order.size ∧ + (∀ k (hk : k < m.entries.size), + (∀ T, Valid (Prep.ofDag ex.dag) (prefixAvail ex.dag.size order k) order[k]! T → + (sizeInfoWith layout.widthAt m.entries[k]).full ≤ + T.gcost (Prep.ofDag ex.dag) (prefixWd ex.dag.size order layout.widthAt k)) ∧ + ∃ T, Valid (Prep.ofDag ex.dag) (prefixAvail ex.dag.size order k) order[k]! T ∧ + T.gcost (Prep.ofDag ex.dag) (prefixWd ex.dag.size order layout.widthAt k) = + (sizeInfoWith layout.widthAt m.entries[k]).full) ∧ + List.Forall₂ (fun r e => + (∀ T, Valid (Prep.ofDag ex.dag) (prefixAvail ex.dag.size order order.size) r T → + (sizeInfoWith layout.widthAt e).full ≤ + T.gcost (Prep.ofDag ex.dag) (prefixWd ex.dag.size order layout.widthAt order.size)) ∧ + ∃ T, Valid (Prep.ofDag ex.dag) (prefixAvail ex.dag.size order order.size) r T ∧ + T.gcost (Prep.ofDag ex.dag) (prefixWd ex.dag.size order layout.widthAt order.size) = + (sizeInfoWith layout.widthAt e).full) ex.roots.toList m.roots.toList ∧ + m.bytes = layoutBytes layout m.entries m.roots ∧ m.bytes ≤ phase1Layout ∧ + (∀ k (hk : k < m.entries.size), Ix.Compile.Verify.SharingExact.SharesIn (· < k) + m.entries[k]) ∧ + (∀ r ∈ m.roots.toList, Ix.Compile.Verify.SharingExact.SharesIn (· < order.size) r) ∧ + (∀ (E : Nat → Ixon.Expr), Ix.Compile.Verify.SharingExact.DagModel ex.dag E → + (∀ k (hk : k < m.entries.size), + Ix.Compile.Verify.SharingExact.substShares (fun i => E order[i]!) m.entries[k] = + E order[k]!) ∧ + List.Forall₂ (fun r e => + Ix.Compile.Verify.SharingExact.substShares (fun i => E order[i]!) e = E r) + ex.roots.toList m.roots.toList) ∧ + ∃ k, reexpand limits ex.dag m.entries m.roots = .ok (order, ex.roots, k) := by + obtain ⟨work, hmat, hle, hre, -⟩ := rematerialize_parts h + obtain ⟨hsz, -, -, hpred⟩ := materializeTable_spec hwf hroots hmat + obtain ⟨hmin, hrmin⟩ := materializeTable_min hwf hroots hmat + obtain ⟨hsize, -, -⟩ := materializeTable_parts _ _ _ _ _ hmat + obtain ⟨_, hback, hrback⟩ := Ix.Compile.Verify.SharingExact.materializeTable_backward _ _ _ _ _ + (by omega) hmat + refine ⟨hsz, hmin, hrmin, by rw [layoutBytes_eq, hpred], hle, hback, hrback, + fun E hE => Ix.Compile.Verify.SharingExact.materializeTable_correct _ _ _ _ _ (by omega) + hmat E hE, hre⟩ + +end Ix.Compile.Verify.Tiered diff --git a/Ix/Compile/Verify/TieredSelect.lean b/Ix/Compile/Verify/TieredSelect.lean new file mode 100644 index 000000000..e9dee26a3 --- /dev/null +++ b/Ix/Compile/Verify/TieredSelect.lean @@ -0,0 +1,170 @@ +import Ix.Compile.Verify.SharingExact +import Ix.Sharing.Exact + +/-! +# Tiered construction: width selection + +`canonicalTieredExpanded` runs the per-phase construction at the phase-1 +widths 1, 2 and 3 and returns one of the three candidates: one with the +fewest final layout bytes (`phase3LayoutBytes`), and among those the one of +lowest width (`canonicalTieredCore_select`). Each candidate is exact per phase +(`TieredTier`, `TieredPhase3`); the selection is the real-byte minimum over +these three candidates only. The composition is NOT claimed to be a global +byte minimum over all tables, orders and encodings. +-/ + +namespace Ix.Compile.Verify.Tiered + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (bind_eq_ok) + +/-- A successful candidate is assembled from its three phases. -/ +theorem tieredAtWidth_parts {layout : ShareLayout} {limits : Limits} {ex : Expanded} {w : Nat} + {c : TieredSharingResult} (h : tieredAtWidth layout limits ex w = .ok c) : + ∃ u a m, optimizeUniformExpanded w limits ex = .ok u ∧ + allocate layout limits ex.dag (graphFacts ex.dag ex.roots).deg u.result.tableTerms + u.result.sharing u.result.roots = .ok a ∧ + rematerialize layout limits ex a.order + (layoutBytes layout u.result.sharing u.result.roots) = .ok m ∧ + c = tieredResult layout ex w u a m := by + unfold tieredAtWidth at h + obtain ⟨u, hu, h⟩ := bind_eq_ok h + obtain ⟨a, ha, h⟩ := bind_eq_ok h + obtain ⟨m, hm, h⟩ := bind_eq_ok h + exact ⟨u, a, m, hu, ha, hm, (Except.ok.inj h).symm⟩ + +/-- The candidate at width `w` reports width `w`. -/ +theorem tieredAtWidth_w {layout : ShareLayout} {limits : Limits} {ex : Expanded} {w : Nat} + {c : TieredSharingResult} (h : tieredAtWidth layout limits ex w = .ok c) : c.stats.w = w := by + obtain ⟨u, a, m, -, -, -, rfl⟩ := tieredAtWidth_parts h + rfl + +theorem tieredBetter_iff_of_ne {a b : TieredSharingResult} (hw : a.stats.w ≠ b.stats.w) : + tieredBetter a b = true ↔ + a.stats.phase3LayoutBytes < b.stats.phase3LayoutBytes ∨ + (a.stats.phase3LayoutBytes = b.stats.phase3LayoutBytes ∧ a.stats.w < b.stats.w) := by + simp only [tieredBetter, Bool.or_eq_true, Bool.and_eq_true, decide_eq_true_eq, beq_iff_eq] + constructor + · rintro (h | ⟨h1, h2 | ⟨h3, _⟩⟩) + · exact Or.inl h + · exact Or.inr ⟨h1, h2⟩ + · exact absurd h3 hw + · rintro (h | ⟨h1, h2⟩) + · exact Or.inl h + · exact Or.inr ⟨h1, Or.inl h2⟩ + +/-- The chosen candidate of three with widths 1, 2, 3: it is one of them, no +candidate has fewer bytes, and every candidate with as few bytes has at least +its width. -/ +theorem select_three (c₁ c₂ c₃ : TieredSharingResult) (h₁ : c₁.stats.w = 1) + (h₂ : c₂.stats.w = 2) (h₃ : c₃.stats.w = 3) : + let best := #[c₂, c₃].foldl (fun b c => if tieredBetter c b then c else b) c₁ + (best = c₁ ∨ best = c₂ ∨ best = c₃) ∧ + (∀ c ∈ [c₁, c₂, c₃], best.stats.phase3LayoutBytes ≤ c.stats.phase3LayoutBytes) ∧ + (∀ c ∈ [c₁, c₂, c₃], c.stats.phase3LayoutBytes = best.stats.phase3LayoutBytes → + best.stats.w ≤ c.stats.w) := by + intro best + have hfold : best = (if tieredBetter c₃ (if tieredBetter c₂ c₁ then c₂ else c₁) then c₃ + else if tieredBetter c₂ c₁ then c₂ else c₁) := by + simp [best] + rw [hfold] + have e₁ := tieredBetter_iff_of_ne (a := c₂) (b := c₁) (by omega) + have e₂ := tieredBetter_iff_of_ne (a := c₃) (b := c₁) (by omega) + have e₃ := tieredBetter_iff_of_ne (a := c₃) (b := c₂) (by omega) + rw [h₁, h₂] at e₁ + rw [h₁, h₃] at e₂ + rw [h₂, h₃] at e₃ + have key : ∀ b : TieredSharingResult, (b = c₁ ∨ b = c₂ ∨ b = c₃) → + (∀ c ∈ [c₁, c₂, c₃], b.stats.phase3LayoutBytes ≤ c.stats.phase3LayoutBytes) → + (∀ c ∈ [c₁, c₂, c₃], c.stats.phase3LayoutBytes = b.stats.phase3LayoutBytes → + b.stats.w ≤ c.stats.w) → + (b = c₁ ∨ b = c₂ ∨ b = c₃) ∧ + (∀ c ∈ [c₁, c₂, c₃], b.stats.phase3LayoutBytes ≤ c.stats.phase3LayoutBytes) ∧ + (∀ c ∈ [c₁, c₂, c₃], c.stats.phase3LayoutBytes = b.stats.phase3LayoutBytes → + b.stats.w ≤ c.stats.w) := fun _ a b c => ⟨a, b, c⟩ + have mem3 : ∀ (P : TieredSharingResult → Prop), P c₁ → P c₂ → P c₃ → + ∀ c ∈ [c₁, c₂, c₃], P c := by + intro P p1 p2 p3 c hc + simp only [List.mem_cons, List.not_mem_nil, or_false] at hc + rcases hc with rfl | rfl | rfl <;> assumption + by_cases b₁ : tieredBetter c₂ c₁ = true + · have f₁ := e₁.mp b₁ + rw [if_pos b₁] + by_cases b₂ : tieredBetter c₃ c₂ = true + · have f₂ := e₃.mp b₂ + rw [if_pos b₂] + exact key c₃ (by simp) (mem3 _ (by omega) (by omega) (by omega)) + (mem3 _ (by rw [h₁, h₃]; omega) (by rw [h₂, h₃]; omega) (fun _ => by omega)) + · have f₂ := mt e₃.mpr b₂ + rw [if_neg b₂] + exact key c₂ (by simp) (mem3 _ (by omega) (by omega) (by omega)) + (mem3 _ (by rw [h₁, h₂]; omega) (fun _ => by omega) (by rw [h₂, h₃]; omega)) + · have f₁ := mt e₁.mpr b₁ + rw [if_neg b₁] + by_cases b₂ : tieredBetter c₃ c₁ = true + · have f₂ := e₂.mp b₂ + rw [if_pos b₂] + exact key c₃ (by simp) (mem3 _ (by omega) (by omega) (by omega)) + (mem3 _ (by rw [h₁, h₃]; omega) (by rw [h₂, h₃]; omega) (fun _ => by omega)) + · have f₂ := mt e₂.mpr b₂ + rw [if_neg b₂] + exact key c₁ (by simp) (mem3 _ (by omega) (by omega) (by omega)) + (mem3 _ (fun _ => by omega) (by rw [h₁, h₂]; omega) (by rw [h₁, h₃]; omega)) + +/-- **Width selection.** The canonical tiered construction on a DAG and roots +runs the candidates at widths 1, 2 and 3 and returns one of them (with the +three final lengths recorded): no candidate has fewer final layout bytes, +and every candidate with as few bytes has at least the returned width (so +the lowest width wins a tie; the widths differ, so the `setPrec` tie-break +never decides). This is the real-byte minimum over the three candidates, +NOT a global byte minimum. -/ +theorem canonicalTieredCore_select {layout : ShareLayout} {limits : Limits} {dag : Dag} + {roots : Array Nat} {r : TieredSharingResult} + (h : canonicalTieredCore layout limits dag roots = .ok r) : + let ex : Expanded := { dag, roots, visits := 0, internedNodes := 0 } + ∃ c₁ c₂ c₃, tieredAtWidth layout limits ex 1 = .ok c₁ ∧ + tieredAtWidth layout limits ex 2 = .ok c₂ ∧ tieredAtWidth layout limits ex 3 = .ok c₃ ∧ + (∃ c ∈ [c₁, c₂, c₃], r = { c with stats := { c.stats with candidateLengths := + #[(1, c₁.stats.phase3LayoutBytes), (2, c₂.stats.phase3LayoutBytes), + (3, c₃.stats.phase3LayoutBytes)] } }) ∧ + (∀ c ∈ [c₁, c₂, c₃], r.stats.phase3LayoutBytes ≤ c.stats.phase3LayoutBytes) ∧ + (∀ c ∈ [c₁, c₂, c₃], c.stats.phase3LayoutBytes = r.stats.phase3LayoutBytes → + r.stats.w ≤ c.stats.w) := by + intro ex + unfold canonicalTieredCore at h + obtain ⟨c₁, hc₁, h⟩ := bind_eq_ok h + obtain ⟨c₂, hc₂, h⟩ := bind_eq_ok h + obtain ⟨c₃, hc₃, h⟩ := bind_eq_ok h + have hw₁ := tieredAtWidth_w hc₁ + have hw₂ := tieredAtWidth_w hc₂ + have hw₃ := tieredAtWidth_w hc₃ + obtain ⟨hmem, hle, htie⟩ := select_three c₁ c₂ c₃ hw₁ hw₂ hw₃ + have hr := (Except.ok.inj h).symm + refine ⟨c₁, c₂, c₃, hc₁, hc₂, hc₃, + ⟨#[c₂, c₃].foldl (fun b c => if tieredBetter c b then c else b) c₁, ?_, ?_⟩, ?_, ?_⟩ + · rcases hmem with h' | h' | h' <;> rw [h'] <;> simp + · rw [hr] + simp [hw₁, hw₂, hw₃] + · intro c hc + rw [hr] + exact hle c hc + · intro c hc heq + rw [hr] at heq ⊢ + exact htie c hc heq + +/-- On an expanded input the construction is that of its DAG and roots, +with the expansion statistics recorded (the encoding, the table terms and +the candidate statistics are those of `canonicalTieredCore`). -/ +theorem canonicalTiered_core {layout : ShareLayout} {limits : Limits} {ex : Expanded} + {r : TieredSharingResult} (h : canonicalTieredExpanded layout limits ex = .ok r) : + ∃ r₀, canonicalTieredCore layout limits ex.dag ex.roots = .ok r₀ ∧ + r = withExpansionStats ex r₀ ∧ r.stats = r₀.stats ∧ + r.result.sharing = r₀.result.sharing ∧ r.result.roots = r₀.result.roots ∧ + r.result.tableTerms = r₀.result.tableTerms ∧ r.phase1.stored = r₀.phase1.stored := by + unfold canonicalTieredExpanded at h + obtain ⟨r₀, hr₀, h⟩ := bind_eq_ok h + have hr := (Except.ok.inj h).symm + subst hr + exact ⟨r₀, hr₀, rfl, rfl, rfl, rfl, rfl, rfl⟩ + +end Ix.Compile.Verify.Tiered diff --git a/Ix/Compile/Verify/TieredTier.lean b/Ix/Compile/Verify/TieredTier.lean new file mode 100644 index 000000000..6066d68ab --- /dev/null +++ b/Ix/Compile/Verify/TieredTier.lean @@ -0,0 +1,1431 @@ +import Ix.Compile.Verify.TieredSelect + +/-! +# Tiered construction, phase 2: the first tier + +`firstTier topo weight deps cap` returns a set `F` of stored terms that is +closed under the dependency relation `deps` (here: the terms each phase-1 +body references), has at most `cap` terms, and has the maximum total weight +(here: reference count) among all such sets; among the maximum sets it is +the first in the tie order: order the stored terms by weight descending, +then ID ascending (`tierOrder`); at the first term in this order where two +sets differ, the chosen set contains it (`firstTier_spec`). + +The search is a depth-first branch and bound. Its correctness is stated +against the unpruned enumeration `tierLeaves`: every closed set is a leaf, +the leaves are in the tie order, and pruning only skips leaves that are no +heavier than the best set found so far. +-/ + +namespace Ix.Compile.Verify.Tiered + +open Ix.Sharing.Exact + +/-! ## Sets, weights and the tie order -/ + +/-- Total weight of a list of terms. -/ +def wsum (weight : Nat → Nat) (G : List Nat) : Nat := (G.map weight).sum + +/-- `x` is reachable from `t` along dependencies (reflexively). -/ +inductive DReach (deps : Nat → List Nat) : Nat → Nat → Prop + | refl (t : Nat) : DReach deps t t + | step {t d x : Nat} : d ∈ deps t → DReach deps d x → DReach deps t x + +/-- `G` contains the dependencies of its members. -/ +def Closed (deps : Nat → List Nat) (G : List Nat) : Prop := + ∀ u ∈ G, ∀ d ∈ deps u, d ∈ G + +/-- A first-tier candidate: stored terms without repeats, closed under +dependencies, at most `cap` of them. -/ +def Feasible (deps : Nat → List Nat) (items : List Nat) (cap : Nat) (G : List Nat) : Prop := + G.Nodup ∧ (∀ x ∈ G, x ∈ items) ∧ Closed deps G ∧ G.length ≤ cap + +/-- `A` precedes `B` in the tie order over `items`: at the first item where +they differ, `A` contains it. -/ +def PrecIn : List Nat → List Nat → List Nat → Prop + | [], _, _ => False + | t :: ts, A, B => (t ∈ A ∧ t ∉ B) ∨ ((t ∈ A ↔ t ∈ B) ∧ PrecIn ts A B) + +theorem PrecIn.congr {items A B A' B' : List Nat} (hA : ∀ x, x ∈ A ↔ x ∈ A') + (hB : ∀ x, x ∈ B ↔ x ∈ B') (h : PrecIn items A B) : PrecIn items A' B' := by + induction items with + | nil => exact h + | cons t ts ih => + rcases h with ⟨h1, h2⟩ | ⟨h1, h2⟩ + · exact Or.inl ⟨(hA t).mp h1, fun h => h2 ((hB t).mpr h)⟩ + · exact Or.inr ⟨by rw [← hA, ← hB]; exact h1, ih h2⟩ + +theorem PrecIn.irrefl {items A : List Nat} : ¬ PrecIn items A A := by + induction items with + | nil => exact id + | cons t ts ih => + rintro (⟨h1, h2⟩ | ⟨_, h2⟩) + · exact h2 h1 + · exact ih h2 + +theorem PrecIn.append {pre rest A B : List Nat} (hpre : ∀ x ∈ pre, x ∈ A ↔ x ∈ B) + (h : PrecIn rest A B) : PrecIn (pre ++ rest) A B := by + induction pre with + | nil => exact h + | cons t ts ih => + exact Or.inr ⟨hpre t List.mem_cons_self, + ih fun x hx => hpre x (List.mem_cons_of_mem _ hx)⟩ + +/-! ## The search bound -/ + +/-- The sum of the first `k` weights. -/ +def topSum (weight : Nat → Nat) : List Nat → Nat → Nat + | [], _ => 0 + | _ :: _, 0 => 0 + | a :: l, k + 1 => weight a + topSum weight l k + +theorem tierBound_eq (weight : Nat → Nat) (inF : List Nat) : + ∀ (rest : List Nat) (room acc : Nat), + tierBound weight inF rest room acc = + acc + topSum weight (rest.filter fun x => !inF.contains x) room := by + intro rest + induction rest with + | nil => intro room acc; simp [tierBound, topSum] + | cons t ts ih => + intro room acc + simp only [tierBound] + by_cases hr : room = 0 + · subst hr + simp only [if_true] + cases h : (t :: ts).filter (fun x => !inF.contains x) <;> simp [topSum] + · rw [if_neg hr] + by_cases hc : inF.contains t = true + · rw [if_pos hc, ih] + have hc' : t ∈ inF := by simpa using hc + simp [hc'] + · rw [if_neg hc, ih] + obtain ⟨r, rfl⟩ : ∃ r, room = r + 1 := ⟨room - 1, by omega⟩ + simp only [List.filter_cons, hc, Bool.not_false, if_true, topSum, + Nat.add_sub_cancel] + omega + +theorem topSum_succ_le (weight : Nat → Nat) {m : Nat} : + ∀ (l : List Nat) (k : Nat), (∀ x ∈ l, weight x ≤ m) → + topSum weight l (k + 1) ≤ m + topSum weight l k := by + intro l + induction l with + | nil => intro k _; simp [topSum] + | cons b l ih => + intro k hl + have hb := hl b List.mem_cons_self + cases k with + | zero => simp only [topSum]; have := ih 0 (fun x hx => hl x (List.mem_cons_of_mem _ hx)); cases l <;> simp_all [topSum] + | succ k => + simp only [topSum] + have := ih k (fun x hx => hl x (List.mem_cons_of_mem _ hx)) + omega + +theorem wsum_perm {weight : Nat → Nat} {A B : List Nat} (h : A.Perm B) : + wsum weight A = wsum weight B := (h.map weight).sum_nat + +theorem wsum_append (weight : Nat → Nat) (A B : List Nat) : + wsum weight (A ++ B) = wsum weight A + wsum weight B := by + simp [wsum] + +theorem wsum_cons (weight : Nat → Nat) (a : Nat) (A : List Nat) : + wsum weight (a :: A) = weight a + wsum weight A := by + simp [wsum] + +/-- Any `k` distinct members of a list in decreasing weight weigh at most its +first `k`. -/ +theorem wsum_le_topSum (weight : Nat → Nat) : + ∀ (L X : List Nat) (k : Nat), L.Pairwise (fun a b => weight b ≤ weight a) → L.Nodup → + X.Nodup → (∀ x ∈ X, x ∈ L) → X.length ≤ k → wsum weight X ≤ topSum weight L k := by + intro L + induction L with + | nil => + intro X k _ _ _ hsub _ + cases X with + | nil => simp [wsum, topSum] + | cons x _ => exact absurd (hsub x List.mem_cons_self) (by simp) + | cons a l ih => + intro X k hsort hnd hX hsub hlen + rw [List.pairwise_cons] at hsort + rw [List.nodup_cons] at hnd + cases k with + | zero => + have : X = [] := List.eq_nil_of_length_eq_zero (by omega) + subst this + simp [wsum, topSum] + | succ k => + simp only [topSum] + by_cases ha : a ∈ X + · have hperm := List.perm_cons_erase ha + rw [wsum_perm hperm, wsum_cons] + have hX' : (X.erase a).Nodup := hX.erase a + have hsub' : ∀ x ∈ X.erase a, x ∈ l := by + intro x hx + have hxa : x ≠ a := fun h => by subst h; exact (hX.not_mem_erase) hx + rcases List.mem_cons.mp (hsub x (List.mem_of_mem_erase hx)) with h | h + · exact absurd h hxa + · exact h + have hlen' : (X.erase a).length ≤ k := by + rw [List.length_erase_of_mem ha]; omega + have := ih (X.erase a) k hsort.2 hnd.2 hX' hsub' hlen' + omega + · have hsub' : ∀ x ∈ X, x ∈ l := by + intro x hx + rcases List.mem_cons.mp (hsub x hx) with h | h + · exact absurd (h ▸ hx) ha + · exact h + have h1 := ih X (k + 1) hsort.2 hnd.2 hX hsub' hlen + have h2 := topSum_succ_le weight l k hsort.1 + omega + +/-! ## Closures -/ + +/-- `L` lists the terms reachable from `t`, without repeats. -/ +def IsClosure (deps : Nat → List Nat) (t : Nat) (L : List Nat) : Prop := + L.Nodup ∧ ∀ x, x ∈ L ↔ DReach deps t x + +/-- More than `cap` terms are reachable from `t`. -/ +def Big (deps : Nat → List Nat) (cap t : Nat) : Prop := + ∃ L : List Nat, L.Nodup ∧ (∀ x ∈ L, DReach deps t x) ∧ cap < L.length + +/-- A computed closure entry: the closure if it has at most `cap` terms, +`none` if it has more. -/ +def ClosureOK (deps : Nat → List Nat) (cap : Nat) : Option (List Nat) → Nat → Prop + | some L, t => IsClosure deps t L ∧ L.length ≤ cap + | none, t => Big deps cap t + +theorem DReach.trans {deps : Nat → List Nat} {a b c : Nat} (h₁ : DReach deps a b) + (h₂ : DReach deps b c) : DReach deps a c := by + induction h₁ with + | refl => exact h₂ + | step hd _ ih => exact .step hd (ih h₂) + +theorem Big.of_dep {deps : Nat → List Nat} {cap t d : Nat} (hd : d ∈ deps t) + (h : Big deps cap d) : Big deps cap t := by + obtain ⟨L, hnd, hr, hlen⟩ := h + exact ⟨L, hnd, fun x hx => .step hd (hr x hx), hlen⟩ + +theorem Big.not_small {deps : Nat → List Nat} {cap t : Nat} (h : Big deps cap t) + {L : List Nat} (hL : IsClosure deps t L) : cap < L.length := by + obtain ⟨B, hnd, hr, hlen⟩ := h + have := hnd.length_le_of_subset fun x hx => (hL.2 x).mpr (hr x hx) + omega + +theorem foldl_insert_spec : + ∀ (c a : List Nat), a.Nodup → + (c.foldl (fun a x => a.insert x) a).Nodup ∧ + ∀ x, x ∈ c.foldl (fun a x => a.insert x) a ↔ x ∈ a ∨ x ∈ c := by + intro c + induction c with + | nil => intro a ha; simp [ha] + | cons y ys ih => + intro a ha + simp only [List.foldl_cons] + have hins : (a.insert y).Nodup := by + by_cases hy : y ∈ a + · rw [List.insert_of_mem hy]; exact ha + · rw [List.insert_of_not_mem hy]; exact List.nodup_cons.mpr ⟨hy, ha⟩ + obtain ⟨h1, h2⟩ := ih (a.insert y) hins + refine ⟨h1, fun x => ?_⟩ + rw [h2, List.mem_insert_iff, List.mem_cons] + constructor + · rintro ((h | h) | h) + · exact Or.inr (Or.inl h) + · exact Or.inl h + · exact Or.inr (Or.inr h) + · rintro (h | h | h) + · exact Or.inl (Or.inr h) + · exact Or.inl (Or.inl h) + · exact Or.inr h + +/-- The running partial closure of `t` after the dependencies `seen`. -/ +def AccOK (deps : Nat → List Nat) (cap t : Nat) (seen : List Nat) : Option (List Nat) → Prop + | some a => a.Nodup ∧ (∀ x ∈ a, DReach deps t x) ∧ t ∈ a ∧ + ∀ d ∈ seen, ∀ x, DReach deps d x → x ∈ a + | none => Big deps cap t + +theorem closureUnion_spec {deps : Nat → List Nat} {cap t : Nat} + {cl : Std.HashMap Nat (Option (List Nat))} + (hcl : ∀ d ∈ deps t, ClosureOK deps cap (cl.getD d none) d) : + ∀ (ds seen : List Nat) (acc : Option (List Nat)), (∀ d ∈ ds, d ∈ deps t) → + AccOK deps cap t seen acc → + AccOK deps cap t (seen ++ ds) (ds.foldl (tierClosureUnion cap cl) acc) := by + intro ds + induction ds with + | nil => intro seen acc _ h; simpa using h + | cons d ds ih => + intro seen acc hds hacc + simp only [List.foldl_cons] + have hd := hds d List.mem_cons_self + rw [show seen ++ d :: ds = (seen ++ [d]) ++ ds by simp] + apply ih _ _ (fun d' h => hds d' (List.mem_cons_of_mem _ h)) + have hok := hcl d hd + unfold tierClosureUnion + cases acc with + | none => exact hacc + | some a => + obtain ⟨hnd, hreach, hta, hseen⟩ := hacc + cases hc : cl.getD d none with + | none => + rw [hc] at hok + exact Big.of_dep hd hok + | some c => + rw [hc] at hok + obtain ⟨⟨hcnd, hcmem⟩, _⟩ := hok + obtain ⟨hund, humem⟩ := foldl_insert_spec c a hnd + simp only + split + · refine ⟨hund, fun x hx => ?_, (humem t).mpr (Or.inl hta), fun d' hd' x hx => ?_⟩ + · rcases (humem x).mp hx with h | h + · exact hreach x h + · exact .step hd ((hcmem x).mp h) + · rcases List.mem_append.mp hd' with h | h + · exact (humem x).mpr (Or.inl (hseen d' h x hx)) + · rw [List.mem_singleton] at h + subst h + exact (humem x).mpr (Or.inr ((hcmem x).mpr hx)) + · rename_i hlen + refine ⟨_, hund, fun x hx => ?_, by omega⟩ + rcases (humem x).mp hx with h | h + · exact hreach x h + · exact .step hd ((hcmem x).mp h) + +/-- The closure entry computed for `t` from its dependencies' entries. -/ +theorem closureEntry_spec {deps : Nat → List Nat} {cap t : Nat} + {cl : Std.HashMap Nat (Option (List Nat))} + (hcl : ∀ d ∈ deps t, ClosureOK deps cap (cl.getD d none) d) : + ClosureOK deps cap (((deps t).foldl (tierClosureUnion cap cl) (some [t])).bind + fun a => if a.length ≤ cap then some a else none) t := by + have hinit : AccOK deps cap t [] (some [t]) := + ⟨(by simp : [t].Nodup), fun x hx => by rw [List.mem_singleton] at hx; subst hx; exact .refl _, + List.mem_singleton_self t, fun _ h => absurd h (by simp)⟩ + have h := closureUnion_spec hcl (deps t) [] (some [t]) (fun _ h => h) hinit + simp only [List.nil_append] at h + generalize (deps t).foldl (tierClosureUnion cap cl) (some [t]) = acc at h + cases acc with + | none => exact h + | some a => + obtain ⟨hnd, hreach, hta, hall⟩ := h + simp only [Option.bind_some] + split + · rename_i hlen + refine ⟨⟨hnd, fun x => ⟨hreach x, fun hx => ?_⟩⟩, hlen⟩ + cases hx with + | refl => exact hta + | step hd hr => exact hall _ hd x hr + · rename_i hlen + exact ⟨a, hnd, hreach, by omega⟩ + +/-- The closures computed so far, for the terms `done`. -/ +def CInv (deps : Nat → List Nat) (cap : Nat) (cl : Std.HashMap Nat (Option (List Nat))) + (done : List Nat) : Prop := + (∀ x, cl.contains x = true ↔ x ∈ done) ∧ done.Nodup ∧ + (∀ x ∈ done, ClosureOK deps cap (cl.getD x none) x) ∧ ∀ x ∈ done, ∀ d ∈ deps x, d ∈ done + +theorem checkInternal_ok {b : Bool} {msg : String} {u : Unit} + (h : checkInternal b msg = .ok u) : b = true := by + unfold checkInternal at h + split at h + · assumption + · cases h + +theorem tierClosures_fold {deps : Nat → List Nat} {cap : Nat} : + ∀ (l done : List Nat) (cl cl' : Std.HashMap Nat (Option (List Nat))), + CInv deps cap cl done → + l.foldlM (fun cl t => do + checkInternal (!cl.contains t) "a stored term repeats in the phase-1 table" + checkInternal ((deps t).all cl.contains) "a phase-1 body references a later entry" + let acc := (deps t).foldl (tierClosureUnion cap cl) (some [t]) + return cl.insert t (acc.bind fun a => if a.length ≤ cap then some a else none)) + cl = .ok cl' → + CInv deps cap cl' (done ++ l) := by + intro l + induction l with + | nil => + intro done cl cl' hinv h + simp only [List.foldlM_nil] at h + cases h + simpa using hinv + | cons t ts ih => + intro done cl cl' hinv h + simp only [List.foldlM_cons] at h + obtain ⟨cl1, h1, h⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + obtain ⟨_, hc1, h1⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h1 + obtain ⟨_, hc2, h1⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h1 + have hnew := checkInternal_ok hc1 + have hdeps := checkInternal_ok hc2 + simp only [pure, Except.pure, Except.ok.injEq] at h1 + subst h1 + rw [show done ++ t :: ts = (done ++ [t]) ++ ts by simp] + apply ih _ _ _ _ h + obtain ⟨hcont, hnd, hok, hclosed⟩ := hinv + have htd : t ∉ done := by + intro ht + rw [← hcont] at ht + simp [ht] at hnew + have hdd : ∀ d ∈ deps t, d ∈ done := by + intro d hd + rw [List.all_eq_true] at hdeps + exact (hcont d).mp (hdeps d hd) + have hdok : ∀ d ∈ deps t, ClosureOK deps cap (cl.getD d none) d := + fun d hd => hok d (hdd d hd) + refine ⟨fun x => ?_, ?_, fun x hx => ?_, fun x hx d hd => ?_⟩ + · rw [Std.HashMap.contains_insert, Bool.or_eq_true, hcont, List.mem_append, + List.mem_singleton, beq_iff_eq] + constructor + · rintro (h | h) + · exact Or.inr h.symm + · exact Or.inl h + · rintro (h | h) + · exact Or.inr h + · exact Or.inl h.symm + · exact List.nodup_append.mpr ⟨hnd, (by simp : [t].Nodup), + fun a ha b hb => by rw [List.mem_singleton] at hb; subst hb; exact fun h => htd (h ▸ ha)⟩ + · rw [Std.HashMap.getD_insert] + rcases List.mem_append.mp hx with hx | hx + · have : (t == x) = false := by + rw [beq_eq_false_iff_ne]; exact fun h => htd (h ▸ hx) + rw [this] + exact hok x hx + · rw [List.mem_singleton] at hx + subst hx + simp only [beq_self_eq_true, if_true] + exact closureEntry_spec hdok + · rcases List.mem_append.mp hx with hx | hx + · exact List.mem_append_left _ (hclosed x hx d hd) + · rw [List.mem_singleton] at hx + subst hx + exact List.mem_append_left _ (hdd d hd) + +/-- **Closures.** A successful `tierClosures` saw every term once, every +dependency before its user, and computed the closure of every term (or +`none` when it has more than `cap` terms). -/ +theorem tierClosures_spec {topo : Array Nat} {deps : Nat → List Nat} {cap : Nat} + {cl : Std.HashMap Nat (Option (List Nat))} (h : tierClosures topo deps cap = .ok cl) : + topo.toList.Nodup ∧ (∀ t ∈ topo.toList, ClosureOK deps cap (cl.getD t none) t) ∧ + ∀ t ∈ topo.toList, ∀ d ∈ deps t, d ∈ topo.toList := by + unfold tierClosures at h + rw [← Array.foldlM_toList] at h + have hinit : CInv deps cap {} [] := + ⟨fun x => by simp, List.nodup_nil, fun _ h => absurd h (by simp), fun _ h => absurd h (by simp)⟩ + obtain ⟨_, hnd, hok, hclosed⟩ := tierClosures_fold _ [] {} cl hinit h + simp only [List.nil_append] at hnd hok hclosed + exact ⟨hnd, hok, hclosed⟩ + +/-! ## The unpruned search -/ + +/-- The leaves of the search below a node, in search order, without pruning: +`rest` are the undecided items, `inF` the chosen set and `ex` the excluded +terms. -/ +def tierLeaves (closure : Nat → Option (List Nat)) (cap : Nat) : + List Nat → List Nat → List Nat → List (List Nat) + | [], inF, _ => [inF] + | t :: ts, inF, ex => + if inF.contains t then tierLeaves closure cap ts inF ex + else + (match closure t with + | some c => + if !c.any ex.contains && inF.length + (c.filter (!inF.contains ·)).length ≤ cap then + tierLeaves closure cap ts (inF ++ c.filter (!inF.contains ·)) ex + else [] + | none => []) ++ tierLeaves closure cap ts inF (t :: ex) + +/-- The global facts of a search: distinct items, a correct closure for every +item, and dependencies among the items. -/ +structure Ctx (deps : Nat → List Nat) (closure : Nat → Option (List Nat)) (cap : Nat) + (items : List Nat) : Prop where + nodup : items.Nodup + closure : ∀ t ∈ items, ClosureOK deps cap (closure t) t + deps : ∀ t ∈ items, ∀ d ∈ deps t, d ∈ items + +/-- The local facts of a search node: the decided items `pre` are chosen or +excluded, the chosen set is a closed set of items without repeats. -/ +def Inv (deps : Nat → List Nat) (items : List Nat) (cap : Nat) (pre inF ex : List Nat) : Prop := + inF.Nodup ∧ inF.length ≤ cap ∧ (∀ x ∈ pre, x ∈ inF ∨ x ∈ ex) ∧ (∀ x ∈ ex, x ∉ inF) ∧ + (∀ x ∈ inF, x ∈ items) ∧ Closed deps inF + +theorem Ctx.reach {deps : Nat → List Nat} {closure : Nat → Option (List Nat)} {cap : Nat} + {items : List Nat} (hc : Ctx deps closure cap items) {t x : Nat} (ht : t ∈ items) + (h : DReach deps t x) : x ∈ items := by + induction h with + | refl => exact ht + | step hd _ ih => exact ih (hc.deps _ ht _ hd) + +theorem contains_iff {l : List Nat} {x : Nat} : l.contains x = true ↔ x ∈ l := by simp + +theorem mem_split {pre rest : List Nat} {x : Nat} (h : x ∈ pre ++ rest) (hx : x ∉ pre) : + x ∈ rest := by + rcases List.mem_append.mp h with h | h + · exact absurd h hx + · exact h + +/-- The include step: the closure of `t` joins the chosen set. -/ +theorem Inv.include {deps : Nat → List Nat} {closure : Nat → Option (List Nat)} {cap : Nat} + {items : List Nat} (hctx : Ctx deps closure cap items) {pre inF ex : List Nat} {t : Nat} + {ts c : List Nat} (hinv : Inv deps items cap pre inF ex) (hitems : items = pre ++ t :: ts) + (ht : t ∉ inF) (hc : closure t = some c) (hex : c.any ex.contains = false) + (hlen : inF.length + (c.filter (!inF.contains ·)).length ≤ cap) : + Inv deps items cap (pre ++ [t]) (inF ++ c.filter (!inF.contains ·)) ex ∧ + (c.filter (!inF.contains ·)).Nodup ∧ t ∈ c.filter (!inF.contains ·) ∧ + ∀ x ∈ c.filter (!inF.contains ·), x ∈ t :: ts ∧ x ∉ inF := by + obtain ⟨hnd, _, hpre, hexF, hitm, hcl⟩ := hinv + have htI : t ∈ items := by rw [hitems]; simp + have hok := hctx.closure t htI + rw [hc] at hok + obtain ⟨⟨hcnd, hcmem⟩, _⟩ := hok + have hcex : ∀ x ∈ c, x ∉ ex := by + intro x hx hxe + have : c.any ex.contains = true := List.any_eq_true.mpr ⟨x, hx, contains_iff.mpr hxe⟩ + rw [hex] at this + cases this + have hcI : ∀ x ∈ c, x ∈ items := fun x hx => hctx.reach htI ((hcmem x).mp hx) + have hmemN : ∀ x, x ∈ c.filter (!inF.contains ·) ↔ x ∈ c ∧ x ∉ inF := by + intro x + simp + have hnew : ∀ x ∈ c.filter (!inF.contains ·), x ∈ t :: ts ∧ x ∉ inF := by + intro x hx + obtain ⟨hxc, hxi⟩ := (hmemN x).mp hx + refine ⟨mem_split (hitems ▸ hcI x hxc) fun hxp => ?_, hxi⟩ + rcases hpre x hxp with h | h + · exact hxi h + · exact hcex x hxc h + have htc : t ∈ c := (hcmem t).mpr (.refl t) + have htN : t ∈ c.filter (!inF.contains ·) := (hmemN t).mpr ⟨htc, ht⟩ + have hNnd : (c.filter (!inF.contains ·)).Nodup := hcnd.filter _ + refine ⟨⟨?_, by simp only [List.length_append]; omega, fun x hx => ?_, fun x hx hxi => ?_, + fun x hx => ?_, fun u hu d hd => ?_⟩, hNnd, htN, hnew⟩ + · exact List.nodup_append.mpr ⟨hnd, hNnd, fun a ha b hb hab => ((hmemN b).mp hb).2 (hab ▸ ha)⟩ + · rcases List.mem_append.mp hx with hx | hx + · rcases hpre x hx with h | h + · exact Or.inl (List.mem_append_left _ h) + · exact Or.inr h + · rw [List.mem_singleton] at hx + subst hx + exact Or.inl (List.mem_append_right _ htN) + · rcases List.mem_append.mp hxi with h | h + · exact hexF x hx h + · exact hcex x ((hmemN x).mp h).1 hx + · rcases List.mem_append.mp hx with h | h + · exact hitm x h + · exact hcI x ((hmemN x).mp h).1 + · rcases List.mem_append.mp hu with h | h + · exact List.mem_append_left _ (hcl u h d hd) + · have hdc : d ∈ c := (hcmem d).mpr + (((hcmem u).mp ((hmemN u).mp h).1).trans (.step hd (.refl d))) + by_cases hdi : d ∈ inF + · exact List.mem_append_left _ hdi + · exact List.mem_append_right _ ((hmemN d).mpr ⟨hdc, hdi⟩) + +theorem Inv.exclude {deps : Nat → List Nat} {items : List Nat} {cap : Nat} + {pre inF ex : List Nat} {t : Nat} (hinv : Inv deps items cap pre inF ex) (ht : t ∉ inF) : + Inv deps items cap (pre ++ [t]) inF (t :: ex) := by + obtain ⟨hnd, hlen, hpre, hexF, hitm, hcl⟩ := hinv + refine ⟨hnd, hlen, fun x hx => ?_, fun x hx => ?_, hitm, hcl⟩ + · rcases List.mem_append.mp hx with hx | hx + · rcases hpre x hx with h | h + · exact Or.inl h + · exact Or.inr (List.mem_cons_of_mem _ h) + · rw [List.mem_singleton] at hx + exact Or.inr (hx ▸ List.mem_cons_self) + · rcases List.mem_cons.mp hx with h | h + · exact h ▸ ht + · exact hexF x h + +theorem Inv.skip {deps : Nat → List Nat} {items : List Nat} {cap : Nat} + {pre inF ex : List Nat} {t : Nat} (hinv : Inv deps items cap pre inF ex) (ht : t ∈ inF) : + Inv deps items cap (pre ++ [t]) inF ex := by + obtain ⟨hnd, hlen, hpre, hexF, hitm, hcl⟩ := hinv + refine ⟨hnd, hlen, fun x hx => ?_, hexF, hitm, hcl⟩ + rcases List.mem_append.mp hx with hx | hx + · exact hpre x hx + · rw [List.mem_singleton] at hx + exact Or.inl (hx ▸ ht) + +/-- The facts of a leaf: a closed set of at most `cap` items without repeats +avoiding the excluded terms. -/ +def LeafOK (deps : Nat → List Nat) (items : List Nat) (cap : Nat) (F ex : List Nat) : Prop := + F.Nodup ∧ F.length ≤ cap ∧ (∀ x ∈ ex, x ∉ F) ∧ (∀ x ∈ F, x ∈ items) ∧ Closed deps F + +/-- **Leaves.** Every leaf extends the chosen set by distinct undecided items +to a closed set of at most `cap` items avoiding the excluded terms. -/ +theorem leaves_shape {deps : Nat → List Nat} {closure : Nat → Option (List Nat)} {cap : Nat} + {items : List Nat} (hctx : Ctx deps closure cap items) : + ∀ (rest pre inF ex : List Nat), items = pre ++ rest → Inv deps items cap pre inF ex → + ∀ F ∈ tierLeaves closure cap rest inF ex, + ∃ X, F = inF ++ X ∧ X.Nodup ∧ (∀ x ∈ X, x ∈ rest ∧ x ∉ inF) ∧ + LeafOK deps items cap F ex := by + intro rest + induction rest with + | nil => + intro pre inF ex hitems hinv F hF + simp only [tierLeaves, List.mem_singleton] at hF + subst hF + simp only [List.append_nil] at hitems + subst hitems + obtain ⟨h1, h2, _, h4, h5, h6⟩ := hinv + exact ⟨[], by simp, List.nodup_nil, by simp, h1, h2, h4, h5, h6⟩ + | cons t ts ih => + intro pre inF ex hitems hinv F hF + have hitems' : items = (pre ++ [t]) ++ ts := by rw [hitems]; simp + simp only [tierLeaves] at hF + by_cases ht : inF.contains t = true + · rw [if_pos ht] at hF + obtain ⟨X, rfl, hX, hXr, hfin⟩ := ih _ _ _ hitems' (hinv.skip (contains_iff.mp ht)) F hF + exact ⟨X, rfl, hX, fun x hx => ⟨List.mem_cons_of_mem _ (hXr x hx).1, (hXr x hx).2⟩, hfin⟩ + · have ht' : t ∉ inF := fun h => ht (contains_iff.mpr h) + rw [if_neg ht] at hF + rcases List.mem_append.mp hF with hI | hE + · cases hc : closure t with + | none => rw [hc] at hI; cases hI + | some c => + rw [hc] at hI + simp only at hI + split at hI + · rename_i hcond + simp only [Bool.and_eq_true, Bool.not_eq_true', decide_eq_true_eq] at hcond + obtain ⟨hinv', hNnd, _, hnew⟩ := + hinv.include hctx hitems ht' hc hcond.1 hcond.2 + obtain ⟨X, rfl, hX, hXr, hfin⟩ := ih _ _ _ hitems' hinv' F hI + refine ⟨c.filter (!inF.contains ·) ++ X, by simp, ?_, fun x hx => ?_, hfin⟩ + · refine List.nodup_append.mpr ⟨hNnd, hX, fun a ha b hb hab => ?_⟩ + exact (hXr b hb).2 (List.mem_append_right _ (hab ▸ ha)) + · rcases List.mem_append.mp hx with h | h + · exact hnew x h + · exact ⟨List.mem_cons_of_mem _ (hXr x h).1, + fun hi => (hXr x h).2 (List.mem_append_left _ hi)⟩ + · cases hI + · obtain ⟨X, rfl, hX, hXr, ⟨h1, h2, h3, h4, h5⟩⟩ := + ih _ _ _ hitems' (hinv.exclude ht') F hE + refine ⟨X, rfl, hX, fun x hx => ⟨List.mem_cons_of_mem _ (hXr x hx).1, (hXr x hx).2⟩, + ⟨h1, h2, fun x hx => h3 x (List.mem_cons_of_mem _ hx), h4, h5⟩⟩ + +/-- **Bound.** Every leaf weighs at most the search bound of its node. -/ +theorem leaves_bound {deps : Nat → List Nat} {closure : Nat → Option (List Nat)} {cap : Nat} + {items : List Nat} (hctx : Ctx deps closure cap items) (weight : Nat → Nat) + (hsort : items.Pairwise fun a b => weight b ≤ weight a) + {rest pre inF ex : List Nat} (hitems : items = pre ++ rest) + (hinv : Inv deps items cap pre inF ex) : + ∀ F ∈ tierLeaves closure cap rest inF ex, + wsum weight F ≤ tierBound weight inF rest (cap - inF.length) (wsum weight inF) := by + intro F hF + obtain ⟨X, rfl, hX, hXr, hleaf⟩ := leaves_shape hctx rest pre inF ex hitems hinv F hF + rw [tierBound_eq, wsum_append] + have hrest : rest.Pairwise (fun a b => weight b ≤ weight a) ∧ rest.Nodup := by + have h1 := hctx.nodup + rw [hitems] at hsort h1 + exact ⟨(List.pairwise_append.mp hsort).2.1, (List.nodup_append.mp h1).2.1⟩ + have hlen : X.length ≤ cap - inF.length := by + have := hleaf.2.1 + simp only [List.length_append] at this + omega + have := wsum_le_topSum weight (rest.filter fun x => !inF.contains x) X (cap - inF.length) + (hrest.1.filter _) (hrest.2.filter _) hX + (fun x hx => List.mem_filter.mpr ⟨(hXr x hx).1, by simpa using (hXr x hx).2⟩) hlen + omega + +/-- A closed set contains everything reachable from its members. -/ +theorem Closed.reach {deps : Nat → List Nat} {G : List Nat} (hG : Closed deps G) {t x : Nat} + (ht : t ∈ G) (h : DReach deps t x) : x ∈ G := by + induction h with + | refl => exact ht + | step hd _ ih => exact ih (hG _ ht _ hd) + +/-- **Completeness.** Every feasible set compatible with a node's decisions +is (up to order) a leaf below it. -/ +theorem leaves_complete {deps : Nat → List Nat} {closure : Nat → Option (List Nat)} {cap : Nat} + {items : List Nat} (hctx : Ctx deps closure cap items) {G : List Nat} + (hG : Feasible deps items cap G) : + ∀ (rest pre inF ex : List Nat), items = pre ++ rest → Inv deps items cap pre inF ex → + (∀ x ∈ inF, x ∈ G) → (∀ x ∈ ex, x ∉ G) → (∀ x ∈ pre, x ∈ G → x ∈ inF) → + ∃ F ∈ tierLeaves closure cap rest inF ex, ∀ x, x ∈ F ↔ x ∈ G := by + obtain ⟨hGnd, hGitems, hGcl, hGlen⟩ := hG + intro rest + induction rest with + | nil => + intro pre inF ex hitems _ hin _ hpre + simp only [List.append_nil] at hitems + subst hitems + exact ⟨inF, by simp [tierLeaves], fun x => ⟨hin x, fun hx => hpre x (hGitems x hx) hx⟩⟩ + | cons t ts ih => + intro pre inF ex hitems hinv hin hex hpre + have hitems' : items = (pre ++ [t]) ++ ts := by rw [hitems]; simp + simp only [tierLeaves] + by_cases ht : inF.contains t = true + · rw [if_pos ht] + have ht' := contains_iff.mp ht + refine ih _ _ _ hitems' (hinv.skip ht') hin hex fun x hx hxG => ?_ + rcases List.mem_append.mp hx with h | h + · exact hpre x h hxG + · rw [List.mem_singleton] at h; exact h ▸ ht' + · have ht' : t ∉ inF := fun h => ht (contains_iff.mpr h) + rw [if_neg ht] + have htI : t ∈ items := by rw [hitems]; simp + by_cases htG : t ∈ G + · -- include + have hok := hctx.closure t htI + cases hc : closure t with + | none => + rw [hc] at hok + obtain ⟨L, hLnd, hLr, hLlen⟩ := hok + have := hLnd.length_le_of_subset fun x hx => hGcl.reach htG (hLr x hx) + omega + | some c => + rw [hc] at hok + obtain ⟨⟨hcnd, hcmem⟩, _⟩ := hok + have hcG : ∀ x ∈ c, x ∈ G := fun x hx => hGcl.reach htG ((hcmem x).mp hx) + have hex' : c.any ex.contains = false := by + rw [Bool.eq_false_iff] + intro h + obtain ⟨x, hx, hxe⟩ := List.any_eq_true.mp h + exact hex x (contains_iff.mp hxe) (hcG x hx) + have hlen : inF.length + (c.filter (!inF.contains ·)).length ≤ cap := by + have hnd : (inF ++ c.filter (!inF.contains ·)).Nodup := + List.nodup_append.mpr ⟨hinv.1, hcnd.filter _, fun a ha b hb hab => by + have hb' := (List.mem_filter.mp hb).2 + simp only [Bool.not_eq_true'] at hb' + exact (by simpa using hb' : b ∉ inF) (hab ▸ ha)⟩ + have := hnd.length_le_of_subset fun x hx => by + rcases List.mem_append.mp hx with h | h + · exact hin x h + · exact hcG x (List.mem_filter.mp h).1 + simp only [List.length_append] at this + omega + obtain ⟨hinv', _, htN, _⟩ := hinv.include hctx hitems ht' hc hex' hlen + have hcond : (!c.any ex.contains && decide (inF.length + + (c.filter (!inF.contains ·)).length ≤ cap)) = true := by + rw [hex']; simpa using hlen + obtain ⟨F, hF, hFG⟩ := ih _ _ _ hitems' hinv' + (fun x hx => by + rcases List.mem_append.mp hx with h | h + · exact hin x h + · exact hcG x (List.mem_filter.mp h).1) + hex (fun x hx hxG => by + rcases List.mem_append.mp hx with h | h + · exact List.mem_append_left _ (hpre x h hxG) + · rw [List.mem_singleton] at h; subst h + exact List.mem_append_right _ htN) + refine ⟨F, List.mem_append_left _ ?_, hFG⟩ + dsimp only + rw [if_pos hcond] + exact hF + · -- exclude + obtain ⟨F, hF, hFG⟩ := ih _ _ _ hitems' (hinv.exclude ht') hin + (fun x hx => by + rcases List.mem_cons.mp hx with h | h + · exact h ▸ htG + · exact hex x h) + (fun x hx hxG => by + rcases List.mem_append.mp hx with h | h + · exact hpre x h hxG + · rw [List.mem_singleton] at h; exact absurd (h ▸ hxG) htG) + exact ⟨F, List.mem_append_right _ hF, hFG⟩ + +/-- **Order.** The leaves come in the tie order. -/ +theorem leaves_order {deps : Nat → List Nat} {closure : Nat → Option (List Nat)} {cap : Nat} + {items : List Nat} (hctx : Ctx deps closure cap items) : + ∀ (rest pre inF ex : List Nat), items = pre ++ rest → Inv deps items cap pre inF ex → + (tierLeaves closure cap rest inF ex).Pairwise (PrecIn rest) := by + intro rest + induction rest with + | nil => intro _ inF _ _ _; simp [tierLeaves] + | cons t ts ih => + intro pre inF ex hitems hinv + have hitems' : items = (pre ++ [t]) ++ ts := by rw [hitems]; simp + simp only [tierLeaves] + by_cases ht : inF.contains t = true + · rw [if_pos ht] + have ht' := contains_iff.mp ht + have hsub := ih _ _ _ hitems' (hinv.skip ht') + refine hsub.imp_of_mem fun {A B} hA hB hAB => Or.inr ⟨?_, hAB⟩ + obtain ⟨X, rfl, -⟩ := leaves_shape hctx ts _ _ _ hitems' (hinv.skip ht') A hA + obtain ⟨Y, rfl, -⟩ := leaves_shape hctx ts _ _ _ hitems' (hinv.skip ht') B hB + exact iff_of_true (List.mem_append_left _ ht') (List.mem_append_left _ ht') + · have ht' : t ∉ inF := fun h => ht (contains_iff.mpr h) + rw [if_neg ht] + have hE := ih _ _ _ hitems' (hinv.exclude ht') + have hEt : ∀ B ∈ tierLeaves closure cap ts inF (t :: ex), t ∉ B := by + intro B hB + obtain ⟨_, _, _, _, ⟨_, _, hav, _⟩⟩ := + leaves_shape hctx ts _ _ _ hitems' (hinv.exclude ht') B hB + exact hav t List.mem_cons_self + -- the include part + have hI : ∀ (I : List (List Nat)), (I = match closure t with + | some c => + if (!c.any ex.contains && decide (inF.length + + (c.filter (!inF.contains ·)).length ≤ cap)) = true then + tierLeaves closure cap ts (inF ++ c.filter (!inF.contains ·)) ex + else [] + | none => []) → + I.Pairwise (PrecIn (t :: ts)) ∧ ∀ A ∈ I, t ∈ A := by + intro I hIdef + cases hc : closure t with + | none => rw [hc] at hIdef; subst hIdef; simp + | some c => + rw [hc] at hIdef + dsimp only at hIdef + split at hIdef + · rename_i hcond + simp only [Bool.and_eq_true, Bool.not_eq_true', decide_eq_true_eq] at hcond + obtain ⟨hinv', _, htN, _⟩ := hinv.include hctx hitems ht' hc hcond.1 hcond.2 + subst hIdef + have hin : ∀ A ∈ tierLeaves closure cap ts (inF ++ c.filter (!inF.contains ·)) ex, + t ∈ A := by + intro A hA + obtain ⟨X, rfl, -⟩ := leaves_shape hctx ts _ _ _ hitems' hinv' A hA + exact List.mem_append_left _ (List.mem_append_right _ htN) + refine ⟨(ih _ _ _ hitems' hinv').imp_of_mem fun {A B} hA hB hAB => + Or.inr ⟨iff_of_true (hin A hA) (hin B hB), hAB⟩, hin⟩ + · subst hIdef; simp + obtain ⟨hIp, hIt⟩ := hI _ rfl + refine List.pairwise_append.mpr ⟨hIp, hE.imp_of_mem fun {A B} hA hB hAB => + Or.inr ⟨iff_of_false (hEt A hA) (hEt B hB), hAB⟩, fun A hA B hB => ?_⟩ + exact Or.inl ⟨hIt A hA, hEt B hB⟩ + +theorem leaves_ne_nil (closure : Nat → Option (List Nat)) (cap : Nat) : + ∀ (rest inF ex : List Nat), tierLeaves closure cap rest inF ex ≠ [] := by + intro rest + induction rest with + | nil => intro _ _; simp [tierLeaves] + | cons t ts ih => + intro inF ex + simp only [tierLeaves] + split + · exact ih _ _ + · intro h + exact ih inF (t :: ex) (List.append_eq_nil_iff.mp h).2 + +/-! ## The best leaf -/ + +/-- The search's update at a leaf. -/ +def leafUpd (weight : Nat → Nat) (best : Option (Nat × List Nat)) (F : List Nat) : + Option (Nat × List Nat) := + tierUpd best (wsum weight F) F + +theorem fold_noop (weight : Nat → Nat) {b : Nat} {B : List Nat} : + ∀ (L : List (List Nat)), (∀ F ∈ L, wsum weight F ≤ b) → + L.foldl (leafUpd weight) (some (b, B)) = some (b, B) := by + intro L + induction L with + | nil => intro _; rfl + | cons F L ih => + intro h + simp only [List.foldl_cons, leafUpd, tierUpd] + rw [if_neg (by have := h F List.mem_cons_self; omega)] + exact ih fun G hG => h G (List.mem_cons_of_mem _ hG) + +/-- The fold over the leaves keeps the first heaviest leaf. -/ +theorem fold_best (weight : Nat → Nat) (items : List Nat) : + ∀ (L : List (List Nat)) (init : Option (Nat × List Nat)), L.Pairwise (PrecIn items) → + (∀ b R, init = some (b, R) → b = wsum weight R ∧ ∀ G ∈ L, PrecIn items R G) → + ((init ≠ none ∨ L ≠ []) → L.foldl (leafUpd weight) init ≠ none) ∧ + ∀ b R, L.foldl (leafUpd weight) init = some (b, R) → + b = wsum weight R ∧ (R ∈ L ∨ init = some (b, R)) ∧ (∀ G ∈ L, wsum weight G ≤ b) ∧ + (∀ b0 R0, init = some (b0, R0) → b0 ≤ b ∧ (b0 = b → R0 = R)) ∧ + (∀ G ∈ L, wsum weight G = b → G = R ∨ PrecIn items R G) := by + intro L + induction L with + | nil => + intro init _ hinit + refine ⟨fun h => by simpa using h, fun b R h => ?_⟩ + simp only [List.foldl_nil] at h + subst h + exact ⟨(hinit b R rfl).1, Or.inr rfl, by simp, fun b0 R0 h => by + simp only [Option.some.injEq, Prod.mk.injEq] at h + exact ⟨by omega, fun _ => h.2.symm⟩, by simp⟩ + | cons F L ih => + intro init hpw hinit + rw [List.pairwise_cons] at hpw + simp only [List.foldl_cons] + -- the state after `F` + have hstep : ∀ b' R', leafUpd weight init F = some (b', R') → + b' = wsum weight R' ∧ (∀ G ∈ L, PrecIn items R' G) ∧ wsum weight F ≤ b' ∧ + ((R' = F ∧ b' = wsum weight F) ∨ init = some (b', R')) ∧ + (∀ b0 R0, init = some (b0, R0) → b0 ≤ b' ∧ (b0 = b' → R0 = R')) ∧ + (wsum weight F = b' → F = R' ∨ PrecIn items R' F) := by + intro b' R' h + unfold leafUpd tierUpd at h + cases init with + | none => + simp only [Option.some.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + exact ⟨rfl, hpw.1, Nat.le_refl _, Or.inl ⟨rfl, rfl⟩, (fun _ _ h => nomatch h), + fun _ => Or.inl rfl⟩ + | some bR => + obtain ⟨b0, R0⟩ := bR + obtain ⟨hb0, hR0⟩ := hinit b0 R0 rfl + simp only at h + split at h + · rename_i hgt + simp only [Option.some.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + exact ⟨rfl, hpw.1, Nat.le_refl _, Or.inl ⟨rfl, rfl⟩, + fun b1 R1 h1 => by + simp only [Option.some.injEq, Prod.mk.injEq] at h1 + obtain ⟨rfl, rfl⟩ := h1 + exact ⟨by omega, fun h => by omega⟩, + fun _ => Or.inl rfl⟩ + · rename_i hle + simp only [Option.some.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + exact ⟨hb0, fun G hG => hR0 G (List.mem_cons_of_mem _ hG), by omega, Or.inr rfl, + fun b1 R1 h1 => by + simp only [Option.some.injEq, Prod.mk.injEq] at h1 + obtain ⟨rfl, rfl⟩ := h1 + exact ⟨Nat.le_refl _, fun _ => rfl⟩, + fun _ => Or.inr (hR0 F List.mem_cons_self)⟩ + have hsome : leafUpd weight init F ≠ none := by + unfold leafUpd tierUpd + cases init with + | none => simp + | some bR => obtain ⟨b0, R0⟩ := bR; simp only; split <;> simp + obtain ⟨hne, hres⟩ := ih (leafUpd weight init F) hpw.2 (fun b' R' h => + ⟨(hstep b' R' h).1, (hstep b' R' h).2.1⟩) + refine ⟨fun _ => hne (Or.inl hsome), fun b R h => ?_⟩ + obtain ⟨b', R', hbR'⟩ : ∃ b' R', leafUpd weight init F = some (b', R') := by + cases h' : leafUpd weight init F with + | none => exact absurd h' hsome + | some p => exact ⟨p.1, p.2, rfl⟩ + obtain ⟨hbw, hmem, hle, hmono, htie⟩ := hres b R h + obtain ⟨_, _, hFle, hsrc, hmono', htieF⟩ := hstep b' R' hbR' + obtain ⟨hb'b, hb'R⟩ := hmono b' R' hbR' + refine ⟨hbw, ?_, ?_, ?_, ?_⟩ + · rcases hmem with h1 | h1 + · exact Or.inl (List.mem_cons_of_mem _ h1) + · rw [hbR'] at h1 + simp only [Option.some.injEq, Prod.mk.injEq] at h1 + obtain ⟨rfl, rfl⟩ := h1 + rcases hsrc with ⟨rfl, _⟩ | h2 + · exact Or.inl List.mem_cons_self + · exact Or.inr h2 + · intro G hG + rcases List.mem_cons.mp hG with rfl | hG + · omega + · exact hle G hG + · intro b0 R0 h0 + obtain ⟨h1, h2⟩ := hmono' b0 R0 h0 + exact ⟨by omega, fun h => by rw [h2 (by omega)]; exact hb'R (by omega)⟩ + · intro G hG hGb + rcases List.mem_cons.mp hG with rfl | hG + · have : wsum weight G = b' := by omega + rw [← hb'R (by omega)] + exact htieF this + · exact htie G hG hGb + +/-! ## The pruned search -/ + +theorem foldl_weight (weight : Nat → Nat) : + ∀ (l : List Nat) (cur : Nat), l.foldl (fun acc u => acc + weight u) cur = cur + wsum weight l := by + intro l + induction l with + | nil => intro cur; simp [wsum] + | cons a l ih => intro cur; simp only [List.foldl_cons, ih, wsum_cons]; omega + +/-- **Search.** A successful run from a node folds the best-set update over +the node's leaves in search order: pruning skips only leaves no heavier +than the best set. -/ +theorem tierDfs_spec {deps : Nat → List Nat} {closure : Nat → Option (List Nat)} {cap : Nat} + {items : Array Nat} (hctx : Ctx deps closure cap items.toList) (weight : Nat → Nat) + (hsort : items.toList.Pairwise fun a b => weight b ≤ weight a) (limits : Limits) : + ∀ (fuel pos cur : Nat) (inF : List Nat) (excluded : Std.HashSet Nat) (ex : List Nat) + (st st' : TierState), + cur = wsum weight inF → (∀ u, excluded.contains u = true ↔ u ∈ ex) → + Inv deps items.toList cap (items.toList.take pos) inF ex → + tierDfs items weight closure cap limits fuel pos cur inF excluded st = .ok st' → + st'.best = (tierLeaves closure cap (items.toList.drop pos) inF ex).foldl + (leafUpd weight) st.best := by + intro fuel + induction fuel with + | zero => intro _ _ _ _ _ _ _ _ _ _ h; unfold tierDfs at h; cases h + | succ fuel ih => + intro pos cur inF excluded ex st st' hcur hex hinv h + have hsplit := (List.take_append_drop pos items.toList).symm + rw [tierDfs] at h + split at h + · cases h + · dsimp only at h + split at h + · -- pruned + rename_i hpr + simp only [pure, Except.pure, Except.ok.injEq] at h + subst h + simp only + unfold tierPruned at hpr + split at hpr + · rename_i b B hbB + rw [hbB] + refine (fold_noop weight _ fun F hF => ?_).symm + have := leaves_bound hctx weight hsort hsplit hinv F hF + rw [← hcur] at this + simp only [decide_eq_true_eq] at hpr + omega + · cases hpr + · split at h + · -- a leaf + rename_i _ hpos + simp only [pure, Except.pure, Except.ok.injEq] at h + subst h + rw [List.drop_eq_nil_of_le (by simpa using hpos)] + simp [tierLeaves, leafUpd, hcur] + · rename_i _ hpos + have hlt : pos < items.toList.length := by simp; omega + have hdrop : items.toList.drop pos = items[pos]! :: items.toList.drop (pos + 1) := by + rw [List.drop_eq_getElem_cons hlt] + simp [getElem!_pos items pos (by simpa using hlt)] + have htake : items.toList.take (pos + 1) = items.toList.take pos ++ [items[pos]!] := by + rw [List.take_succ_eq_append_getElem hlt] + simp [getElem!_pos items pos (by simpa using hlt)] + have hitems : items.toList = items.toList.take pos ++ items[pos]! :: + items.toList.drop (pos + 1) := by rw [← hdrop]; exact hsplit + rw [hdrop] + simp only [tierLeaves] + generalize hst1 : ({ st with states := st.states + 1 } : TierState) = st1 at h + have hb1 : st1.best = st.best := by rw [← hst1] + split at h + · rename_i hin + rw [if_pos hin, ← hb1] + refine ih _ _ _ _ _ _ _ hcur hex ?_ h + rw [htake] + exact hinv.skip (contains_iff.mp hin) + · rename_i hin + rw [if_neg hin, List.foldl_append] + have ht' : items[pos]! ∉ inF := fun h => hin (contains_iff.mpr h) + have hex' : ∀ u, (excluded.insert items[pos]!).contains u = true ↔ + u ∈ items[pos]! :: ex := by + intro u + rw [Std.HashSet.contains_insert, Bool.or_eq_true, hex, beq_iff_eq, List.mem_cons] + constructor + · rintro (h | h) + · exact Or.inl h.symm + · exact Or.inr h + · rintro (h | h) + · exact Or.inl h.symm + · exact Or.inr h + have hinvE : Inv deps items.toList cap (items.toList.take (pos + 1)) inF + (items[pos]! :: ex) := by rw [htake]; exact hinv.exclude ht' + have hany : ∀ c : List Nat, c.any excluded.contains = c.any ex.contains := by + intro c + rw [Bool.eq_iff_iff, List.any_eq_true, List.any_eq_true] + constructor + · rintro ⟨u, hu, h⟩; exact ⟨u, hu, contains_iff.mpr ((hex u).mp h)⟩ + · rintro ⟨u, hu, h⟩; exact ⟨u, hu, (hex u).mpr (contains_iff.mp h)⟩ + cases hc : closure items[pos]! with + | none => + rw [hc] at h + obtain ⟨st2, hst2, h⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + simp only [pure, Except.pure, Except.ok.injEq] at hst2 + subst hst2 + rw [ih _ _ _ _ _ _ _ hcur hex' hinvE h, hb1] + rfl + | some c => + rw [hc] at h + dsimp only at h ⊢ + rw [hany c] at h + split at h + · rename_i hcond + rw [if_pos hcond] + obtain ⟨st2, hst2, h⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + simp only [Bool.and_eq_true, Bool.not_eq_true', decide_eq_true_eq] at hcond + obtain ⟨hinv', -⟩ := hinv.include hctx hitems ht' hc hcond.1 hcond.2 + rw [ih _ _ _ _ _ _ _ hcur hex' hinvE h, + ih _ _ _ _ _ _ _ (by rw [foldl_weight, hcur, wsum_append]) hex + (by rw [htake]; exact hinv') hst2, hb1] + · rename_i hcond + rw [if_neg hcond] + obtain ⟨st2, hst2, h⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + simp only [pure, Except.pure, Except.ok.injEq] at hst2 + subst hst2 + rw [ih _ _ _ _ _ _ _ hcur hex' hinvE h, hb1] + rfl + +/-! ## The first tier -/ + +theorem tierOrder_trans (weight : Nat → Nat) (a b c : Nat) (h₁ : tierOrder weight a b = true) + (h₂ : tierOrder weight b c = true) : tierOrder weight a c = true := by + simp only [tierOrder, Bool.or_eq_true, Bool.and_eq_true, decide_eq_true_eq, beq_iff_eq] at * + omega + +theorem tierOrder_total (weight : Nat → Nat) (a b : Nat) : + (tierOrder weight a b || tierOrder weight b a) = true := by + simp only [tierOrder, Bool.or_eq_true, Bool.and_eq_true, decide_eq_true_eq, beq_iff_eq] + omega + +/-- The search order is sorted: weight descending, then ID ascending. -/ +theorem tierItems_sorted (weight : Nat → Nat) (topo : List Nat) : + (topo.mergeSort (tierOrder weight)).Pairwise (fun a b => tierOrder weight a b = true) := + List.pairwise_mergeSort (tierOrder_trans weight) (tierOrder_total weight) topo + +theorem Feasible.congr {deps : Nat → List Nat} {items items' : List Nat} {cap : Nat} + {G G' : List Nat} (hi : ∀ x, x ∈ items ↔ x ∈ items') (hG : G.Perm G') + (h : Feasible deps items cap G) : Feasible deps items' cap G' := by + obtain ⟨hnd, hmem, hcl, hlen⟩ := h + refine ⟨hG.nodup_iff.mp hnd, fun x hx => (hi x).mp (hmem x (hG.mem_iff.mpr hx)), + fun u hu d hd => hG.mem_iff.mp (hcl u (hG.mem_iff.mpr hu) d hd), ?_⟩ + rw [← hG.length_eq] + exact hlen + +/-- **The first tier.** `firstTier topo weight deps cap` returns (ascending) a +set of terms of `topo` that is closed under `deps`, has at most `cap` +terms, and has the maximum total weight among all such sets; every such set +of the same weight is the same set or comes after it in the tie order over +the terms sorted by weight descending, then ID ascending (at the first term +in that order where they differ, the returned set contains it). -/ +theorem firstTier_spec {topo : Array Nat} {weight : Nat → Nat} {deps : Nat → List Nat} + {cap : Nat} {limits : Limits} {tier : Array Nat} {states : Nat} + (h : firstTier topo weight deps cap limits = .ok (tier, states)) : + Feasible deps topo.toList cap tier.toList ∧ tier.toList.Pairwise (· ≤ ·) ∧ + (∀ G, Feasible deps topo.toList cap G → wsum weight G ≤ wsum weight tier.toList) ∧ + ∀ G, Feasible deps topo.toList cap G → wsum weight G = wsum weight tier.toList → + (∀ x, x ∈ G ↔ x ∈ tier.toList) ∨ + PrecIn (topo.toList.mergeSort (tierOrder weight)) tier.toList G := by + unfold firstTier at h + obtain ⟨cl, hcl, h⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + obtain ⟨st, hst, h⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + obtain ⟨hnd, hok, hdeps⟩ := tierClosures_spec hcl + generalize hitemsL : topo.toList.mergeSort (tierOrder weight) = itemsL at h hst ⊢ + have hperm : itemsL.Perm topo.toList := hitemsL ▸ List.mergeSort_perm _ _ + have hmemI : ∀ x, x ∈ itemsL ↔ x ∈ topo.toList := fun x => hperm.mem_iff + have hctx : Ctx deps (fun t => cl.getD t none) cap (itemsL.toArray).toList := by + exact ⟨hperm.nodup_iff.mpr hnd, fun t ht => hok t ((hmemI t).mp ht), + fun t ht d hd => (hmemI d).mpr (hdeps t ((hmemI t).mp ht) d hd)⟩ + have hsort : (itemsL.toArray).toList.Pairwise fun a b => weight b ≤ weight a := by + rw [← hitemsL] + refine (tierItems_sorted weight topo.toList).imp fun {a b} hab => ?_ + simp only [tierOrder, Bool.or_eq_true, Bool.and_eq_true, decide_eq_true_eq, + beq_iff_eq] at hab + omega + have hinv0 : Inv deps (itemsL.toArray).toList cap ((itemsL.toArray).toList.take 0) [] [] := + ⟨List.nodup_nil, by simp, by simp, by simp, by simp, fun _ h => by cases h⟩ + have hspec := tierDfs_spec hctx weight hsort limits _ 0 0 [] {} [] {} st (by simp [wsum]) + (fun u => by simp) hinv0 hst + simp only [List.drop_zero] at hspec + have hsplit : itemsL = [] ++ itemsL := rfl + have hinvE : Inv deps itemsL cap [] [] [] := + ⟨List.nodup_nil, by simp, by simp, by simp, by simp, fun _ h => by cases h⟩ + have hord := leaves_order hctx itemsL [] [] [] hsplit hinvE + obtain ⟨hne, hres⟩ := fold_best weight itemsL _ none hord (fun _ _ h => nomatch h) + have hbest : st.best ≠ none := by + rw [hspec] + exact hne (Or.inr (leaves_ne_nil _ _ _ _ _)) + obtain ⟨b, R, hbR⟩ : ∃ b R, st.best = some (b, R) := by + cases h' : st.best with + | none => exact absurd h' hbest + | some p => exact ⟨p.1, p.2, rfl⟩ + rw [hbR] at h + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, -⟩ := h + rw [hspec] at hbR + obtain ⟨hbw, hRmem, hle, -, htie⟩ := hres b R hbR + have hRL : R ∈ tierLeaves (fun t => cl.getD t none) cap itemsL [] [] := by + rcases hRmem with h | h + · exact h + · cases h + obtain ⟨_, _, _, _, hleaf⟩ := leaves_shape hctx itemsL [] [] [] hsplit hinvE R hRL + obtain ⟨hRnd, hRlen, -, hRitems, hRcl⟩ := hleaf + have hTperm : R.Perm (R.mergeSort (· ≤ ·)) := (List.mergeSort_perm _ _).symm + have hFeasR : Feasible deps itemsL cap R := ⟨hRnd, hRitems, hRcl, hRlen⟩ + have hwT : wsum weight (R.mergeSort (· ≤ ·)) = b := by rw [← wsum_perm hTperm, hbw] + -- every feasible set is a leaf, up to order + have hleaf : ∀ G, Feasible deps topo.toList cap G → + ∃ F ∈ tierLeaves (fun t => cl.getD t none) cap itemsL [] [], + (∀ x, x ∈ F ↔ x ∈ G) ∧ wsum weight F = wsum weight G := by + intro G hG + have hG' : Feasible deps itemsL cap G := + hG.congr (fun x => (hmemI x).symm) (List.Perm.refl G) + obtain ⟨F, hF, hFG⟩ := leaves_complete hctx hG' itemsL [] [] [] hsplit hinvE (by simp) + (by simp) (by simp) + obtain ⟨_, _, _, _, hFnd, _⟩ := leaves_shape hctx itemsL [] [] [] hsplit hinvE F hF + exact ⟨F, hF, hFG, wsum_perm ((List.perm_ext_iff_of_nodup hFnd hG.1).mpr hFG)⟩ + refine ⟨hFeasR.congr hmemI hTperm, ?_, fun G hG => ?_, fun G hG hGw => ?_⟩ + · exact (List.pairwise_mergeSort (le := fun a b => decide (a ≤ b)) + (fun a b c h1 h2 => decide_eq_true (Nat.le_trans (of_decide_eq_true h1) (of_decide_eq_true h2))) + (fun a b => by rcases Nat.le_total a b with h | h <;> simp [h]) R).imp + fun h => of_decide_eq_true h + · obtain ⟨F, hF, -, hw⟩ := hleaf G hG + rw [hwT, ← hw] + exact hle F hF + · obtain ⟨F, hF, hFG, hw⟩ := hleaf G hG + rw [hwT] at hGw + rcases htie F hF (by omega) with rfl | hprec + · exact Or.inl fun x => (hFG x).symm.trans hTperm.mem_iff + · exact Or.inr (hprec.congr (fun x => hTperm.mem_iff) hFG) + +/-- A successful first-tier search saw every term once. -/ +theorem firstTier_nodup {topo : Array Nat} {weight : Nat → Nat} {deps : Nat → List Nat} + {cap : Nat} {limits : Limits} {r : Array Nat × Nat} + (h : firstTier topo weight deps cap limits = .ok r) : topo.toList.Nodup := by + unfold firstTier at h + obtain ⟨cl, hcl, -⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + exact (tierClosures_spec hcl).1 + +/-! ## Phase 2 -/ + +/-- The position map of `respectsDeps` maps a term to an index holding it. -/ +theorem posMap_spec (order : Array Nat) : + ∀ (l : List (Nat × Nat)) (mp : Std.HashMap Nat Nat), + (∀ d j, mp.get? d = some j → order[j]? = some d) → (∀ x ∈ l, order[x.2]? = some x.1) → + ∀ d j, (l.foldl (fun m (x : Nat × Nat) => m.insert x.1 x.2) mp).get? d = some j → + order[j]? = some d := by + intro l + induction l with + | nil => intro mp hmp _ d j h; exact hmp d j h + | cons x l ih => + intro mp hmp hl + simp only [List.foldl_cons] + refine ih _ (fun d j h => ?_) (fun y hy => hl y (List.mem_cons_of_mem _ hy)) + rw [Std.HashMap.get?_insert] at h + split at h + · rename_i hx + simp only [Option.some.injEq] at h + subst h + rw [beq_iff_eq] at hx + subst hx + exact hl x List.mem_cons_self + · exact hmp d j h + +/-- **Backwardness check.** If `respectsDeps` accepts `order`, every +dependency of the term at index `k` is at an index below `k`. -/ +theorem respectsDeps_spec {order : Array Nat} {deps : Nat → List Nat} + (h : respectsDeps order deps = true) : + ∀ k (hk : k < order.size), ∀ d ∈ deps order[k], ∃ j, j < k ∧ order[j]? = some d := by + intro k hk d hd + unfold respectsDeps at h + simp only at h + rw [Array.all_eq_true_iff_forall_mem] at h + have hmem : (order[k], k) ∈ order.zipIdx := + Array.mem_zipIdx_iff_getElem?.mpr (by simp [hk]) + have h1 := h _ hmem + simp only [List.all_eq_true] at h1 + have h2 := h1 d hd + cases hp : (order.zipIdx.foldl (fun m (x : Nat × Nat) => m.insert x.1 x.2) + (∅ : Std.HashMap Nat Nat)).get? d with + | none => + simp only [hp, Option.any_none] at h2 + cases h2 + | some j => + simp only [hp, Option.any_some, decide_eq_true_eq] at h2 + refine ⟨j, h2, ?_⟩ + rw [← Array.foldl_toList] at hp + exact posMap_spec order _ ∅ (fun d j h => by simp at h) + (fun x hx => Array.mem_zipIdx_iff_getElem?.mp (Array.mem_toList_iff.mp hx)) d j hp + +/-- The reference counts of `shareCounts`: the occurrences of each index +among the Share indices of the expressions. -/ +theorem shareCounts_inner : + ∀ (l : List Nat) (refs : Array Nat), + (l.foldl (fun refs i => if i < refs.size then refs.modify i (· + 1) else refs) refs).size = + refs.size ∧ + ∀ i, i < refs.size → + (l.foldl (fun refs i => if i < refs.size then refs.modify i (· + 1) else refs) + refs)[i]! = refs[i]! + l.count i := by + intro l + induction l with + | nil => intro refs; simp + | cons c cs ih => + intro refs + simp only [List.foldl_cons] + split + · rename_i hc + obtain ⟨hs, hv⟩ := ih (refs.modify c (· + 1)) + refine ⟨by rw [hs]; simp, fun i hi => ?_⟩ + rw [hv i (by simp; omega), List.count_cons] + have hm : (refs.modify c (· + 1))[i]! = refs[i]! + (if c = i then 1 else 0) := by + simp only [getElem!_def, Array.getElem?_modify] + by_cases hci : c = i + · subst hci; simp [Array.getElem?_eq_getElem hi] + · simp [hci] + rw [hm] + by_cases hci : c = i + · subst hci; simp; omega + · have : (c == i) = false := by rw [beq_eq_false_iff_ne]; exact hci + simp [hci, this] + · rename_i hc + obtain ⟨hs, hv⟩ := ih refs + refine ⟨hs, fun i hi => ?_⟩ + rw [hv i hi, List.count_cons] + have : (c == i) = false := by rw [beq_eq_false_iff_ne]; omega + simp [this] + +theorem shareCounts_spec (m : Nat) (exprs : Array Ixon.Expr) : + (shareCounts m exprs).size = m ∧ ∀ i, i < m → + (shareCounts m exprs)[i]! = + (exprs.toList.flatMap fun e => (shareIndices e #[]).toList).count i := by + unfold shareCounts + rw [← Array.foldl_toList] + suffices ∀ (l : List Ixon.Expr) (refs : Array Nat), + (l.foldl (fun refs e => (shareIndices e #[]).foldl + (fun refs i => if i < refs.size then refs.modify i (· + 1) else refs) refs) refs).size = + refs.size ∧ + ∀ i, i < refs.size → (l.foldl (fun refs e => (shareIndices e #[]).foldl + (fun refs i => if i < refs.size then refs.modify i (· + 1) else refs) refs) refs)[i]! = + refs[i]! + (l.flatMap fun e => (shareIndices e #[]).toList).count i by + obtain ⟨hs, hv⟩ := this exprs.toList (Array.replicate m 0) + refine ⟨by rw [hs]; simp, fun i hi => ?_⟩ + rw [hv i (by simp; omega)] + simp [hi] + intro l + induction l with + | nil => intro refs; simp + | cons e es ih => + intro refs + simp only [List.foldl_cons, List.flatMap_cons, List.count_append] + rw [← Array.foldl_toList] + obtain ⟨hs1, hv1⟩ := shareCounts_inner (shareIndices e #[]).toList refs + obtain ⟨hs2, hv2⟩ := ih ((shareIndices e #[]).toList.foldl + (fun refs i => if i < refs.size then refs.modify i (· + 1) else refs) refs) + refine ⟨by rw [hs2, hs1], fun i hi => ?_⟩ + rw [hv2 i (by rw [hs1]; exact hi), hv1 i hi] + omega + +/-- Inserting keys `f i` for `i` in a duplicate-free list with injective `f`: +each key holds its own value. -/ +theorem fold_insert_getD {β : Type} (f : Nat → Nat) (g : Nat → β) (fb : β) : + ∀ (l : List Nat) (mp : Std.HashMap Nat β), l.Nodup → + (∀ i ∈ l, ∀ j ∈ l, f i = f j → i = j) → + ∀ i ∈ l, (l.foldl (fun m i => m.insert (f i) (g i)) mp).getD (f i) fb = g i := by + have keep : ∀ (l : List Nat) (mp : Std.HashMap Nat β) (k : Nat), (∀ i ∈ l, f i ≠ k) → + (l.foldl (fun m i => m.insert (f i) (g i)) mp).getD k fb = mp.getD k fb := by + intro l + induction l with + | nil => intro mp k _; rfl + | cons a l ih => + intro mp k hk + simp only [List.foldl_cons] + rw [ih _ k (fun i hi => hk i (List.mem_cons_of_mem _ hi)), Std.HashMap.getD_insert] + have : (f a == k) = false := by + rw [beq_eq_false_iff_ne]; exact hk a List.mem_cons_self + rw [this] + rfl + intro l + induction l with + | nil => intro _ _ _ i hi; cases hi + | cons a l ih => + intro mp hnd hinj i hi + rw [List.nodup_cons] at hnd + simp only [List.foldl_cons] + rcases List.mem_cons.mp hi with rfl | hi + · rw [keep _ _ _ (fun j hj hfj => hnd.1 (hinj j (List.mem_cons_of_mem _ hj) i + List.mem_cons_self hfj ▸ hj)), Std.HashMap.getD_insert] + simp + · exact ih _ hnd.2 (fun j hj k hk h => hinj j (List.mem_cons_of_mem _ hj) k + (List.mem_cons_of_mem _ hk) h) i hi + +theorem getBang_inj {order : Array Nat} (hnd : order.toList.Nodup) {i j : Nat} + (hi : i < order.size) (hj : j < order.size) (h : order[i]! = order[j]!) : i = j := by + rw [getElem!_pos order i hi, getElem!_pos order j hj] at h + have hi' : i < order.toList.length := by simpa using hi + have hj' : j < order.toList.length := by simpa using hj + have e1 := hnd.idxOf_getElem i hi' + have e2 := hnd.idxOf_getElem j hj' + have : order.toList[i] = order.toList[j] := by simpa using h + rw [this] at e1 + omega + +/-- **Reference counts.** The weight of the stored term at phase-1 index +`i` is the number of `Share(i)` in the phase-1 entries and roots. -/ +theorem tierWeights_spec {order1 : Array Nat} (hnd : order1.toList.Nodup) + (entries1 roots1 : Array Ixon.Expr) {i : Nat} (hi : i < order1.size) : + (tierWeights order1 entries1 roots1).getD order1[i] 0 = + ((entries1.toList ++ roots1.toList).flatMap fun e => (shareIndices e #[]).toList).count i := by + unfold tierWeights + have := fold_insert_getD (fun i => order1[i]!) (fun i => (shareCounts order1.size + (entries1 ++ roots1))[i]!) 0 (List.range order1.size) {} List.nodup_range + (fun a ha b hb h => getBang_inj hnd (List.mem_range.mp ha) (List.mem_range.mp hb) h) i + (List.mem_range.mpr hi) + rw [← getElem!_pos order1 i hi, this, (shareCounts_spec _ _).2 i hi] + simp + +/-- The terms a phase-1 body references. -/ +theorem mem_bodyRefs (order1 : Array Nat) (e : Ixon.Expr) (d : Nat) : + d ∈ bodyRefs order1 e ↔ ∃ j ∈ (shareIndices e #[]).toList, order1[j]? = some d := by + unfold bodyRefs + simp [List.mem_filterMap] + +/-- **Dependencies.** The dependencies of the stored term at phase-1 index +`i` are the terms its phase-1 body references. -/ +theorem tierDeps_spec {order1 : Array Nat} (hnd : order1.toList.Nodup) + (entries1 : Array Ixon.Expr) {i : Nat} (hi : i < order1.size) : + (tierDeps order1 entries1).getD order1[i] [] = bodyRefs order1 (entries1[i]?.getD default) := by + unfold tierDeps + have := fold_insert_getD (fun i => order1[i]!) (fun i => bodyRefs order1 + (entries1[i]?.getD default)) [] (List.range order1.size) {} List.nodup_range + (fun a ha b hb h => getBang_inj hnd (List.mem_range.mp ha) (List.mem_range.mp hb) h) i + (List.mem_range.mpr hi) + rw [← getElem!_pos order1 i hi, this] + +/-- **Phase 2.** A successful slot allocation on the phase-1 table `order1` +(entries `entries1`, roots `roots1`), with the reference counts `weight` +and the body-reference relation `deps` of the phase-1 output +(`tierWeights_spec`, `tierDeps_spec`): +* the first tier is a maximum-reference-count set of at most 8 stored terms + closed under body references, and the first such set in the tie order + (`firstTier_spec`); +* the final order is a permutation of the phase-1 table that places every + body reference of an entry before it (backwardness); +* it is the phase-1 order if the guard kept it, otherwise the first tier in + the pinned order followed by the other terms in the Kahn priority order, + and its reference cost is at most the phase-1 order's. -/ +theorem allocate_spec {layout : ShareLayout} {limits : Limits} {dag : Dag} {deg : Array Nat} + {order1 : Array Nat} {entries1 roots1 : Array Ixon.Expr} {a : Allocation} + (h : allocate layout limits dag deg order1 entries1 roots1 = .ok a) : + let weight := fun t => (tierWeights order1 entries1 roots1).getD t 0 + let deps := fun t => (tierDeps order1 entries1).getD t [] + let cap := min 8 order1.size + order1.toList.Nodup ∧ + (Feasible deps order1.toList cap a.tier.toList ∧ a.tier.toList.Pairwise (· ≤ ·) ∧ + (∀ G, Feasible deps order1.toList cap G → wsum weight G ≤ wsum weight a.tier.toList) ∧ + ∀ G, Feasible deps order1.toList cap G → wsum weight G = wsum weight a.tier.toList → + (∀ x, x ∈ G ↔ x ∈ a.tier.toList) ∨ + PrecIn (order1.toList.mergeSort (tierOrder weight)) a.tier.toList G) ∧ + a.order.toList.Perm order1.toList ∧ + (∀ k (hk : k < a.order.size), ∀ d ∈ deps a.order[k], ∃ j, j < k ∧ a.order[j]? = some d) ∧ + (a.order = if a.kept then order1 else pinnedOrder dag deg a.tier ++ + kahnOrder weight deps ((order1.toList.mergeSort (· ≤ ·)).toArray.filter + (!a.tier.contains ·))) ∧ + a.refCost1 = refCost layout weight order1 ∧ a.refCostFinal = refCost layout weight a.order ∧ + a.refCostFinal ≤ a.refCost1 ∧ + (pinnedOrder dag deg a.tier ++ kahnOrder weight deps + ((order1.toList.mergeSort (· ≤ ·)).toArray.filter (!a.tier.contains ·))).toList.Perm + order1.toList ∧ + a.refCostFinal ≤ refCost layout weight (pinnedOrder dag deg a.tier ++ kahnOrder weight deps + ((order1.toList.mergeSort (· ≤ ·)).toArray.filter (!a.tier.contains ·))) := by + intro weight deps cap + unfold allocate at h + dsimp only at h + obtain ⟨⟨tier, states⟩, hft, h⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + dsimp only at h + obtain ⟨_, hc2, h⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + try dsimp only at h + obtain ⟨_, hc1, h⟩ := Ix.Compile.Verify.SharingExact.bind_eq_ok h + have hresp := checkInternal_ok hc1 + have hperm := checkInternal_ok hc2 + simp only [pure, Except.pure, Except.ok.injEq] at h + subst h + have hnd := firstTier_nodup hft + -- the sorted pinned order equals the sorted phase-1 table + have hperm2 : (pinnedOrder dag deg tier ++ kahnOrder weight deps + ((order1.toList.mergeSort (· ≤ ·)).toArray.filter (!tier.contains ·))).toList.Perm + order1.toList := by + have hs := congrArg Array.toList (beq_iff_eq.mp hperm) + simp only at hs + refine (List.mergeSort_perm _ (fun x1 x2 => decide (x1 ≤ x2))).symm.trans ?_ + rw [hs] + exact List.mergeSort_perm _ _ + refine ⟨hnd, firstTier_spec hft, ?_, respectsDeps_spec hresp, by dsimp only, by dsimp only, + by dsimp only, ?_, hperm2, ?_⟩ + · dsimp only + split + · exact List.Perm.refl _ + · exact hperm2 + · simp only + split + · exact Nat.le_refl _ + · rename_i hk + simp only [Bool.not_eq_true, decide_eq_false_iff_not, Nat.not_lt] at hk + exact hk + · simp only + split + · rename_i hk + simp only [decide_eq_true_eq] at hk + exact Nat.le_of_lt hk + · exact Nat.le_refl _ + +end Ix.Compile.Verify.Tiered diff --git a/Ix/Compile/Verify/TieredWire.lean b/Ix/Compile/Verify/TieredWire.lean new file mode 100644 index 000000000..5cbef4008 --- /dev/null +++ b/Ix/Compile/Verify/TieredWire.lean @@ -0,0 +1,279 @@ +import Ix.Compile.Verify.TieredIdem +import Ix.Compile.Verify.Catalog + +/-! +# Tiered construction: the output is in the wire domain + +For the format switch: every expression the tiered construction returns +(table entries and roots) is in the expression codec's public wire domain +(`Ixon.Expr.wireWF`: every `UInt64` count it writes is representable), the +table count fits a `UInt64` (capacity), table entry `k` references only +entries below `k`, and every root only table entries (the Share part of +`DecodeCtx.SharingWF`). The wire domain is established by phase 3's +`wireCounts` check over the output (`wireCounts_spec`); the other facts +are proved from the construction. For the wire layout the length the +construction reports is the serialized length of its output +(`canonicalSharingTiered_serialized`). +-/ + +namespace Ix.Compile.Verify.Tiered + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (bind_eq_ok SharesIn materializeTable_parts + materializeTable_backward) + +/-- `wireCounts` decides the wire domain and computes the telescope counts. -/ +theorem wireCounts_spec : ∀ (e : Ixon.Expr) (c : Nat × Nat × Nat), wireCounts e = some c → + e.wireWF ∧ c = (e.appCount, e.lamCount, e.allCount) := by + intro e + induction e with + | sort _ | var _ | str _ | nat _ | share _ => + intro c h; simp only [wireCounts, Option.some.injEq] at h; subst h + exact ⟨trivial, rfl⟩ + | ref _ us | recur _ us => + intro c h + simp only [wireCounts] at h + split at h + · rename_i hus; simp only [Option.some.injEq] at h; subst h; exact ⟨hus, rfl⟩ + · cases h + | prj _ _ v ih => + intro c h + simp only [wireCounts] at h + cases hv : wireCounts v with + | none => rw [hv] at h; cases h + | some cv => + rw [hv] at h + simp only [Option.map_some, Option.some.injEq] at h + subst h + exact ⟨(ih cv hv).1, rfl⟩ + | app f a ihf iha => + intro c h + simp only [wireCounts] at h + cases hf : wireCounts f with + | none => rw [hf] at h; cases h + | some cf => + cases ha : wireCounts a with + | none => rw [hf, ha] at h; cases h + | some ca => + rw [hf, ha] at h + obtain ⟨n, x, y⟩ := cf + simp only at h + split at h + · rename_i hn + simp only [Option.some.injEq] at h + subst h + obtain ⟨hwf, hc⟩ := ihf _ hf + simp only [Prod.mk.injEq] at hc + refine ⟨⟨hwf, (iha ca ha).1, by rw [← hc.1]; exact hn⟩, ?_⟩ + simp [Ixon.Expr.appCount, Ixon.Expr.lamCount, Ixon.Expr.allCount, hc.1] + · cases h + | lam _ ty b iht ihb => + intro c h + simp only [wireCounts] at h + cases ht : wireCounts ty with + | none => rw [ht] at h; cases h + | some ct => + cases hb : wireCounts b with + | none => rw [ht, hb] at h; cases h + | some cb => + rw [ht, hb] at h + obtain ⟨x, n, y⟩ := cb + simp only at h + split at h + · rename_i hn + simp only [Option.some.injEq] at h + subst h + obtain ⟨hwf, hc⟩ := ihb _ hb + simp only [Prod.mk.injEq] at hc + refine ⟨⟨(iht ct ht).1, hwf, by rw [← hc.2.1]; exact hn⟩, ?_⟩ + simp [Ixon.Expr.appCount, Ixon.Expr.lamCount, Ixon.Expr.allCount, hc.2.1] + · cases h + | all _ _ ty b iht ihb => + intro c h + simp only [wireCounts] at h + cases ht : wireCounts ty with + | none => rw [ht] at h; cases h + | some ct => + cases hb : wireCounts b with + | none => rw [ht, hb] at h; cases h + | some cb => + rw [ht, hb] at h + obtain ⟨x, y, n⟩ := cb + simp only at h + split at h + · rename_i hn + simp only [Option.some.injEq] at h + subst h + obtain ⟨hwf, hc⟩ := ihb _ hb + simp only [Prod.mk.injEq] at hc + refine ⟨⟨(iht ct ht).1, hwf, by rw [← hc.2.2]; exact hn⟩, ?_⟩ + simp [Ixon.Expr.appCount, Ixon.Expr.lamCount, Ixon.Expr.allCount, hc.2.2] + · cases h + | letE _ ty v b iht ihv ihb => + intro c h + simp only [wireCounts] at h + cases ht : wireCounts ty with + | none => rw [ht] at h; cases h + | some ct => + cases hv : wireCounts v with + | none => rw [ht, hv] at h; cases h + | some cv => + cases hb : wireCounts b with + | none => rw [ht, hv, hb] at h; cases h + | some cb => + rw [ht, hv, hb] at h + simp only [Option.some.injEq] at h + subst h + exact ⟨⟨(iht ct ht).1, (ihv cv hv).1, (ihb cb hb).1⟩, rfl⟩ + +theorem wireWF_of_check {e : Ixon.Expr} (h : (wireCounts e).isSome = true) : e.wireWF := by + cases hc : wireCounts e with + | none => rw [hc] at h; cases h + | some c => exact (wireCounts_spec e c hc).1 + +/-- The format facts of an encoding: wire domain, table capacity, and +backward Shares. -/ +def FormatOK (sharing roots : Array Ixon.Expr) : Prop := + (∀ e ∈ sharing.toList, e.wireWF) ∧ (∀ e ∈ roots.toList, e.wireWF) ∧ + sharing.size < UInt64.size ∧ + (∀ k (hk : k < sharing.size), SharesIn (· < k) sharing[k]) ∧ + ∀ e ∈ roots.toList, SharesIn (· < sharing.size) e + +theorem tieredAtWidth_format {layout : ShareLayout} {limits : Limits} {ex : Expanded} {w : Nat} + {c : TieredSharingResult} (h : tieredAtWidth layout limits ex w = .ok c) : + FormatOK c.result.sharing c.result.roots := by + obtain ⟨u, a, m, -, -, hm, rfl⟩ := tieredAtWidth_parts h + obtain ⟨work, hmat, -, -, hwire⟩ := rematerialize_parts hm + obtain ⟨hsize, -, -⟩ := materializeTable_parts _ _ _ _ _ hmat + obtain ⟨hsz, hback, hrback⟩ := materializeTable_backward _ _ _ _ _ (by omega) hmat + rw [Array.all_eq_true] at hwire + have hw : ∀ e ∈ (m.entries ++ m.roots).toList, e.wireWF := by + intro e he + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp he + exact wireWF_of_check (hwire i (by simpa using hi)) + refine ⟨fun e he => hw e (by rw [Array.toList_append, List.mem_append]; exact Or.inl he), + fun e he => hw e (by rw [Array.toList_append, List.mem_append]; exact Or.inr he), + by show m.entries.size < UInt64.size; omega, hback, ?_⟩ + intro e he + rw [show (tieredResult layout ex w u a m).result.sharing.size = a.order.size by + show m.entries.size = a.order.size; exact hsz] + exact hrback e he + +/-- **The tiered output is in the format domain.** Every table entry and +root the tiered construction returns is in the expression codec's wire +domain, the table count fits a `UInt64`, entry `k` references only entries +below `k`, and every root only table entries. -/ +theorem canonicalTiered_format {layout : ShareLayout} {limits : Limits} {ex : Expanded} + {r : TieredSharingResult} (h : canonicalTieredExpanded layout limits ex = .ok r) : + FormatOK r.result.sharing r.result.roots := by + obtain ⟨r₀, hr₀, -, -, hs, hr, -, -⟩ := canonicalTiered_core h + rw [hs, hr] + obtain ⟨c₁, c₂, c₃, h₁, h₂, h₃, ⟨c, hc, hrc⟩, -, -⟩ := canonicalTieredCore_select hr₀ + have hres : r₀.result = c.result := by rw [hrc] + rw [hres] + simp only [List.mem_cons, List.not_mem_nil, or_false] at hc + rcases hc with hc | hc | hc <;> rw [hc] + · exact tieredAtWidth_format h₁ + · exact tieredAtWidth_format h₂ + · exact tieredAtWidth_format h₃ + +/-- `canonicalSharingTiered` (Share-free roots): the output is in the format +domain. -/ +theorem canonicalSharingTiered_format {layout : ShareLayout} {roots : Array Ixon.Expr} + {limits : Limits} {r : TieredSharingResult} + (h : canonicalSharingTiered layout roots limits = .ok r) : + FormatOK r.result.sharing r.result.roots := by + unfold canonicalSharingTiered at h + obtain ⟨ex, -, h⟩ := bind_eq_ok h + exact canonicalTiered_format h + +/-- `canonicalSharingTieredTable` (roots with an existing table): the output +is in the format domain. -/ +theorem canonicalSharingTieredTable_format {layout : ShareLayout} + {sharing roots : Array Ixon.Expr} {limits : Limits} {r : TieredSharingResult} + (h : canonicalSharingTieredTable layout sharing roots limits = .ok r) : + FormatOK r.result.sharing r.result.roots := by + unfold canonicalSharingTieredTable at h + obtain ⟨ex, -, h⟩ := bind_eq_ok h + exact canonicalTiered_format h + +/-! ## The reported length is the serialized length + +On the wire domain the TagN layout length of an encoding is the length the +wire codec writes (`layoutBytes_tagN_eq_serialized`). Phase 3 records the +layout length of its output (`rematerialize_measured`) and checks that every +output expression is in the wire domain, so for the wire layout the length +the tiered construction reports is the serialized length of its output +(`canonicalSharingTiered_serialized`). -/ + +/-- On the wire domain the TagN layout price is the serialized length. -/ +theorem layoutBytes_tagN_eq_serialized (entries roots : Array Ixon.Expr) + (h : ((entries ++ roots).all fun e => (wireCounts e).isSome) = true) : + layoutBytes .tagN entries roots = + tag0Size entries.size + (entries ++ roots).foldl (fun acc e => acc + (Ixon.serExpr e).size) 0 := by + have hsz : ∀ e ∈ (entries ++ roots).toList, + (sizeInfoWith ShareLayout.tagN.widthAt e).full = (Ixon.serExpr e).size := by + intro e he + rw [Array.all_eq_true'] at h + obtain ⟨c, hc⟩ := Option.isSome_iff_exists.mp (h e (Array.mem_toList_iff.mp he)) + have hser := Ix.Compile.Verify.SharingExact.exprSize_eq_serExpr e (wireCounts_spec e c hc).1 + exact hser + unfold layoutBytes + simp only [Ix.Compile.Verify.UniformModel.array_foldl_add_sum, Array.toList_append, + List.map_append, List.sum_append] at hsz ⊢ + rw [List.map_congr_left (fun e he => hsz e (List.mem_append_left _ he)), + List.map_congr_left (fun e he => hsz e (List.mem_append_right _ he))] + omega + +theorem tieredAtWidth_serialized {limits : Limits} {ex : Expanded} {w : Nat} + {c : TieredSharingResult} (h : tieredAtWidth .tagN limits ex w = .ok c) : + c.result.variableBytes = tag0Size c.result.sharing.size + + (c.result.sharing ++ c.result.roots).foldl (fun acc e => acc + (Ixon.serExpr e).size) 0 ∧ + c.result.modelBytes = c.result.variableBytes := by + obtain ⟨u, a, m, -, -, hm, rfl⟩ := tieredAtWidth_parts h + obtain ⟨-, -, -, -, hwire⟩ := rematerialize_parts hm + obtain ⟨hmeas, hbytes⟩ := rematerialize_measured hm + show m.measured = tag0Size m.entries.size + + (m.entries ++ m.roots).foldl (fun acc e => acc + (Ixon.serExpr e).size) 0 ∧ + m.bytes = m.measured + exact ⟨hmeas.trans (layoutBytes_tagN_eq_serialized _ _ hwire), hbytes⟩ + +theorem canonicalTiered_serialized {limits : Limits} {ex : Expanded} {r : TieredSharingResult} + (h : canonicalTieredExpanded .tagN limits ex = .ok r) : + r.result.variableBytes = tag0Size r.result.sharing.size + + (r.result.sharing ++ r.result.roots).foldl (fun acc e => acc + (Ixon.serExpr e).size) 0 ∧ + r.result.modelBytes = r.result.variableBytes := by + obtain ⟨r₀, hr₀, hrr, -, -, -, -, -⟩ := canonicalTiered_core h + subst hrr + obtain ⟨c₁, c₂, c₃, h₁, h₂, h₃, ⟨c, hc, hrc⟩, -, -⟩ := canonicalTieredCore_select hr₀ + subst hrc + simp only [List.mem_cons, List.not_mem_nil, or_false] at hc + rcases hc with rfl | rfl | rfl + · have hc := tieredAtWidth_serialized h₁; exact hc + · have hc := tieredAtWidth_serialized h₂; exact hc + · have hc := tieredAtWidth_serialized h₃; exact hc + +/-- **The tiered length is the serialized length.** For the wire layout, the +length `canonicalSharingTiered` reports for its output (`variableBytes`, and +the layout price `modelBytes`) is the serialized length of the output: the +table count and every entry and root as the wire codec writes them. -/ +theorem canonicalSharingTiered_serialized {roots : Array Ixon.Expr} {limits : Limits} + {r : TieredSharingResult} (h : canonicalSharingTiered .tagN roots limits = .ok r) : + r.result.variableBytes = tag0Size r.result.sharing.size + + (r.result.sharing ++ r.result.roots).foldl (fun acc e => acc + (Ixon.serExpr e).size) 0 ∧ + r.result.modelBytes = r.result.variableBytes := by + unfold canonicalSharingTiered at h + obtain ⟨ex, -, h⟩ := bind_eq_ok h + exact canonicalTiered_serialized h + +/-- `canonicalSharingTiered_serialized` for roots with an existing table. -/ +theorem canonicalSharingTieredTable_serialized {sharing roots : Array Ixon.Expr} {limits : Limits} + {r : TieredSharingResult} (h : canonicalSharingTieredTable .tagN sharing roots limits = .ok r) : + r.result.variableBytes = tag0Size r.result.sharing.size + + (r.result.sharing ++ r.result.roots).foldl (fun acc e => acc + (Ixon.serExpr e).size) 0 ∧ + r.result.modelBytes = r.result.variableBytes := by + unfold canonicalSharingTieredTable at h + obtain ⟨ex, -, h⟩ := bind_eq_ok h + exact canonicalTiered_serialized h + +end Ix.Compile.Verify.Tiered diff --git a/Ix/Compile/Verify/UniformChecks.lean b/Ix/Compile/Verify/UniformChecks.lean new file mode 100644 index 000000000..88d07ae9d --- /dev/null +++ b/Ix/Compile/Verify/UniformChecks.lean @@ -0,0 +1,484 @@ +import Ix.Compile.Verify.UniformDecomp + +/-! +# Runtime-checked facts of the uniform search + +Specifications of the checkers the optimizer runs: `reachLabels` / +`labelsSeparated` (the labels reachable along non-opaque paths) and +`componentsChecked` (the uncertain components are a separated partition). +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (child_eq_getElem) + +/-! ## Reach summaries -/ + +/-- `x` allows label `ℓ`: it records several labels, or exactly `ℓ`. -/ +def Allows (x : Option (Option Nat)) (ℓ : Nat) : Prop := x = some none ∨ x = some (some ℓ) + +theorem allows_join_left {a : Option (Option Nat)} {ℓ : Nat} (h : Allows a ℓ) + (b : Option (Option Nat)) : Allows (labelJoin a b) ℓ := by + rcases h with rfl | rfl + · rcases b with _ | _ | b <;> simp [labelJoin, Allows] + · rcases b with _ | _ | b + · simp [labelJoin, Allows] + · simp [labelJoin, Allows] + · unfold labelJoin Allows + by_cases hab : ℓ = b + · simp [hab] + · simp [hab] + +theorem allows_join_right {b : Option (Option Nat)} {ℓ : Nat} (h : Allows b ℓ) + (a : Option (Option Nat)) : Allows (labelJoin a b) ℓ := by + rcases h with rfl | rfl + · rcases a with _ | _ | a <;> simp [labelJoin, Allows] + · rcases a with _ | _ | a + · simp [labelJoin, Allows] + · simp [labelJoin, Allows] + · unfold labelJoin Allows + by_cases hab : a = ℓ + · simp [hab] + · simp [hab] + +theorem foldl_congr_mem {α β : Type} {f g : β → α → β} : + ∀ (l : List α) (init : β), (∀ v x, x ∈ l → f v x = g v x) → l.foldl f init = l.foldl g init + | [], _, _ => rfl + | x :: xs, init, h => by + simp only [List.foldl_cons] + rw [h init x List.mem_cons_self] + exact foldl_congr_mem xs _ fun v y hy => h v y (List.mem_cons_of_mem _ hy) + +theorem allows_foldl {α : Type} (g : α → Option (Option Nat)) {ℓ : Nat} : + ∀ (l : List α) (init : Option (Option Nat)), + (Allows init ℓ ∨ ∃ a ∈ l, Allows (g a) ℓ) → + Allows (l.foldl (fun v a => labelJoin v (g a)) init) ℓ := by + intro l + induction l with + | nil => + intro init h + rcases h with h | ⟨a, ha, _⟩ + · exact h + · cases ha + | cons x xs ih => + intro init h + simp only [List.foldl_cons] + apply ih + rcases h with h | ⟨a, ha, hga⟩ + · exact Or.inl (allows_join_left h _) + · rcases List.mem_cons.mp ha with rfl | ha + · exact Or.inl (allows_join_right hga _) + · exact Or.inr ⟨a, ha, hga⟩ + +/-- The row of `reachLabels` at `t`, reading `acc` for the children. -/ +def labelRow (dag : Dag) (opq : Nat → Bool) (lab : Nat → Option Nat) + (acc : Array (Option (Option Nat))) (t : Nat) : Option (Option Nat) := + (dag.node t).children.foldl (fun v c => + labelJoin v (if opq c then (lab c).map some else acc[c]!)) ((lab t).map some) + +theorem labelRow_congr {dag : Dag} (hwf : DagWF dag) {opq : Nat → Bool} {lab : Nat → Option Nat} + {a b : Array (Option (Option Nat))} {t : Nat} (ht : t < dag.size) + (h : ∀ c, c < t → a[c]! = b[c]!) : labelRow dag opq lab a t = labelRow dag opq lab b t := by + unfold labelRow + rw [← Array.foldl_toList, ← Array.foldl_toList] + apply foldl_congr_mem + intro v c hc + have := hwf.child_lt ht (Array.mem_toList_iff.mp hc) + rw [h c this] + +theorem reachLabels_spec {dag : Dag} (hwf : DagWF dag) (opq : Nat → Bool) + (lab : Nat → Option Nat) {t : Nat} (ht : t < dag.size) : + (reachLabels dag opq lab)[t]! = labelRow dag opq lab (reachLabels dag opq lab) t := by + have hinv : ∀ m, m ≤ dag.size → + ((List.range m).foldl (fun acc t => acc.set! t (labelRow dag opq lab acc t)) + (Array.replicate dag.size none)).size = dag.size ∧ + ∀ t, t < m → + ((List.range m).foldl (fun acc t => acc.set! t (labelRow dag opq lab acc t)) + (Array.replicate dag.size none))[t]! = + labelRow dag opq lab ((List.range m).foldl + (fun acc t => acc.set! t (labelRow dag opq lab acc t)) + (Array.replicate dag.size none)) t := by + intro m + induction m with + | zero => intro _; exact ⟨by simp, fun _ h => absurd h (Nat.not_lt_zero _)⟩ + | succ m ih => + intro hm + obtain ⟨hs, hrows⟩ := ih (by omega) + rw [foldl_range_succ] + generalize (List.range m).foldl (fun acc t => acc.set! t (labelRow dag opq lab acc t)) + (Array.replicate dag.size none) = acc at hs hrows + have keep : ∀ c, c < m → (acc.set! m (labelRow dag opq lab acc m))[c]! = acc[c]! := + fun c hc => setBang_getElem!_ne _ _ (by omega) + refine ⟨by simp [hs], fun t ht => ?_⟩ + by_cases htm : t = m + · subst htm + rw [setBang_getElem!_self _ _ (by omega)] + exact labelRow_congr hwf (by omega) fun c hc => (keep c hc).symm + · rw [keep t (by omega), hrows t (by omega)] + exact labelRow_congr hwf (by omega) fun c hc => (keep c (by omega)).symm + unfold reachLabels + rw [foldRange_zero] + exact (hinv dag.size (Nat.le_refl _)).2 t ht + +/-- Paths only descend. -/ +theorem NReach.le_of_wf {dag : Dag} (hwf : DagWF dag) {O : Nat → Bool} {y v : Nat} + (h : NReach (Prep.ofDag dag) O y v) (hy : y < dag.size) : v ≤ y := by + induction h with + | refl => exact Nat.le_refl _ + | tail _ _ he ih => + obtain ⟨k, hk, rfl⟩ := he + simp only [ofDag_dag] at hk ⊢ + have := hwf.childAt_lt (by omega) hk + omega + +/-- A path is empty or starts with an edge into an opaque endpoint or into a +non-opaque term it continues from. -/ +theorem NReach.head {p : Prep} {O : Nat → Bool} {y v : Nat} (h : NReach p O y v) : + v = y ∨ ∃ k, k < (p.dag.node y).head.arity ∧ + ((O ((p.dag.node y).child k) = true ∧ v = (p.dag.node y).child k) ∨ + (O ((p.dag.node y).child k) = false ∧ NReach p O ((p.dag.node y).child k) v)) := by + induction h with + | refl => exact Or.inl rfl + | @tail u v hu hun he ih => + obtain ⟨k', hk', hv⟩ := he + have direct : u = y → + ∃ k, k < (p.dag.node y).head.arity ∧ + ((O ((p.dag.node y).child k) = true ∧ v = (p.dag.node y).child k) ∨ + (O ((p.dag.node y).child k) = false ∧ NReach p O ((p.dag.node y).child k) v)) := by + intro huy + subst huy + refine ⟨k', hk', ?_⟩ + cases hOv : O ((p.dag.node u).child k') + · exact Or.inr ⟨rfl, by rw [hv]; exact .refl⟩ + · exact Or.inl ⟨rfl, hv.symm⟩ + right + rcases hun with huy | hOu + · exact direct huy + · rcases ih with rfl | ⟨k, hk, (⟨hO, rfl⟩ | ⟨hO, hc⟩)⟩ + · exact direct rfl + · rw [hO] at hOu; cases hOu + · exact ⟨k, hk, Or.inr ⟨hO, .tail hc (Or.inr hOu) ⟨k', hk', hv⟩⟩⟩ + +/-- **The reach summaries allow every reachable label.** -/ +theorem reachLabels_allows {dag : Dag} (hwf : DagWF dag) (opq : Nat → Bool) + (lab : Nat → Option Nat) : + ∀ y, y < dag.size → ∀ v, NReach (Prep.ofDag dag) opq y v → ∀ ℓ, lab v = some ℓ → + Allows (reachLabels dag opq lab)[y]! ℓ := by + intro y + induction y using Nat.strongRecOn with + | _ y ih => + intro hy v hv ℓ hℓ + rw [reachLabels_spec hwf opq lab hy] + unfold labelRow + rw [← Array.foldl_toList] + apply allows_foldl + rcases hv.head with rfl | ⟨k, hk, (⟨hO, rfl⟩ | ⟨hO, hc⟩)⟩ + · left; rw [hℓ]; exact Or.inr rfl + · right + have har := hwf.arity y hy + rw [← dag_node_eq hy] at har + simp only [ofDag_dag] at hk hO hℓ ⊢ + refine ⟨(dag.node y).child k, ?_, ?_⟩ + · rw [child_eq_getElem _ k (by omega)] + exact Array.mem_toList_iff.mpr (Array.getElem_mem _) + · rw [if_pos hO, hℓ]; exact Or.inr rfl + · right + have har := hwf.arity y hy + rw [← dag_node_eq hy] at har + simp only [ofDag_dag] at hk hO hc ⊢ + have hlt := hwf.childAt_lt hy hk + refine ⟨(dag.node y).child k, ?_, ?_⟩ + · rw [child_eq_getElem _ k (by omega)] + exact Array.mem_toList_iff.mpr (Array.getElem_mem _) + · rw [if_neg (by simp [hO])] + exact ih _ hlt (by omega) v hc ℓ hℓ + +/-- **Checked separation.** If the check passes, every listed term carries a +label and reaches (along non-opaque paths) only terms with that label. -/ +theorem labelsSeparated_spec {dag : Dag} (hwf : DagWF dag) {opq : Nat → Bool} + {lab : Nat → Option Nat} {terms : Array Nat} (hchk : labelsSeparated dag opq lab terms = true) + {y : Nat} (hy : y ∈ terms) (hyn : y < dag.size) : + ∃ ℓ, lab y = some ℓ ∧ ∀ v, NReach (Prep.ofDag dag) opq y v → ∀ ℓ', lab v = some ℓ' → ℓ' = ℓ := by + unfold labelsSeparated at hchk + rw [Array.all_eq_true'] at hchk + have h := hchk y hy + cases hl : lab y with + | none => rw [hl] at h; cases h + | some ℓ => + rw [hl] at h + simp only [beq_iff_eq] at h + refine ⟨ℓ, rfl, fun v hv ℓ' hℓ' => ?_⟩ + have := reachLabels_allows hwf opq lab y hyn v hv ℓ' hℓ' + rw [h] at this + rcases this with h1 | h1 + · cases h1 + · simp only [Option.some.injEq] at h1; exact h1.symm + +/-! ## The component check -/ + +theorem uclass_eq_of_beq {a b : UClass} (h : (a == b) = true) : a = b := by + cases a <;> cases b <;> first | rfl | (exact absurd h (by decide)) + +theorem uclass_beq_self (a : UClass) : (a == a) = true := by + cases a <;> rfl + +theorem arr_getElem!_eq {α : Type} [Inhabited α] (a : Array α) {i : Nat} (h : i < a.size) : + a[i]! = a[i] := by + simp [getElem!_def, Array.getElem?_eq_getElem h] + +/-- What a passing `componentsChecked` guarantees: the listed components are +duplicate-free sets of uncertain terms labeled by their index, every +uncertain term is listed in the component of its label, and uncertain terms +joined by a path whose intermediate terms are not certain-stored share a +label. -/ +theorem componentsChecked_spec {dag : Dag} (hwf : DagWF dag) {cls : Array UClass} + {opaq : Array Bool} {comps : Array (Array Nat)} {label : Array (Option Nat)} + (hchk : componentsChecked dag cls opaq comps label = true) : + (∀ i, i < comps.size → ∀ t ∈ comps[i]!.toList, + t < dag.size ∧ cls[t]! = .uncertain ∧ label[t]! = some i) ∧ + (∀ i, i < comps.size → comps[i]!.toList.Nodup) ∧ + (∀ t, t < dag.size → cls[t]! = .uncertain → + ∃ i, i < comps.size ∧ label[t]! = some i ∧ t ∈ comps[i]!.toList) ∧ + (∀ a b, a < dag.size → cls[a]! = .uncertain → cls[b]! = .uncertain → + NReach (Prep.ofDag dag) (opaq[·]!) a b → label[a]! = label[b]!) := by + unfold componentsChecked at hchk + simp only [Bool.and_eq_true] at hchk + obtain ⟨⟨h1, h2⟩, h3⟩ := hchk + rw [Array.all_eq_true'] at h1 h2 + -- per-component facts + have hcomp : ∀ i, i < comps.size → ∀ j, j < comps[i]!.size → + comps[i]![j]! < dag.size ∧ cls[comps[i]![j]!]! = .uncertain ∧ + label[comps[i]![j]!]! = some i ∧ + (j + 1 < comps[i]!.size → comps[i]![j]! < comps[i]![j + 1]!) := by + intro i hi j hj + have := h1 i (Array.mem_range.mpr hi) + rw [List.all_eq_true] at this + have := this j (List.mem_range.mpr hj) + simp only [Bool.and_eq_true, decide_eq_true_eq, beq_iff_eq] at this + obtain ⟨⟨⟨ha, hb⟩, hc⟩, hd⟩ := this + exact ⟨ha, uclass_eq_of_beq hb, hc, hd⟩ + have hmem : ∀ i, i < comps.size → ∀ t ∈ comps[i]!.toList, + ∃ j, j < comps[i]!.size ∧ comps[i]![j]! = t := by + intro i _ t ht + obtain ⟨j, hj, rfl⟩ := List.mem_iff_getElem.mp ht + simp only [Array.length_toList] at hj + exact ⟨j, hj, by rw [arr_getElem!_eq _ hj]; rfl⟩ + have hcover : ∀ t, t < dag.size → cls[t]! = .uncertain → + ∃ i, i < comps.size ∧ label[t]! = some i ∧ t ∈ comps[i]!.toList := by + intro t ht hu + have := h2 t (Array.mem_range.mpr ht) + simp only [Bool.or_eq_true] at this + rcases this with h | h + · rw [hu] at h; exact absurd h (by decide) + · cases hl : label[t]! with + | none => rw [hl] at h; cases h + | some i => + rw [hl] at h + simp only [Bool.and_eq_true, decide_eq_true_eq] at h + exact ⟨i, h.1, rfl, Array.mem_toList_iff.mpr (Array.contains_iff_mem.mp h.2)⟩ + refine ⟨fun i hi t ht => ?_, fun i hi => ?_, fun t ht hu => ?_, fun a b ha hua hub hab => ?_⟩ + · obtain ⟨j, hj, rfl⟩ := hmem i hi t ht + exact ⟨(hcomp i hi j hj).1, (hcomp i hi j hj).2.1, (hcomp i hi j hj).2.2.1⟩ + · -- strictly increasing, hence duplicate-free + have hlt : ∀ a b, a < b → b < comps[i]!.size → comps[i]![a]! < comps[i]![b]! := by + intro a b hab hb + induction b with + | zero => omega + | succ b ihb => + have hstep := (hcomp i hi b (by omega)).2.2.2 hb + by_cases hab' : a = b + · subst hab'; exact hstep + · exact Nat.lt_trans (ihb (by omega) (by omega)) hstep + apply List.Pairwise.imp (R := (· < ·)) (fun h => Nat.ne_of_lt h) + rw [List.pairwise_iff_getElem] + intro a b ha hb hab + simp only [Array.length_toList] at ha hb + have := hlt a b hab hb + rw [arr_getElem!_eq _ ha, arr_getElem!_eq _ hb] at this + simpa using this + · exact hcover t ht hu + · have hmemu : a ∈ (Array.range dag.size).filter (cls[·]! == .uncertain) := by + rw [Array.mem_filter] + exact ⟨Array.mem_range.mpr ha, by rw [hua]; exact uclass_beq_self _⟩ + obtain ⟨ℓ, hℓ, hreach⟩ := labelsSeparated_spec hwf h3 hmemu ha + have hbn : b < dag.size := by + have := NReach.le_of_wf hwf hab ha + omega + obtain ⟨i, _, hlb, _⟩ := hcover b hbn hub + have := hreach b hab i hlb + rw [hℓ, hlb, this] + +/-! ## Reclassification bounds (B3a) -/ + +/-- Pointwise order of bound tables. -/ +def BLe (b b' : UBounds) : Prop := + ∀ t : Nat, b.inlineLB[t]! ≤ b'.inlineLB[t]! ∧ b.mergedLB[t]! ≤ b'.mergedLB[t]! ∧ + b.headLB[t]! ≤ b'.headLB[t]! ∧ b.contLB[t]! ≤ b'.contLB[t]! + +theorem arr_foldl_add_mono {f g : Nat → Nat} (a : Nat) (arr : Array Nat) (h : ∀ c, f c ≤ g c) : + arr.foldl (fun acc c => acc + f c) a ≤ arr.foldl (fun acc c => acc + g c) a := by + rw [arr_foldl_add_eq_sum, arr_foldl_add_eq_sum] + have := sum_le_sum_of_le arr.toList fun c _ => h c + omega + +theorem setBang_getElem!_le {a a' : Array Nat} {t v v' : Nat} (u : Nat) + (hs : a.size = a'.size) (hle : a[u]! ≤ a'[u]!) (hv : v ≤ v') : + (a.set! t v)[u]! ≤ (a'.set! t v')[u]! := by + rw [Ix.Compile.Verify.SharingExact.setBang_getElem!, Ix.Compile.Verify.SharingExact.setBang_getElem!] + by_cases h : t = u ∧ t < a.size + · rw [if_pos h, if_pos ⟨h.1, hs ▸ h.2⟩]; exact hv + · rw [if_neg h, if_neg (fun h' => h ⟨h'.1, hs ▸ h'.2⟩)]; exact hle + +/-- Fields of equal sizes. -/ +def BSize (b : UBounds) (n : Nat) : Prop := + b.inlineLB.size = n ∧ b.mergedLB.size = n ∧ b.headLB.size = n ∧ b.contLB.size = n + +theorem boundsStep_size {p : Prep} {w : Nat} {ms : Array Bool} {b : UBounds} {n : Nat} + (h : BSize b n) (t : Nat) : BSize (boundsStep p w ms b t) n := by + unfold boundsStep; simp only; split <;> simp [BSize] at h ⊢ <;> exact h + +/-- `boundsStep` is monotone in the bounds and antitone in the maybe-stored +set. -/ +theorem boundsStep_mono {p : Prep} {w : Nat} {ms ms' : Array Bool} {b b' : UBounds} {n : Nat} + (hle : BLe b b') (hms : ∀ v : Nat, ms'[v]! = true → ms[v]! = true) (hb : BSize b n) + (hb' : BSize b' n) (t : Nat) : BLe (boundsStep p w ms b t) (boundsStep p w ms' b' t) := by + intro u + obtain ⟨s1, s2, s3, s4⟩ := hb + obtain ⟨s1', s2', s3', s4'⟩ := hb' + have hhead : ∀ c, b.headLB[c]! ≤ b'.headLB[c]! := fun c => (hle c).2.2.1 + have hcont : ∀ c, b.contLB[c]! ≤ b'.contLB[c]! := fun c => (hle c).2.2.2 + have hcap : ∀ (x x' : Nat), x ≤ x' → + (if ms[t]! then min w x else x) ≤ (if ms'[t]! then min w x' else x') := by + intro x x' hx + cases h' : ms'[t]! + · cases ms[t]! <;> simp <;> omega + · rw [hms t h']; simp; omega + unfold boundsStep + simp only + split + · have hi := arr_foldl_add_mono (p.dag.node t).head.ownBytes (p.dag.node t).children hhead + exact ⟨setBang_getElem!_le u (by omega) (hle u).1 hi, + setBang_getElem!_le u (by omega) (hle u).2.1 hi, + setBang_getElem!_le u (by omega) (hle u).2.2.1 (hcap _ _ hi), + setBang_getElem!_le u (by omega) (hle u).2.2.2 (hcap _ _ hi)⟩ + · have hrest : (if p.family[(p.dag.node t).spineNext]! == p.family[t]! then + b.contLB[(p.dag.node t).spineNext]! else b.headLB[(p.dag.node t).spineNext]!) ≤ + (if p.family[(p.dag.node t).spineNext]! == p.family[t]! then + b'.contLB[(p.dag.node t).spineNext]! else b'.headLB[(p.dag.node t).spineNext]!) := by + split + · exact hcont _ + · exact hhead _ + have hm := Nat.add_le_add (Nat.add_le_add_left (hhead (p.dag.node t).sideChild) + (p.dag.node t).sideExtra) hrest + exact ⟨setBang_getElem!_le u (by omega) (hle u).1 (Nat.add_le_add_left hm 1), + setBang_getElem!_le u (by omega) (hle u).2.1 hm, + setBang_getElem!_le u (by omega) (hle u).2.2.1 (hcap _ _ (Nat.add_le_add_left hm 1)), + setBang_getElem!_le u (by omega) (hle u).2.2.2 (hcap _ _ hm)⟩ + +/-- **The bounds are antitone in the maybe-stored set.** -/ +theorem uniformBounds_antitone (p : Prep) (w : Nat) {ms ms' : Array Bool} + (hms : ∀ v : Nat, ms'[v]! = true → ms[v]! = true) : + BLe (uniformBounds p w ms) (uniformBounds p w ms') := by + let init : UBounds := + { inlineLB := Array.replicate p.dag.size 0, mergedLB := Array.replicate p.dag.size 0, + headLB := Array.replicate p.dag.size 0, contLB := Array.replicate p.dag.size 0 } + have hinit : BSize init p.dag.size := by simp [BSize, init] + have key : ∀ (l : List Nat) (b b' : UBounds), BLe b b' → BSize b p.dag.size → + BSize b' p.dag.size → + BLe (l.foldl (boundsStep p w ms) b) (l.foldl (boundsStep p w ms') b') := by + intro l + induction l with + | nil => intro b b' h _ _; exact h + | cons t ts ih => + intro b b' h hb hb' + exact ih _ _ (boundsStep_mono h hms hb hb' t) (boundsStep_size hb t) (boundsStep_size hb' t) + unfold uniformBounds + rw [foldRange_zero, foldRange_zero] + exact key _ init init (fun _ => ⟨Nat.le_refl _, Nat.le_refl _, Nat.le_refl _, Nat.le_refl _⟩) + hinit hinit + +theorem setBang_self {α : Type} [Inhabited α] (a : Array α) {t : Nat} (ht : t < a.size) : + a.set! t a[t]! = a := by + rw [Array.set!_eq_setIfInBounds, Array.setIfInBounds_def, dif_pos ht, getElem!_pos a t ht] + exact Array.set_getElem_self ht + +theorem uniformBounds_size (p : Prep) (w : Nat) (ms : Array Bool) : + BSize (uniformBounds p w ms) p.dag.size := by + have key : ∀ (l : List Nat) (b : UBounds), BSize b p.dag.size → + BSize (l.foldl (boundsStep p w ms) b) p.dag.size := by + intro l + induction l with + | nil => intro b h; exact h + | cons t ts ih => intro b h; exact ih _ (boundsStep_size h t) + unfold uniformBounds + rw [foldRange_zero] + exact key _ _ (by simp [BSize]) + +/-- `uniformBounds` is a fixed point of every step. -/ +theorem PrepWF.boundsStep_fix {p : Prep} (hp : PrepWF p) (w : Nat) (ms : Array Bool) {t : Nat} + (ht : t < p.dag.size) : + boundsStep p w ms (uniformBounds p w ms) t = uniformBounds p w ms := by + obtain ⟨h1, h2, h3, h4⟩ := hp.uniformBounds_spec w ms t ht + obtain ⟨s1, s2, s3, s4⟩ := uniformBounds_size p w ms + generalize uniformBounds p w ms = U at h1 h2 h3 h4 s1 s2 s3 s4 ⊢ + rcases U with ⟨I, M, H, C⟩ + simp only at h1 h2 h3 h4 s1 s2 s3 s4 + unfold boundsStep + simp only + split + · rename_i hf + have hf' : p.family[t]! = .none := by simpa using hf + obtain ⟨a, b⟩ := h1 hf' + simp only [UBounds.mk.injEq] + rw [← a] + refine ⟨setBang_self I (by omega), ?_, ?_, ?_⟩ + · rw [← b]; exact setBang_self M (by omega) + · rw [← h3]; exact setBang_self H (by omega) + · rw [← b, ← h4]; exact setBang_self C (by omega) + · rename_i hf + have hf' : p.family[t]! ≠ .none := by simpa using hf + obtain ⟨a, b⟩ := h2 hf' + have hrest : (if p.family[(p.dag.node t).spineNext]! == p.family[t]! then + C[(p.dag.node t).spineNext]! else H[(p.dag.node t).spineNext]!) = + (if p.family[snext p t]! = p.family[t]! then C[snext p t]! else H[snext p t]!) := by + unfold snext + by_cases hs : p.family[(p.dag.node t).spineNext]! = p.family[t]! + · simp [hs] + · simp [hs] + simp only [UBounds.mk.injEq] + rw [hrest, ← a, ← b] + refine ⟨setBang_self I (by omega), setBang_self M (by omega), ?_, ?_⟩ + · rw [← h3]; exact setBang_self H (by omega) + · rw [← h4]; exact setBang_self C (by omega) + +/-- **Reclassification bounds are below the bounds of the reduced maybe-stored +set.** Steps over any terms, from tables below, stay below. -/ +theorem PrepWF.boundsFold_le {p : Prep} (hp : PrepWF p) (w : Nat) {ms : Array Bool} : + ∀ (l : List Nat) (b : UBounds), BLe b (uniformBounds p w ms) → BSize b p.dag.size → + BLe (l.foldl (boundsStep p w ms) b) (uniformBounds p w ms) := by + intro l + induction l with + | nil => intro b h _; exact h + | cons t ts ih => + intro b h hb + apply ih _ _ (boundsStep_size hb t) + by_cases ht : t < p.dag.size + · have := boundsStep_mono (p := p) (w := w) (ms := ms) (ms' := ms) h (fun _ h => h) hb + (uniformBounds_size p w ms) t + rw [hp.boundsStep_fix w ms ht] at this + exact this + · -- out of range: nothing changes + intro u + obtain ⟨s1, s2, s3, s4⟩ := hb + unfold boundsStep + simp only + split <;> + · simp only [Array.set!_eq_setIfInBounds, + Array.setIfInBounds_eq_of_size_le (show b.inlineLB.size ≤ t by omega), + Array.setIfInBounds_eq_of_size_le (show b.mergedLB.size ≤ t by omega), + Array.setIfInBounds_eq_of_size_le (show b.headLB.size ≤ t by omega), + Array.setIfInBounds_eq_of_size_le (show b.contLB.size ≤ t by omega)] + exact h u + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformClasses.lean b/Ix/Compile/Verify/UniformClasses.lean new file mode 100644 index 000000000..47d4b210a --- /dev/null +++ b/Ix/Compile/Verify/UniformClasses.lean @@ -0,0 +1,2192 @@ +import Ix.Compile.Verify.UniformGain + +/-! +# Stage 3: the certain classes + +* **Slots.** In any writing, the inline occurrences of `t` plus its Shares + are the top (if it is `t`) plus one per edge from a written node into `t` + (`slots_edges`); the inline occurrences are the writes of `t` + (`count_written`). Summed over an encoding: `writes t + refs t = root + occurrences + [t stored] + Σ_y writes y · edges(y, t)`. +* **Visible counts.** Hence every encoding of a set `S ⊆ M` writes each + `t ∉ S` at least `visibleCounts … M` times, at least the head count at head + positions. +* **Certain-stored**, generalised to partial assignments: for any + maybe-stored set `M ⊇ S` and `t ∉ S`, the gain under `uniformBounds … M` + and the visible counts of `M` bounds the length drop of adding `t`, up to + the growth of the count's TagN; so a gain `≥ θ` puts `t` in every + minimum (over any class containing `S ∪ {t}`) that lies in `M`. +* **Certain-excluded**: the removal exchange and `refs ≤ occ` in a minimum + without unreferenced entries, on DAGs whose telescope spines are shorter + than `teleSubaddEnd` (`SpinesFit`: the TagN telescope headers are + subadditive there). +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact + +/-! ## Slots of a writing -/ + +/-- All edges from `y` into `t`. -/ +def edgeAll (p : Prep) (y t : Nat) : Nat := edgeMult p y t false + edgeMult p y t true + +theorem count_singleton' (a b : Nat) : [a].count b = if a = b then 1 else 0 := by + by_cases h : a = b + · subst h; simp + · rw [if_neg h, List.count_singleton] + simp only [beq_iff_eq] + split <;> omega + +theorem sharess_count (t : Nat) (l : List WTree) : + (WTree.sharess l).count t = (l.map fun T => T.shares.count t).sum := by + induction l with + | nil => rfl + | cons k ks ih => simp [WTree.sharess, List.count_append, ih] + +theorem writtens_count (p : Prep) (t : Nat) (l : List WTree) : + (WTree.writtens p l).count t = (l.map fun T => (T.written p).count t).sum := by + induction l with + | nil => rfl + | cons k ks ih => simp [WTree.writtens, List.count_append, ih] + +theorem count_zero_of_lt {l : List Nat} {t : Nat} (h : ∀ y ∈ l, y < t) : l.count t = 0 := by + rw [List.count_eq_zero] + intro ht + have := h t ht + omega + +/-- Every written node of a writing of `x` is at most `x`. -/ +theorem PrepWF.written_le {p : Prep} (hp : PrepWF p) {S : Nat → Bool} : + ∀ {x : Nat} {T : WTree}, Valid p S x T → x < p.dag.size → ∀ y ∈ T.written p, y ≤ x := by + intro x T h + induction h with + | share _ => intro _ y hy; simp [WTree.written] at hy + | @node x kids hf hlen _ ih => + intro hx y hy + simp only [WTree.written] at hy + rcases List.mem_cons.mp hy with rfl | hy + · exact Nat.le_refl _ + · obtain ⟨T, hT, hyT⟩ := writtens_mem hy + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hc := hp.dag.childAt_lt hx (k := i) (by omega) + have := ih i hi (by omega) y hyT + omega + | @teleCut x j sides hf hj1 hj hlen _ _ ih => + intro hx y hy + simp only [WTree.written, List.append_nil, List.mem_append] at hy + rcases hy with hy | hy + · obtain ⟨k, hk, rfl⟩ := List.mem_map.mp hy + exact hp.spineAt_le hx hf (by rw [List.mem_range] at hk; omega) + · obtain ⟨T, hT, hyT⟩ := writtens_mem hy + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hsl := hp.sideAt_lt hx hf (k := i) (by omega) + have := ih i hi (by omega) y hyT + omega + | @teleFull x sides tail hf hlen _ _ ih iht => + intro hx y hy + obtain ⟨_, _, _, htl, _⟩ := hp.spine x hx hf + simp only [WTree.written, List.mem_append] at hy + rcases hy with (hy | hy) | hy + · obtain ⟨k, hk, rfl⟩ := List.mem_map.mp hy + exact hp.spineAt_le hx hf (by rw [List.mem_range] at hk; omega) + · obtain ⟨T, hT, hyT⟩ := writtens_mem hy + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hsl := hp.sideAt_lt hx hf (k := i) (by omega) + have := ih i hi (by omega) y hyT + omega + · have := iht (by omega) y hy + omega + +theorem PrepWF.spineHit_self {p : Prep} (hp : PrepWF p) {x j : Nat} (hx : x < p.dag.size) + (hf : p.family[x]! ≠ .none) (hj : j ≤ p.spineLen[x]!) : spineHit p x j x = none := by + cases hs : spineHit p x j x with + | none => rfl + | some k => + obtain ⟨hk1, hkj, hk⟩ := spineHit_spec hs + have := hp.spineAt_strict hx hf (a := 0) (b := k) (by omega) (by omega) + rw [hk] at this + exact absurd this (Nat.lt_irrefl _) + +/-- The spine prefix of length `j` writes `t` once if `t` is its top or one of +its inner nodes. -/ +theorem PrepWF.spine_count {p : Prep} (hp : PrepWF p) {x j t : Nat} (hx : x < p.dag.size) + (hf : p.family[x]! ≠ .none) (hj : j ≤ p.spineLen[x]!) (hj1 : 1 ≤ j) : + ((List.range j).map (spineAt p x)).count t = + (if x = t then 1 else 0) + (if (spineHit p x j t).isSome then 1 else 0) := by + have huniq : ∀ a b, a < j → b < j → spineAt p x a = t → spineAt p x b = t → a = b := by + intro a b ha hb hPa hPb + rcases Nat.lt_trichotomy a b with hab | hab | hab + · have := hp.spineAt_strict hx hf hab (by omega); omega + · exact hab + · have := hp.spineAt_strict hx hf hab (by omega); omega + rw [List.count_eq_length_filter, filter_length_eq_sum, List.map_map] + have hfun : ((fun i => if (i == t) = true then 1 else 0) ∘ spineAt p x) = + fun k => if spineAt p x k = t then 1 else 0 := by + funext k; simp + rw [hfun, sum_indicator_unique (fun k => spineAt p x k = t) j huniq] + by_cases hxt : x = t + · subst hxt + have hnone : (spineHit p x j x).isSome = false := by + cases hs : (spineHit p x j x).isSome + · rfl + · obtain ⟨k, hk1, hkj, hk⟩ := spineHit_isSome_iff.mp hs + have := hp.spineAt_strict hx hf (a := 0) (b := k) (by omega) (by omega) + rw [hk] at this + exact absurd this (Nat.lt_irrefl _) + rw [if_pos ⟨0, by omega, rfl⟩, if_pos rfl, hnone] + rfl + · rw [if_neg hxt, Nat.zero_add] + congr 1 + apply propext + rw [spineHit_isSome_iff] + constructor + · rintro ⟨k, hk, hkt⟩ + refine ⟨k, ?_, hk, hkt⟩ + rcases Nat.eq_zero_or_pos k with h0 | h0 + · subst h0; exact absurd hkt hxt + · exact h0 + · rintro ⟨k, _, hk, hkt⟩ + exact ⟨k, hk, hkt⟩ + +/-- The writes of `t` in a writing are its inline occurrences. -/ +theorem PrepWF.count_written {p : Prep} (hp : PrepWF p) {S : Nat → Bool} (t : Nat) : + ∀ {x : Nat} {T : WTree}, Valid p S x T → x < p.dag.size → + (T.written p).count t = T.occH t + T.occC p t := by + intro x T h + induction h with + | share _ => intro _; simp [WTree.written, WTree.occH, WTree.occC] + | @node x kids hf hlen hkids ih => + intro hx + by_cases hxt : x = t + · subst hxt + have hle := hp.written_le (.node hf hlen hkids) hx + simp only [WTree.written, List.count_cons, WTree.occH, WTree.occC, if_true, beq_self_eq_true] + have : (WTree.writtens p kids).count x = 0 := by + apply count_zero_of_lt + intro y hy + obtain ⟨T, hT, hyT⟩ := writtens_mem hy + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hc := hp.dag.childAt_lt hx (k := i) (by omega) + have := hp.written_le (hkids i hi) (by omega) y hyT + omega + simp [this] + · simp only [WTree.written, List.count_cons, WTree.occH, WTree.occC, hxt, if_false, + occHs_eq, occCs_eq, writtens_count, beq_iff_eq] + rw [Nat.add_zero, ← sum_map_add'] + apply congrArg + apply List.map_congr_left + intro T hT + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hc := hp.dag.childAt_lt hx (k := i) (by omega) + exact ih i hi (by omega) + | @teleCut x j sides hf hj1 hj hlen hsides hS ih => + intro hx + have hside : ∀ T ∈ sides, (T.written p).count t = T.occH t + T.occC p t ∧ + ∀ y ∈ T.written p, y < x := by + intro T hT + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hsl := hp.sideAt_lt hx hf (k := i) (by omega) + exact ⟨ih i hi (by omega), fun y hy => by + have := hp.written_le (hsides i hi) (by omega) y hy; omega⟩ + have hspine := hp.spine_count (t := t) hx hf (Nat.le_of_lt hj) hj1 + simp only [WTree.written, List.append_nil, List.count_append, hspine, writtens_count] + by_cases hxt : x = t + · subst hxt + have hs0 : (sides.map fun T => (T.written p).count x).sum = 0 := + sum_map_eq_zero fun T hT => count_zero_of_lt (hside T hT).2 + rw [hs0] + simp [WTree.occH, WTree.occC, hp.spineHit_self hx hf (Nat.le_of_lt hj)] + · simp only [WTree.occH, WTree.occC, hxt, if_false, occHs_eq, occCs_eq, Nat.zero_add] + rw [List.map_congr_left (fun T hT => (hside T hT).1), sum_map_add'] + simp + omega + | @teleFull x sides tail hf hlen hsides htail ih iht => + intro hx + obtain ⟨hl1, _, _, htl, _⟩ := hp.spine x hx hf + have hside : ∀ T ∈ sides, (T.written p).count t = T.occH t + T.occC p t ∧ + ∀ y ∈ T.written p, y < x := by + intro T hT + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hsl := hp.sideAt_lt hx hf (k := i) (by omega) + exact ⟨ih i hi (by omega), fun y hy => by + have := hp.written_le (hsides i hi) (by omega) y hy; omega⟩ + have hspine := hp.spine_count (t := t) hx hf (Nat.le_refl _) (by omega) + have htl' := iht (by omega) + simp only [WTree.written, List.count_append, hspine, writtens_count, htl'] + by_cases hxt : x = t + · subst hxt + have hs0 : (sides.map fun T => (T.written p).count x).sum = 0 := + sum_map_eq_zero fun T hT => count_zero_of_lt (hside T hT).2 + have ht0 : (tail.written p).count x = 0 := by + apply count_zero_of_lt + intro y hy + have := hp.written_le htail (by omega) y hy + omega + rw [← htl', hs0, ht0] + simp [WTree.occH, WTree.occC, hp.spineHit_self hx hf (Nat.le_refl _)] + · simp only [WTree.occH, WTree.occC, hxt, if_false, occHs_eq, occCs_eq, Nat.zero_add] + rw [List.map_congr_left (fun T hT => (hside T hT).1), sum_map_add'] + omega + +/-- The term a writing writes (or shares). -/ +def WTree.label : WTree → Nat + | .share x => x + | .node x _ => x + | .tele x _ _ _ => x + +theorem label_eq {p : Prep} {S : Nat → Bool} {x : Nat} {T : WTree} (h : Valid p S x T) : + T.label = x := by + cases h <;> rfl + +theorem PrepWF.shares_count_zero {p : Prep} (hp : PrepWF p) {S : Nat → Bool} {x : Nat} + {T : WTree} (h : Valid p S x T) (hx : x < p.dag.size) (hns : T.isShare = false) (t : Nat) + (hxt : x ≤ t) : T.shares.count t = 0 := + count_zero_of_lt fun s hs => by have := (hp.shares_lt h hx s hs).2.2 hns; omega + +theorem PrepWF.edgeAll_zero {p : Prep} (hp : PrepWF p) {t : Nat} (l : List Nat) + (hl : ∀ y ∈ l, y ≤ t) : (l.map fun y => edgeAll p y t).sum = 0 := + sum_map_eq_zero fun y hy => by + unfold edgeAll + rw [edgeMult_zero_of_le hp (hl y hy), edgeMult_zero_of_le hp (hl y hy)] + +/-- The head edges of a telescope prefix of length `j < spineLen` into `t` +are its side edges. -/ +theorem PrepWF.spine_head_sides {p : Prep} (hp : PrepWF p) {x j t : Nat} (hx : x < p.dag.size) + (ht : t < p.dag.size) (hf : p.family[x]! ≠ .none) (hj : j ≤ p.spineLen[x]!) : + ((List.range j).map fun k => edgeMult p (spineAt p x k) t false).sum = + ((List.range j).map fun k => if sideAt p x k = t then 1 else 0).sum + + (if j = p.spineLen[x]! ∧ p.tail[x]! = t then 1 else 0) := by + have hk : ∀ k ∈ List.range j, spineAt p x k < p.dag.size ∧ p.family[spineAt p x k]! ≠ .none := by + intro k hk + rw [List.mem_range] at hk + obtain ⟨hts, htf, _⟩ := hp.spine_shift hx hf (k := k) (by omega) + exact ⟨hts, by rw [htf]; exact hf⟩ + rw [List.map_congr_left fun k hk1 => (hp.edgeMult_tele (hk k hk1).1 ht (hk k hk1).2).2] + rw [sum_map_add', hp.spine_head_edges hx hf hj] + rfl + +/-- The continuation edges of a telescope prefix cut at its node `j`: one if +`t` is among the nodes `1 … j`. -/ +theorem PrepWF.spine_cont_cut {p : Prep} (hp : PrepWF p) {x j t : Nat} (hx : x < p.dag.size) + (ht : t < p.dag.size) (hf : p.family[x]! ≠ .none) (hj : j < p.spineLen[x]!) + (hj1 : 1 ≤ j) : + ((List.range j).map fun k => edgeMult p (spineAt p x k) t true).sum = + (if (spineHit p x j t).isSome then 1 else 0) + (if spineAt p x j = t then 1 else 0) := by + have hk : ∀ k, k ≤ j → spineAt p x k < p.dag.size ∧ p.family[spineAt p x k]! ≠ .none := by + intro k hk + obtain ⟨hts, htf, _⟩ := hp.spine_shift hx hf (k := k) (by omega) + exact ⟨hts, by rw [htf]; exact hf⟩ + have hcont : ∀ m, m ≤ j → + ((List.range m).map fun k => edgeMult p (spineAt p x k) t true).sum = + ((List.range m).map fun k => + if snext p (spineAt p x k) = t ∧ p.family[t]! = p.family[spineAt p x k]! then 1 + else 0).sum := by + intro m hm + apply congrArg + apply List.map_congr_left + intro k hk1 + rw [List.mem_range] at hk1 + exact (hp.edgeMult_tele (hk k (by omega)).1 ht (hk k (by omega)).2).1 + by_cases hjt : spineAt p x j = t + · -- the cut node is `t`: its continuation edge is the last one + have hlt : ∀ k, 1 ≤ k → k < j → spineAt p x k ≠ t := by + intro k hk1 hkj h + have := hp.spineAt_strict hx hf (a := k) (b := j) hkj (by omega) + omega + have hnone : (spineHit p x j t).isSome = false := by + cases hs : (spineHit p x j t).isSome + · rfl + · obtain ⟨k, hk1, hkj, hk⟩ := spineHit_isSome_iff.mp hs + exact absurd hk (hlt k hk1 hkj) + have h1 := hp.spine_cont_edges hx hf (j := j + 1) (t := t) (by omega) (by + intro _ h + have := hp.spineAt_strict hx hf (a := j) (b := j + 1) (by omega) (by omega) + omega) + have hsome : (spineHit p x (j + 1) t).isSome = true := + spineHit_isSome_iff.mpr ⟨j, by omega, by omega, hjt⟩ + rw [hsome, sum_range_succ'] at h1 + have hlast : (if snext p (spineAt p x j) = t ∧ p.family[t]! = p.family[spineAt p x j]! then 1 + else 0) = 0 := by + rw [if_neg] + rintro ⟨h, _⟩ + rw [snext_spineAt] at h + have := hp.spineAt_strict hx hf (a := j) (b := j + 1) (by omega) (by omega) + omega + simp only [if_true] at h1 + rw [hlast] at h1 + rw [hcont j (Nat.le_refl _), hnone, if_pos hjt] + simp only [Bool.false_eq_true, if_false] + omega + · rw [hcont j (Nat.le_refl _), hp.spine_cont_edges hx hf (Nat.le_of_lt hj) (fun _ => hjt), + if_neg hjt, Nat.add_zero] + +/-- **Slots.** In a writing of `x`, the inline occurrences of `t` plus its +Shares are the top (if `x = t`) plus one per edge from a written node into +`t`. -/ +theorem PrepWF.slots_edges {p : Prep} (hp : PrepWF p) {S : Nat → Bool} {t : Nat} + (htn : t < p.dag.size) : + ∀ {x : Nat} {T : WTree}, Valid p S x T → x < p.dag.size → + T.occH t + T.occC p t + T.shares.count t = + (if x = t then 1 else 0) + ((T.written p).map fun y => edgeAll p y t).sum := by + intro x T h + induction h with + | share _ => + intro _ + simp [WTree.occH, WTree.occC, WTree.shares, WTree.written, count_singleton'] + | @node x kids hf hlen hkids ih => + intro hx + have hT : Valid p S x (.node x kids) := .node hf hlen hkids + by_cases hxt : x = t + · subst hxt + rw [hp.shares_count_zero hT hx rfl x (Nat.le_refl _), + hp.edgeAll_zero _ (hp.written_le hT hx)] + simp [WTree.occH, WTree.occC] + · have hper : ∀ T ∈ kids, T.occH t + T.occC p t + T.shares.count t = + (if T.label = t then 1 else 0) + ((T.written p).map fun y => edgeAll p y t).sum := by + intro T hT + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hc := hp.dag.childAt_lt hx (k := i) (by omega) + rw [ih i hi (by omega), label_eq (hkids i hi)] + have hind : (kids.map fun T => if T.label = t then 1 else 0).sum = edgeAll p x t := by + unfold edgeAll + rw [(hp.edgeMult_node hx hf t).1, (hp.edgeMult_node hx hf t).2, Nat.add_zero, + filter_length_eq_sum, sum_map_eq_range, hlen] + congr 1 + apply List.map_congr_left + intro i hi + rw [List.mem_range] at hi + rw [List.getElem?_eq_getElem (by omega), Option.getD_some, label_eq (hkids i (by omega))] + simp + simp only [WTree.occH, WTree.occC, WTree.shares, WTree.written, hxt, if_false, + occHs_eq, occCs_eq, sharess_count, List.map_cons, List.sum_cons, writtens_sum] + have e := congrArg List.sum (List.map_congr_left hper) + simp only [sum_map_add'] at e + omega + | @teleCut x j sides hf hj1 hj hlen hsides hS ih => + intro hx + have hT : Valid p S x (.tele x j sides (.share (spineAt p x j))) := + .teleCut hf hj1 hj hlen hsides hS + by_cases hxt : x = t + · subst hxt + rw [hp.shares_count_zero hT hx rfl x (Nat.le_refl _), + hp.edgeAll_zero _ (hp.written_le hT hx)] + simp [WTree.occH, WTree.occC] + · have hper : ∀ T ∈ sides, T.occH t + T.occC p t + T.shares.count t = + (if T.label = t then 1 else 0) + ((T.written p).map fun y => edgeAll p y t).sum := by + intro T hT + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hsl := hp.sideAt_lt hx hf (k := i) (by omega) + rw [ih i hi (by omega), label_eq (hsides i hi)] + have hind : (sides.map fun T => if T.label = t then 1 else 0).sum = + ((List.range j).map fun k => if sideAt p x k = t then 1 else 0).sum := by + rw [sum_map_eq_range, hlen] + congr 1 + apply List.map_congr_left + intro i hi + rw [List.mem_range] at hi + rw [List.getElem?_eq_getElem (by omega), Option.getD_some, label_eq (hsides i (by omega))] + have hH := hp.spine_head_sides hx htn hf (Nat.le_of_lt hj) + have hC := hp.spine_cont_cut hx htn hf hj hj1 + have hne : ¬(j = p.spineLen[x]! ∧ p.tail[x]! = t) := fun h => by omega + rw [if_neg hne] at hH + have e := congrArg List.sum (List.map_congr_left hper) + simp only [sum_map_add'] at e + have hsplit : (((List.range j).map (spineAt p x)).map fun y => edgeAll p y t).sum = + ((List.range j).map fun k => edgeMult p (spineAt p x k) t false).sum + + ((List.range j).map fun k => edgeMult p (spineAt p x k) t true).sum := by + rw [List.map_map, ← sum_map_add'] + rfl + simp only [WTree.occH, WTree.occC, WTree.shares, WTree.written, hxt, if_false, occHs_eq, + occCs_eq, sharess_count, List.count_append, count_singleton', writtens_sum, + List.map_append, List.sum_append, List.append_nil, Nat.zero_add, Nat.add_zero] + rw [hsplit, hH, hC] + omega + | @teleFull x sides tail hf hlen hsides htail ih iht => + intro hx + obtain ⟨hl1, _, _, htl, _⟩ := hp.spine x hx hf + have hT : Valid p S x (.tele x p.spineLen[x]! sides tail) := .teleFull hf hlen hsides htail + by_cases hxt : x = t + · subst hxt + rw [hp.shares_count_zero hT hx rfl x (Nat.le_refl _), + hp.edgeAll_zero _ (hp.written_le hT hx)] + simp [WTree.occH, WTree.occC] + · have hper : ∀ T ∈ sides, T.occH t + T.occC p t + T.shares.count t = + (if T.label = t then 1 else 0) + ((T.written p).map fun y => edgeAll p y t).sum := by + intro T hT + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hsl := hp.sideAt_lt hx hf (k := i) (by omega) + rw [ih i hi (by omega), label_eq (hsides i hi)] + have hind : (sides.map fun T => if T.label = t then 1 else 0).sum = + ((List.range p.spineLen[x]!).map fun k => if sideAt p x k = t then 1 else 0).sum := by + rw [sum_map_eq_range, hlen] + congr 1 + apply List.map_congr_left + intro i hi + rw [List.mem_range] at hi + rw [List.getElem?_eq_getElem (by omega), Option.getD_some, label_eq (hsides i (by omega))] + have htl' := iht (by omega) + have hH := hp.spine_head_sides hx htn hf (Nat.le_refl _) + have hC := (hp.spine_edges hx htn hf (Nat.le_refl _) (fun h => absurd h (Nat.lt_irrefl _))).2 + simp only [List.map_map, Function.comp_def] at hC + have hti : (if p.spineLen[x]! = p.spineLen[x]! ∧ p.tail[x]! = t then 1 else 0) = + (if p.tail[x]! = t then 1 else 0) := by + by_cases h : p.tail[x]! = t + · rw [if_pos ⟨rfl, h⟩, if_pos h] + · rw [if_neg (fun h' => h h'.2), if_neg h] + rw [hti] at hH + have e := congrArg List.sum (List.map_congr_left hper) + simp only [sum_map_add'] at e + have hsplit : (((List.range p.spineLen[x]!).map (spineAt p x)).map fun y => edgeAll p y t).sum = + ((List.range p.spineLen[x]!).map fun k => edgeMult p (spineAt p x k) t false).sum + + ((List.range p.spineLen[x]!).map fun k => edgeMult p (spineAt p x k) t true).sum := by + rw [List.map_map, ← sum_map_add'] + rfl + simp only [WTree.occH, WTree.occC, WTree.shares, WTree.written, hxt, if_false, occHs_eq, + occCs_eq, sharess_count, List.count_append, writtens_sum, List.map_append, + List.sum_append, Nat.zero_add] + rw [hsplit, hH, hC] + omega + +/-! ## Slots of an encoding -/ + +/-- The inline writes of `y` in an encoding (entries of `S`, root writings). -/ +def encWrites (p : Prep) (S : List Nat) (E : Nat → WTree) (R : List WTree) (y : Nat) : Nat := + (S.map fun s => ((E s).written p).count y).sum + (R.map fun T => (T.written p).count y).sum + +/-- The Shares of `y` in an encoding. -/ +def encRefs (S : List Nat) (E : Nat → WTree) (R : List WTree) (y : Nat) : Nat := + (S.map fun s => (E s).shares.count y).sum + (R.map fun T => T.shares.count y).sum + +theorem count_eq_sum_ind (l : List Nat) (t : Nat) : + l.count t = (l.map fun s => if s = t then 1 else 0).sum := by + induction l with + | nil => rfl + | cons x xs ih => + simp only [List.count_cons, List.map_cons, List.sum_cons, ih, beq_iff_eq] + omega + +theorem sum_ind_range {n y : Nat} (hy : y < n) (f : Nat → Nat) : + ((List.range n).map fun z => (if z = y then 1 else 0) * f z).sum = f y := by + induction n with + | zero => omega + | succ n ih => + rw [sum_range_succ'] + by_cases hyn : y = n + · subst hyn + rw [sum_zero_of_forall fun z hz => by rw [if_neg (by omega), Nat.zero_mul]] + simp + · rw [ih (by omega), if_neg (Ne.symm hyn)] + simp + +/-- A sum over a list of terms below `n` as a sum over `0 … n-1` weighted by +the counts. -/ +theorem sum_eq_count_range : ∀ {l : List Nat} {n : Nat}, (∀ y ∈ l, y < n) → ∀ (f : Nat → Nat), + (l.map f).sum = ((List.range n).map fun y => l.count y * f y).sum + | [], n, _, f => by + simp only [List.map_nil, List.sum_nil, List.count_nil, Nat.zero_mul] + exact (sum_map_eq_zero fun _ _ => rfl).symm + | x :: xs, n, hl, f => by + rw [List.map_cons, List.sum_cons, sum_eq_count_range (fun y hy => hl y (List.mem_cons_of_mem _ hy)) f] + have hx := hl x List.mem_cons_self + have : ((List.range n).map fun y => (x :: xs).count y * f y).sum = + ((List.range n).map fun y => (if y = x then 1 else 0) * f y).sum + + ((List.range n).map fun y => xs.count y * f y).sum := by + rw [← sum_map_add'] + apply congrArg + apply List.map_congr_left + intro y _ + rw [List.count_cons] + by_cases hyx : y = x + · subst hyx; simp [Nat.add_mul]; omega + · simp [Ne.symm hyx, hyx] + rw [this, sum_ind_range hx] + +theorem sum_comm_range {α : Type} (l : List α) (n : Nat) (g : α → Nat → Nat) : + (l.map fun a => ((List.range n).map fun y => g a y).sum).sum = + ((List.range n).map fun y => (l.map fun a => g a y).sum).sum := by + induction l with + | nil => + simp only [List.map_nil, List.sum_nil] + exact (sum_map_eq_zero fun _ _ => rfl).symm + | cons a as ih => + simp only [List.map_cons, List.sum_cons, ih] + rw [← sum_map_add'] + +theorem sum_mul_right' {α : Type} (l : List α) (f : α → Nat) (c : Nat) : + (l.map fun a => f a * c).sum = (l.map f).sum * c := by + induction l with + | nil => simp + | cons a as ih => simp only [List.map_cons, List.sum_cons, ih, Nat.add_mul] + +theorem label_root {p : Prep} {S : Nat → Bool} (t : Nat) : + ∀ {roots : List Nat} {rootsW : List WTree}, List.Forall₂ (Valid p S) roots rootsW → + (rootsW.map fun T => if T.label = t then 1 else 0).sum = roots.count t + | _, _, .nil => rfl + | r :: rs, T :: Ts, .cons hv hs => by + simp only [List.map_cons, List.sum_cons, List.count_cons, label_root t hs, label_eq hv, + beq_iff_eq] + omega + +/-- One writing: its writes plus Shares of `t` are its top plus one per edge +from each written term. -/ +theorem PrepWF.writing_slots {p : Prep} (hp : PrepWF p) {S : Nat → Bool} {t : Nat} + (htn : t < p.dag.size) {x : Nat} {T : WTree} (h : Valid p S x T) (hx : x < p.dag.size) : + (T.written p).count t + T.shares.count t = + (if x = t then 1 else 0) + + ((List.range p.dag.size).map fun y => (T.written p).count y * edgeAll p y t).sum := by + rw [hp.count_written t h hx, hp.slots_edges htn h hx, + sum_eq_count_range (n := p.dag.size) (fun y hy => by have := hp.written_le h hx y hy; omega)] + +/-- **Slots of an encoding.** `writes t + refs t = root occurrences + [t +stored] + Σ_y writes y · edges(y, t)`. -/ +theorem PrepWF.enc_slots {p : Prep} (hp : PrepWF p) {A : Nat → Bool} {S : List Nat} + {E : Nat → WTree} {roots : List Nat} {R : List WTree} (hEnc : EncodingWF p A S E roots R) + (hSin : ∀ s ∈ S, s < p.dag.size) (hroots : ∀ r ∈ roots, r < p.dag.size) {t : Nat} + (htn : t < p.dag.size) : + encWrites p S E R t + encRefs S E R t = roots.count t + S.count t + + ((List.range p.dag.size).map fun y => encWrites p S E R y * edgeAll p y t).sum := by + have hS : ∀ s ∈ S, ((E s).written p).count t + (E s).shares.count t = + (if s = t then 1 else 0) + + ((List.range p.dag.size).map fun y => ((E s).written p).count y * edgeAll p y t).sum := + fun s hs => hp.writing_slots htn (hEnc.1 s hs).1 (hSin s hs) + have hR : ∀ T ∈ R, (T.written p).count t + T.shares.count t = + (if T.label = t then 1 else 0) + + ((List.range p.dag.size).map fun y => (T.written p).count y * edgeAll p y t).sum := by + intro T hT + obtain ⟨r, hrm, hr⟩ := forall₂_mem_right' hEnc.2 T hT + rw [hp.writing_slots htn hr (hroots r hrm), label_eq hr] + have eS := congrArg List.sum (List.map_congr_left hS) + have eR := congrArg List.sum (List.map_congr_left hR) + simp only [sum_map_add'] at eS eR + rw [← count_eq_sum_ind] at eS + rw [label_root t hEnc.2] at eR + rw [sum_comm_range] at eS eR + unfold encWrites encRefs + have hsplit : ((List.range p.dag.size).map fun y => + ((S.map fun s => ((E s).written p).count y).sum + + (R.map fun T => (T.written p).count y).sum) * edgeAll p y t).sum = + ((List.range p.dag.size).map fun y => + (S.map fun s => ((E s).written p).count y * edgeAll p y t).sum).sum + + ((List.range p.dag.size).map fun y => + (R.map fun T => (T.written p).count y * edgeAll p y t).sum).sum := by + rw [← sum_map_add'] + apply congrArg + apply List.map_congr_left + intro y _ + rw [Nat.add_mul, sum_mul_right', sum_mul_right'] + rw [hsplit] + omega + +/-! ## Visible counts -/ + +theorem modify_addc_getElem! (acc : Array Nat) (c t a : Nat) : + (acc.modify c (· + a))[t]! = acc[t]! + (if c = t ∧ c < acc.size then a else 0) := by + simp only [getElem!_def, Array.getElem?_modify] + by_cases hct : c = t + · subst hct + by_cases hc : c < acc.size + · simp [hc] + · simp [hc] + · simp [hct] + +/-- The weight of a parent in `visibleCounts`. -/ +def visWeight (ms : Array Bool) (d : Array Nat) (y : Nat) : Nat := + if ms[y]! then 1 else min d[y]! visibleCap + +/-- The inner loop of `visibleCounts`: a parent adds its weight per edge. -/ +theorem vis_inner (ch : Nat → Nat) (ce : Nat → Bool) (wy : Nat) : + ∀ (l : List Nat) (st : Array Nat × Array Nat), + (∀ i ∈ l, ch i < st.1.size ∧ ch i < st.2.size) → + (∀ c, (l.foldl (fun (st : Array Nat × Array Nat) i => + (st.1.modify (ch i) (· + wy), if ce i then st.2 else st.2.modify (ch i) (· + wy))) st).1[c]! = + st.1[c]! + wy * (l.filter fun i => ch i == c).length) ∧ + (∀ c, (l.foldl (fun (st : Array Nat × Array Nat) i => + (st.1.modify (ch i) (· + wy), if ce i then st.2 else st.2.modify (ch i) (· + wy))) st).2[c]! = + st.2[c]! + wy * (l.filter fun i => ch i == c && !ce i).length) ∧ + (l.foldl (fun (st : Array Nat × Array Nat) i => + (st.1.modify (ch i) (· + wy), if ce i then st.2 else st.2.modify (ch i) (· + wy))) st).1.size = + st.1.size ∧ + (l.foldl (fun (st : Array Nat × Array Nat) i => + (st.1.modify (ch i) (· + wy), if ce i then st.2 else st.2.modify (ch i) (· + wy))) st).2.size = + st.2.size := by + intro l + induction l with + | nil => intro st _; simp + | cons i is ih => + intro st hl + rw [List.foldl_cons] + have hi := hl i List.mem_cons_self + have hsz2 : (if ce i then st.2 else st.2.modify (ch i) (· + wy)).size = st.2.size := by + split <;> simp + obtain ⟨h1, h2, h3, h4⟩ := ih (st.1.modify (ch i) (· + wy), + if ce i then st.2 else st.2.modify (ch i) (· + wy)) (fun j hj => by + have := hl j (List.mem_cons_of_mem _ hj) + simp only [Array.size_modify, hsz2] + exact this) + refine ⟨fun c => ?_, fun c => ?_, by rw [h3]; simp, by rw [h4, hsz2]⟩ + · rw [h1, modify_addc_getElem!, List.filter_cons] + by_cases hc : ch i = c + · subst hc + simp [hi.1, Nat.mul_add] + omega + · simp [hc] + · rw [h2, List.filter_cons] + by_cases hce : ce i + · simp [hce] + · simp only [hce, Bool.false_eq_true, if_false, Bool.not_false, Bool.and_true] + rw [modify_addc_getElem!] + by_cases hc : ch i = c + · subst hc + simp [hi.2, Nat.mul_add] + omega + · simp [hc] + +/-- **Propagated counts.** `propagateCounts dag roots weight` gives every term +`t` its root occurrences plus, per edge from `y`, the weight of `y` at its +final count. -/ +theorem propagateCounts_spec {dag : Dag} (h : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (weight : Nat → Nat → Nat) {t : Nat} + (ht : t < dag.size) : + (propagateCounts dag roots weight).1[t]! = roots.toList.count t + + ((List.range dag.size).map fun y => edgeAll (Prep.ofDag dag) y t * + weight y (propagateCounts dag roots weight).1[y]!).sum ∧ + (propagateCounts dag roots weight).2[t]! = roots.toList.count t + + ((List.range dag.size).map fun y => edgeMult (Prep.ofDag dag) y t false * + weight y (propagateCounts dag roots weight).1[y]!).sum := by + have hroots' : ∀ c ∈ roots.toList, c < (Array.replicate dag.size (0 : Nat)).size := by + intro c hc; simpa using hroots c hc + let base := roots.foldl (fun acc r => acc.modify r (· + 1)) (Array.replicate dag.size 0) + have hbase : ∀ t, base[t]! = roots.toList.count t ∧ base.size = dag.size := by + intro t + simp only [base] + rw [← Array.foldl_toList] + obtain ⟨h1, h2⟩ := foldl_modify_count roots.toList (Array.replicate dag.size 0) t hroots' + refine ⟨?_, by rw [h2]; simp⟩ + rw [h1] + have : (Array.replicate dag.size (0 : Nat))[t]! = 0 := by + simp only [getElem!_def, Array.getElem?_replicate] + by_cases ht : t < dag.size <;> simp [ht] + rw [this, Nat.zero_add] + let step := fun (st : Array Nat × Array Nat) (k : Nat) => + (List.range (dag.node (dag.size - 1 - k)).children.size).foldl + (fun (st' : Array Nat × Array Nat) i => + (st'.1.modify ((dag.node (dag.size - 1 - k)).child i) + (· + weight (dag.size - 1 - k) st.1[dag.size - 1 - k]!), + if continuationEdge (dag.node (dag.size - 1 - k)) i + (dag.node ((dag.node (dag.size - 1 - k)).child i)) then st'.2 + else st'.2.modify ((dag.node (dag.size - 1 - k)).child i) + (· + weight (dag.size - 1 - k) st.1[dag.size - 1 - k]!))) st + have hdef : propagateCounts dag roots weight = (List.range dag.size).foldl step (base, base) := by + unfold propagateCounts + rw [foldRange_zero] + -- one step: the parent `y` adds its weight per edge + have hstep : ∀ (st : Array Nat × Array Nat) (k : Nat), st.1.size = dag.size → + st.2.size = dag.size → k < dag.size → + (∀ c, (step st k).1[c]! = st.1[c]! + weight (dag.size - 1 - k) st.1[dag.size - 1 - k]! * + edgeAll (Prep.ofDag dag) (dag.size - 1 - k) c) ∧ + (∀ c, (step st k).2[c]! = st.2[c]! + weight (dag.size - 1 - k) st.1[dag.size - 1 - k]! * + edgeMult (Prep.ofDag dag) (dag.size - 1 - k) c false) ∧ + (step st k).1.size = dag.size ∧ (step st k).2.size = dag.size := by + intro st k hs1 hs2 hk + have hy : dag.size - 1 - k < dag.size := by omega + have har := h.arity _ hy + rw [← dag_node_eq hy] at har + have hlt : ∀ i ∈ List.range (dag.node (dag.size - 1 - k)).children.size, + (dag.node (dag.size - 1 - k)).child i < st.1.size ∧ + (dag.node (dag.size - 1 - k)).child i < st.2.size := by + intro i hi + have hi' := List.mem_range.mp hi + rw [Ix.Compile.Verify.SharingExact.child_eq_getElem _ i hi'] + have := h.child_lt hy (Array.getElem_mem hi') + omega + obtain ⟨h1, h2, h3, h4⟩ := vis_inner (dag.node (dag.size - 1 - k)).child + (fun i => continuationEdge (dag.node (dag.size - 1 - k)) i + (dag.node ((dag.node (dag.size - 1 - k)).child i))) + (weight (dag.size - 1 - k) st.1[dag.size - 1 - k]!) _ st hlt + refine ⟨fun c => ?_, fun c => ?_, by rw [h3, hs1], by rw [h4, hs2]⟩ + · rw [h1] + congr 2 + unfold edgeAll edgeMult + rw [ofDag_dag, ← har] + rw [filter_length_split (fun i => (dag.node (dag.size - 1 - k)).child i == c) + (fun i => continuationEdge (dag.node (dag.size - 1 - k)) i (dag.node c))] + · rw [h2] + congr 2 + unfold edgeMult + rw [ofDag_dag, ← har] + congr 1 + apply List.filter_congr + intro i _ + by_cases hc : (dag.node (dag.size - 1 - k)).child i = c + · rw [hc]; cases continuationEdge (dag.node (dag.size - 1 - k)) i (dag.node c) <;> simp + · simp only [beq_eq_false_iff_ne.mpr hc, Bool.false_and] + -- the invariant after `k` steps + have hinv : ∀ k, k ≤ dag.size → + ((List.range k).foldl step (base, base)).1.size = dag.size ∧ + ((List.range k).foldl step (base, base)).2.size = dag.size ∧ + ∀ t, t < dag.size → + ((List.range k).foldl step (base, base)).1[t]! = roots.toList.count t + + ((List.range dag.size).map fun y => if dag.size - k ≤ y then + edgeAll (Prep.ofDag dag) y t * + weight y ((List.range k).foldl step (base, base)).1[y]! else 0).sum ∧ + ((List.range k).foldl step (base, base)).2[t]! = roots.toList.count t + + ((List.range dag.size).map fun y => if dag.size - k ≤ y then + edgeMult (Prep.ofDag dag) y t false * + weight y ((List.range k).foldl step (base, base)).1[y]! else 0).sum := by + intro k + induction k with + | zero => + intro _ + simp only [List.range_zero, List.foldl_nil] + refine ⟨(hbase 0).2, (hbase 0).2, fun t _ => ⟨?_, ?_⟩⟩ + · rw [(hbase t).1, sum_zero_of_forall fun y hy => if_neg (by omega), Nat.add_zero] + · rw [(hbase t).1, sum_zero_of_forall fun y hy => if_neg (by omega), Nat.add_zero] + | succ k ih => + intro hk + obtain ⟨hs1, hs2, hv⟩ := ih (by omega) + rw [foldl_range_succ] + generalize hst : (List.range k).foldl step (base, base) = st at hs1 hs2 hv + obtain ⟨h1, h2, h3, h4⟩ := hstep st k hs1 hs2 (by omega) + have hw : ∀ y, dag.size - 1 - k ≤ y → weight y (step st k).1[y]! = weight y st.1[y]! := by + intro y hy + rw [h1 y] + have : edgeAll (Prep.ofDag dag) (dag.size - 1 - k) y = 0 := by + unfold edgeAll + have hp := prepWF_ofDag h + rw [edgeMult_zero_of_le hp hy, edgeMult_zero_of_le hp hy] + rw [this, Nat.mul_zero, Nat.add_zero] + have hsum : ∀ (e : Nat → Nat), ((List.range dag.size).map fun y => + if dag.size - (k + 1) ≤ y then e y * weight y (step st k).1[y]! else 0).sum = + ((List.range dag.size).map fun y => + if dag.size - k ≤ y then e y * weight y st.1[y]! else 0).sum + + weight (dag.size - 1 - k) st.1[dag.size - 1 - k]! * e (dag.size - 1 - k) := by + intro e + have hpt : ∀ y ∈ List.range dag.size, + (if dag.size - (k + 1) ≤ y then e y * weight y (step st k).1[y]! else 0) = + (if dag.size - k ≤ y then e y * weight y st.1[y]! else 0) + + (if y = dag.size - 1 - k then 1 else 0) * + (weight (dag.size - 1 - k) st.1[dag.size - 1 - k]! * e (dag.size - 1 - k)) := by + intro y hy + rw [List.mem_range] at hy + by_cases hy0 : y = dag.size - 1 - k + · subst hy0 + rw [if_pos (by omega), if_neg (by omega), if_pos rfl, hw _ (Nat.le_refl _)] + simp [Nat.mul_comm] + · simp only [if_neg hy0, Nat.zero_mul, Nat.add_zero] + by_cases hyk : dag.size - k ≤ y + · rw [if_pos (by omega), if_pos hyk, hw y (by omega)] + · rw [if_neg (by omega), if_neg hyk] + rw [List.map_congr_left hpt, sum_map_add', sum_ind_range (by omega)] + refine ⟨h3, h4, fun t ht => ⟨?_, ?_⟩⟩ + · rw [h1, (hv t ht).1, hsum (fun y => edgeAll (Prep.ofDag dag) y t)] + omega + · rw [h2, (hv t ht).2, hsum (fun y => edgeMult (Prep.ofDag dag) y t false)] + omega + obtain ⟨_, _, hfin⟩ := hinv dag.size (Nat.le_refl _) + rw [hdef] + obtain ⟨e1, e2⟩ := hfin t ht + refine ⟨?_, ?_⟩ + · rw [e1] + congr 2 + apply List.map_congr_left + intro y _ + rw [if_pos (by omega)] + · rw [e2] + congr 2 + apply List.map_congr_left + intro y _ + rw [if_pos (by omega)] + +/-! ## The gain algebra with occurrence lower bounds -/ + +/-- `max(x - w, 0)` as an integer. -/ +theorem pos_part_cases (x w : Nat) : + (w ≤ x ∧ (((if w ≤ x then x - w else 0 : Nat)) : _root_.Int) = (x : _root_.Int) - w) ∨ + (x < w ∧ (((if w ≤ x then x - w else 0 : Nat)) : _root_.Int) = 0) := by + by_cases h : w ≤ x + · left; rw [if_pos h]; exact ⟨h, by omega⟩ + · right; rw [if_neg h]; exact ⟨by omega, rfl⟩ + +theorem int_mul_le_mul_right' {a b c : _root_.Int} (hab : a ≤ b) (hc : 0 ≤ c) : + a * c ≤ b * c := _root_.Int.mul_le_mul_of_nonneg_right hab hc + +theorem int_mul_le_mul_left' {a b c : _root_.Int} (hab : a ≤ b) (hc : 0 ≤ c) : + c * a ≤ c * b := _root_.Int.mul_le_mul_of_nonneg_left hab hc + +/-- Non-telescope: `(d-1)·i⁻ - d·w ≤ H·max(I-w, 0) - I` when `1 ≤ d ≤ H`, +`i⁻ ≤ I`. -/ +theorem gain_alg_node (d H I iLB w Ah : _root_.Int) (hd1 : 1 ≤ d) (hdH : d ≤ H) (hiLB : iLB ≤ I) + (_hw : 0 ≤ w) (hA : (w ≤ I ∧ Ah = I - w) ∨ (I < w ∧ Ah = 0)) : + (d - 1) * iLB - d * w ≤ H * Ah - I := by + have e1 := int_mul_le_mul_left' hiLB (show (0 : _root_.Int) ≤ d - 1 by omega) + rcases hA with ⟨hwI, rfl⟩ | ⟨hIw, rfl⟩ + · have e2 := int_mul_le_mul_right' hdH (show (0 : _root_.Int) ≤ I - w by omega) + simp only [_root_.Int.sub_mul, _root_.Int.mul_sub, _root_.Int.one_mul] at e1 e2 ⊢ + omega + · have e2 := int_mul_le_mul_left' (show I ≤ w by omega) (show (0 : _root_.Int) ≤ d - 1 by omega) + simp only [_root_.Int.sub_mul, _root_.Int.one_mul, + _root_.Int.mul_zero] at e1 e2 ⊢ + omega + +/-- Telescope with a head occurrence: +`(d-1)·b + (h-1) - d·w ≤ H·max(I-w, 0) + C·max(M-w, 0) - I` when +`1 ≤ h ≤ H`, `h ≤ d ≤ H + C`, `b ≤ M`, `1 + M ≤ I`. -/ +theorem gain_alg_head (d h H C I M mLB w Ah Ac : _root_.Int) (hh1 : 1 ≤ h) (hhd : h ≤ d) + (hhH : h ≤ H) (hdHC : d ≤ H + C) (_hC0 : 0 ≤ C) (hmLB : mLB ≤ M) (hMI : 1 + M ≤ I) + (_hw : 0 ≤ w) (hAh : (w ≤ I ∧ Ah = I - w) ∨ (I < w ∧ Ah = 0)) + (hAc : (w ≤ M ∧ Ac = M - w) ∨ (M < w ∧ Ac = 0)) : + (d - 1) * mLB + (h - 1) - d * w ≤ H * Ah + C * Ac - I := by + have e1 := int_mul_le_mul_left' hmLB (show (0 : _root_.Int) ≤ d - 1 by omega) + rcases hAc with ⟨hwM, rfl⟩ | ⟨hMw, rfl⟩ + · rcases hAh with ⟨_, rfl⟩ | ⟨hIw, _⟩ + · -- H(I-w) = H(I-M-1) + H(M-w) + H ≥ (I-M-1) + H(M-w) + h + have e2 := int_mul_le_mul_right' (show (1 : _root_.Int) ≤ H by omega) + (show (0 : _root_.Int) ≤ I - M - 1 by omega) + have e3 := int_mul_le_mul_right' hdHC (show (0 : _root_.Int) ≤ M - w by omega) + simp only [_root_.Int.sub_mul, _root_.Int.mul_sub, _root_.Int.one_mul, _root_.Int.add_mul, + _root_.Int.mul_one] at e1 e2 e3 ⊢ + omega + · omega + · have e2 := int_mul_le_mul_left' (show mLB ≤ w - 1 by omega) (show (0 : _root_.Int) ≤ d - 1 by omega) + rcases hAh with ⟨hwI, rfl⟩ | ⟨hIw, rfl⟩ + · have e3 := int_mul_le_mul_right' (show (1 : _root_.Int) ≤ H by omega) + (show (0 : _root_.Int) ≤ I - w by omega) + simp only [_root_.Int.sub_mul, _root_.Int.mul_sub, _root_.Int.one_mul, _root_.Int.mul_one, + _root_.Int.mul_zero] at e1 e2 e3 ⊢ + omega + · simp only [_root_.Int.sub_mul, _root_.Int.mul_sub, _root_.Int.one_mul, _root_.Int.mul_one, + _root_.Int.mul_zero] at e1 e2 ⊢ + omega + +/-- Telescope without head occurrences: +`(d-1)·b - T - d·w ≤ H·max(I-w, 0) + C·max(M-w, 0) - I` when +`1 ≤ d ≤ H + C`, `b ≤ M`, `1 + M ≤ I ≤ T + M`. -/ +theorem gain_alg_cont (d H C I M mLB T w Ah Ac : _root_.Int) (hd1 : 1 ≤ d) (hdHC : d ≤ H + C) + (hH0 : 0 ≤ H) (_hC0 : 0 ≤ C) (hmLB : mLB ≤ M) (hMI : 1 + M ≤ I) (hIT : I ≤ T + M) + (_hw : 0 ≤ w) (hAh : (w ≤ I ∧ Ah = I - w) ∨ (I < w ∧ Ah = 0)) + (hAc : (w ≤ M ∧ Ac = M - w) ∨ (M < w ∧ Ac = 0)) : + (d - 1) * mLB - T - d * w ≤ H * Ah + C * Ac - I := by + have e1 := int_mul_le_mul_left' hmLB (show (0 : _root_.Int) ≤ d - 1 by omega) + rcases hAc with ⟨hwM, rfl⟩ | ⟨hMw, rfl⟩ + · rcases hAh with ⟨_, rfl⟩ | ⟨hIw, _⟩ + · have e2 := int_mul_le_mul_left' (show M - w ≤ I - w by omega) hH0 + have e3 := int_mul_le_mul_right' hdHC (show (0 : _root_.Int) ≤ M - w by omega) + simp only [_root_.Int.sub_mul, _root_.Int.mul_sub, _root_.Int.one_mul, + _root_.Int.add_mul] at e1 e2 e3 ⊢ + omega + · omega + · have e2 := int_mul_le_mul_left' (show mLB ≤ w - 1 by omega) (show (0 : _root_.Int) ≤ d - 1 by omega) + have e3 : 0 ≤ H * Ah := by + rcases hAh with ⟨hwI, rfl⟩ | ⟨_, rfl⟩ + · exact _root_.Int.mul_nonneg hH0 (by omega) + · simp + simp only [_root_.Int.sub_mul, _root_.Int.mul_sub, _root_.Int.one_mul, _root_.Int.mul_one, + _root_.Int.mul_zero] at e1 e2 ⊢ + omega + +/-- **Visible counts.** `visibleCounts dag roots ms` gives every term `t` its +root occurrences plus, per edge from `y`, the weight of `y`: 1 if `ms[y]`, +else the (capped) count of `y`. -/ +theorem visibleCounts_spec {dag : Dag} (h : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (ms : Array Bool) {t : Nat} + (ht : t < dag.size) : + (visibleCounts dag roots ms).1[t]! = roots.toList.count t + + ((List.range dag.size).map fun y => edgeAll (Prep.ofDag dag) y t * + visWeight ms (visibleCounts dag roots ms).1 y).sum ∧ + (visibleCounts dag roots ms).2[t]! = roots.toList.count t + + ((List.range dag.size).map fun y => edgeMult (Prep.ofDag dag) y t false * + visWeight ms (visibleCounts dag roots ms).1 y).sum := + propagateCounts_spec h roots hroots _ ht + +/-- **Occurrences.** `occurrences dag roots` counts every root occurrence +plus, per edge from `y`, the occurrences of `y`. -/ +theorem occurrences_spec {dag : Dag} (h : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) {t : Nat} (ht : t < dag.size) : + (occurrences dag roots)[t]! = roots.toList.count t + + ((List.range dag.size).map fun y => edgeAll (Prep.ofDag dag) y t * + (occurrences dag roots)[y]!).sum := + (propagateCounts_spec h roots hroots (fun _ c => c) ht).1 + +/-! ## Writes of an encoding and the visible counts -/ + +open Ix.Compile.Verify.SharingExact (Desc) + +theorem le_sum_map_of_mem {α : Type} (f : α → Nat) {l : List α} {a : α} (h : a ∈ l) : + f a ≤ (l.map f).sum := by + induction l with + | nil => cases h + | cons x xs ih => + simp only [List.map_cons, List.sum_cons] + rcases List.mem_cons.mp h with rfl | h + · omega + · have := ih h; omega + +theorem PrepWF.refs_zero {p : Prep} (hp : PrepWF p) {S : List Nat} {E : Nat → WTree} + {roots : List Nat} {R : List WTree} + (hEnc : EncodingWF p (fun y => decide (y ∈ S)) S E roots R) + (hSin : ∀ s ∈ S, s < p.dag.size) (hroots : ∀ r ∈ roots, r < p.dag.size) {t : Nat} + (htS : t ∉ S) : encRefs S E R t = 0 := by + have hz : ∀ {x : Nat} {T : WTree}, Valid p (fun y => decide (y ∈ S)) x T → x < p.dag.size → + T.shares.count t = 0 := by + intro x T hv hx + rw [List.count_eq_zero] + intro hs + have := (hp.shares_lt hv hx t hs).1 + simp only [decide_eq_true_eq] at this + exact htS this + unfold encRefs + rw [sum_map_eq_zero (fun s hs => hz (hEnc.1 s hs).1 (hSin s hs)), + sum_map_eq_zero (fun T hT => by + obtain ⟨r, hrm, hr⟩ := forall₂_mem_right' hEnc.2 T hT + exact hz hr (hroots r hrm))] + +theorem PrepWF.writes_pos {p : Prep} (hp : PrepWF p) {S : List Nat} {E : Nat → WTree} + {roots : List Nat} {R : List WTree} + (hEnc : EncodingWF p (fun y => decide (y ∈ S)) S E roots R) + (hSin : ∀ s ∈ S, s < p.dag.size) (hroots : ∀ r ∈ roots, r < p.dag.size) + (hreach : ∀ y, y < p.dag.size → ∃ r ∈ roots, Desc p.dag r y) : + ∀ y, y < p.dag.size → 1 ≤ encWrites p S E R y := by + intro y hy + have hc := hp.encoding_covers hEnc hSin hroots hreach y hy + unfold encWrites + rcases List.mem_append.mp hc with hc | hc + · obtain ⟨l, hl, hyl⟩ := List.mem_flatten.mp hc + obtain ⟨T, hT, rfl⟩ := List.mem_map.mp hl + have h1 : 1 ≤ (T.written p).count y := List.count_pos_iff.mpr hyl + have := le_sum_map_of_mem (fun T => (T.written p).count y) hT + omega + · obtain ⟨l, hl, hyl⟩ := List.mem_flatten.mp hc + obtain ⟨s, hs, rfl⟩ := List.mem_map.mp hl + have h1 : 1 ≤ ((E s).written p).count y := List.count_pos_iff.mpr hyl + have := le_sum_map_of_mem (fun s => ((E s).written p).count y) hs + omega + +theorem PrepWF.writes_unstored {p : Prep} (hp : PrepWF p) {S : List Nat} {E : Nat → WTree} + {roots : List Nat} {R : List WTree} + (hEnc : EncodingWF p (fun y => decide (y ∈ S)) S E roots R) + (hSin : ∀ s ∈ S, s < p.dag.size) (hroots : ∀ r ∈ roots, r < p.dag.size) {y : Nat} + (hy : y < p.dag.size) (hyS : y ∉ S) : + encWrites p S E R y = roots.count y + + ((List.range p.dag.size).map fun z => encWrites p S E R z * edgeAll p z y).sum := by + have := hp.enc_slots hEnc hSin hroots hy + rw [hp.refs_zero hEnc hSin hroots hyS, List.count_eq_zero_of_not_mem hyS] at this + omega + +theorem edgeAll_zero_of_le {p : Prep} (hp : PrepWF p) {z y : Nat} (h : z ≤ y) : + edgeAll p z y = 0 := by + unfold edgeAll + rw [edgeMult_zero_of_le hp h, edgeMult_zero_of_le hp h] + +/-- **Visible counts are lower bounds.** In an encoding of `S ⊆ ms`, every +term gets at least its weight in writes, and every `t ∉ S` at least its +visible count. -/ +theorem writes_ge_visible {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y) + (ms : Array Bool) {S : List Nat} (hSin : ∀ s ∈ S, s < dag.size) + (hSms : ∀ s ∈ S, ms[s]! = true) {E : Nat → WTree} {R : List WTree} + (hEnc : EncodingWF (Prep.ofDag dag) (fun y => decide (y ∈ S)) S E roots.toList R) : + ∀ y, y < dag.size → + visWeight ms (visibleCounts dag roots ms).1 y ≤ encWrites (Prep.ofDag dag) S E R y ∧ + (y ∉ S → (visibleCounts dag roots ms).1[y]! ≤ encWrites (Prep.ofDag dag) S E R y) := by + have hp := prepWF_ofDag hwf + have hpos := hp.writes_pos hEnc hSin hroots hreach + have key : ∀ m, ∀ y, dag.size - y ≤ m → y < dag.size → + visWeight ms (visibleCounts dag roots ms).1 y ≤ encWrites (Prep.ofDag dag) S E R y ∧ + (y ∉ S → (visibleCounts dag roots ms).1[y]! ≤ encWrites (Prep.ofDag dag) S E R y) := by + intro m + induction m with + | zero => intro y hym hy; omega + | succ m ih => + intro y hym hy + have hstep : y ∉ S → (visibleCounts dag roots ms).1[y]! ≤ + encWrites (Prep.ofDag dag) S E R y := by + intro hyS + rw [(visibleCounts_spec hwf roots hroots ms hy).1, + hp.writes_unstored hEnc hSin hroots hy hyS] + apply Nat.add_le_add_left + apply sum_le_sum_of_le + intro z hz + rw [List.mem_range] at hz + by_cases hzy : y < z + · rw [Nat.mul_comm] + exact Nat.mul_le_mul_right _ (ih z (by omega) hz).1 + · rw [edgeAll_zero_of_le hp (by omega)] + simp + refine ⟨?_, hstep⟩ + unfold visWeight + split + · exact hpos y hy + · rename_i hms + have hyS : y ∉ S := fun h => hms (hSms y h) + exact Nat.le_trans (Nat.min_le_left _ _) (hstep hyS) + intro y hy + exact key (dag.size - y) y (Nat.le_refl _) hy + +/-- The head occurrences of `t ∉ S` in an encoding: the root occurrences plus +one per non-continuation edge from each write. -/ +theorem PrepWF.heads_eq {p : Prep} (hp : PrepWF p) {S : List Nat} {E : Nat → WTree} + {roots : List Nat} {R : List WTree} + (hEnc : EncodingWF p (fun y => decide (y ∈ S)) S E roots R) + (hSin : ∀ s ∈ S, s < p.dag.size) (hroots : ∀ r ∈ roots, r < p.dag.size) {t : Nat} + (htn : t < p.dag.size) (htS : t ∉ S) : + (S.map fun s => (E s).occH t).sum + (R.map (WTree.occH t)).sum = roots.count t + + ((List.range p.dag.size).map fun y => encWrites p S E R y * edgeMult p y t false).sum := by + have hSt : (fun y => decide (y ∈ S)) t = false := by simp [htS] + have hone : ∀ {x : Nat} {T : WTree}, Valid p (fun y => decide (y ∈ S)) x T → x < p.dag.size → + T.occH t = (if T.topIs t then 1 else 0) + + ((List.range p.dag.size).map fun y => (T.written p).count y * edgeMult p y t false).sum := by + intro x T hv hx + rw [(hp.occ_edges hSt htn hv hx).1, sum_eq_count_range (n := p.dag.size) + (fun y hy => by have := hp.written_le hv hx y hy; omega)] + have eS := congrArg List.sum (List.map_congr_left fun s hs => hone (hEnc.1 s hs).1 (hSin s hs)) + have eR := congrArg List.sum (List.map_congr_left fun T hT => by + obtain ⟨r, hrm, hr⟩ := forall₂_mem_right' hEnc.2 T hT + exact hone hr (hroots r hrm)) + simp only [sum_map_add'] at eS eR + have htopS : (S.map fun s => if (E s).topIs t then 1 else 0).sum = 0 := by + apply sum_map_eq_zero + intro s hs + rw [if_neg] + intro h + have := (top_iff hSt (hEnc.1 s hs).1).mp h + exact htS (this ▸ hs) + rw [htopS, sum_comm_range] at eS + rw [topIs_root hSt hEnc.2, sum_comm_range] at eR + rw [eS, eR] + unfold encWrites + have hsplit : ((List.range p.dag.size).map fun y => + ((S.map fun s => ((E s).written p).count y).sum + + (R.map fun T => (T.written p).count y).sum) * edgeMult p y t false).sum = + ((List.range p.dag.size).map fun y => + (S.map fun s => ((E s).written p).count y * edgeMult p y t false).sum).sum + + ((List.range p.dag.size).map fun y => + (R.map fun T => (T.written p).count y * edgeMult p y t false).sum).sum := by + rw [← sum_map_add'] + apply congrArg + apply List.map_congr_left + intro y _ + rw [Nat.add_mul, sum_mul_right', sum_mul_right'] + rw [hsplit] + omega + +theorem heads_ge_visible {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y) + (ms : Array Bool) {S : List Nat} (hSin : ∀ s ∈ S, s < dag.size) + (hSms : ∀ s ∈ S, ms[s]! = true) {E : Nat → WTree} {R : List WTree} + (hEnc : EncodingWF (Prep.ofDag dag) (fun y => decide (y ∈ S)) S E roots.toList R) {t : Nat} + (htn : t < dag.size) (htS : t ∉ S) : + (visibleCounts dag roots ms).2[t]! ≤ + (S.map fun s => (E s).occH t).sum + (R.map (WTree.occH t)).sum := by + have hp := prepWF_ofDag hwf + rw [hp.heads_eq hEnc hSin hroots htn htS, (visibleCounts_spec hwf roots hroots ms htn).2] + apply Nat.add_le_add_left + apply sum_le_sum_of_le + intro z hz + rw [List.mem_range] at hz + rw [Nat.mul_comm] + exact Nat.mul_le_mul_right _ + (writes_ge_visible hwf roots hroots hreach ms hSin hSms hEnc z hz).1 + +/-! ## The exchange with visible counts -/ + +theorem PrepWF.occs_eq_writes {p : Prep} (hp : PrepWF p) {S : List Nat} {E : Nat → WTree} + {roots : List Nat} {R : List WTree} + (hEnc : EncodingWF p (fun y => decide (y ∈ S)) S E roots R) + (hSin : ∀ s ∈ S, s < p.dag.size) (hroots : ∀ r ∈ roots, r < p.dag.size) (t : Nat) : + ((S.map fun s => (E s).occH t).sum + (R.map (WTree.occH t)).sum) + + ((S.map fun s => (E s).occC p t).sum + (R.map (WTree.occC p t)).sum) = + encWrites p S E R t := by + have eS := congrArg List.sum (List.map_congr_left fun s hs => + hp.count_written t (hEnc.1 s hs).1 (hSin s hs)) + have eR := congrArg List.sum (List.map_congr_left fun T hT => by + obtain ⟨r, hrm, hr⟩ := forall₂_mem_right' hEnc.2 T hT + exact hp.count_written t hr (hroots r hrm)) + simp only [sum_map_add'] at eS eR + unfold encWrites + omega + +theorem PrepWF.conts_zero {p : Prep} (hp : PrepWF p) {S : List Nat} {E : Nat → WTree} + {roots : List Nat} {R : List WTree} + (hEnc : EncodingWF p (fun y => decide (y ∈ S)) S E roots R) + (hSin : ∀ s ∈ S, s < p.dag.size) (hroots : ∀ r ∈ roots, r < p.dag.size) {t : Nat} + (htn : t < p.dag.size) (htS : t ∉ S) (hf : p.family[t]! = .none) : + (S.map fun s => (E s).occC p t).sum + (R.map (WTree.occC p t)).sum = 0 := by + have hSt : (fun y => decide (y ∈ S)) t = false := by simp [htS] + have hz : ∀ {x : Nat} {T : WTree}, Valid p (fun y => decide (y ∈ S)) x T → x < p.dag.size → + T.occC p t = 0 := by + intro x T hv hx + rw [(hp.occ_edges hSt htn hv hx).2.1] + exact sum_map_eq_zero fun y _ => edgeMult_cont_zero hp htn hf y + rw [sum_map_eq_zero (fun s hs => hz (hEnc.1 s hs).1 (hSin s hs)), + sum_map_eq_zero (fun T hT => by + obtain ⟨r, hrm, hr⟩ := forall₂_mem_right' hEnc.2 T hT + exact hz hr (hroots r hrm))] + +/-- **The exchange, generalised.** For any maybe-stored set `ms ⊇ S` and +`t ∉ S`, any bounds `b` below `uniformBounds … ms` at `t` and any lower +bounds `h ≤ d` (with `1 ≤ d`) of the visible counts of `ms` at `t`: +adding `t` to `S` shortens the uniform length by at least the gain, up to +the growth of the count's TagN: +`L(S ∪ {t}) + tag0Size |S| ≤ L(S) - storedGainWith b w t d h + tag0Size (|S|+1)`. -/ +theorem uniformCost_insert_le_counts {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y) + (w : Nat) (ms : Array Bool) {S : List Nat} (hSin : ∀ s ∈ S, s < dag.size) + (hSms : ∀ s ∈ S, ms[s]! = true) {t : Nat} (htn : t < dag.size) (htS : t ∉ S) + {b : UBounds} + (hbI : b.inlineLB[t]! ≤ (uniformBounds (Prep.ofDag dag) w ms).inlineLB[t]!) + (hbM : b.mergedLB[t]! ≤ (uniformBounds (Prep.ofDag dag) w ms).mergedLB[t]!) + {d h : Nat} (hd : d ≤ (visibleCounts dag roots ms).1[t]!) + (hh : h ≤ (visibleCounts dag roots ms).2[t]!) (hhd : h ≤ d) (hd1 : 1 ≤ d) : + ((uniformCost (Prep.ofDag dag) w (fun y => decide (y ∈ t :: S)) (t :: S) roots.toList : Nat) : + _root_.Int) + (tag0Size S.length : _root_.Int) ≤ + (uniformCost (Prep.ofDag dag) w (fun y => decide (y ∈ S)) S roots.toList : _root_.Int) - + storedGainWith (Prep.ofDag dag) b w t d h + (tag0Size (S.length + 1) : _root_.Int) := by + have hp := prepWF_ofDag hwf + have hSin' : ∀ s ∈ S, s < (Prep.ofDag dag).dag.size := by rw [ofDag_dag]; exact hSin + have hroots' : ∀ r ∈ roots.toList, r < (Prep.ofDag dag).dag.size := by + rw [ofDag_dag]; exact hroots + have htn' : t < (Prep.ofDag dag).dag.size := by rw [ofDag_dag]; exact htn + obtain ⟨E, R, hEnc, hcost⟩ := + hp.uniformCost_attained w (fun y => decide (y ∈ S)) S roots.toList hSin' hroots' + have hx := hp.exchange_counts w hSin' roots.toList hroots' htn' htS hEnc hcost + simp only at hx + have hHC := hp.occs_eq_writes hEnc hSin' hroots' t + have hvis := (writes_ge_visible hwf roots hroots hreach ms hSin hSms hEnc t htn).2 htS + have hhead := heads_ge_visible hwf roots hroots hreach ms hSin hSms hEnc htn htS + generalize (S.map fun s => (E s).occH t).sum + (R.map (WTree.occH t)).sum = H at hx hHC hhead + generalize hCdef : (S.map fun s => (E s).occC (Prep.ofDag dag) t).sum + + (R.map (WTree.occC (Prep.ofDag dag) t)).sum = C at hx hHC + have hb := hp.bounds_sound w ms (fun y => decide (y ∈ S)) + (fun y hy => hSms y (by simpa using hy)) t htn' + have hIMb : (Prep.ofDag dag).family[t]! ≠ .none → + 1 + mergedOf (Prep.ofDag dag) w (fun y => decide (y ∈ S)) + (uCost (Prep.ofDag dag) w fun y => decide (y ∈ S)) t ≤ + uInl (Prep.ofDag dag) w (fun y => decide (y ∈ S)) t ∧ + uInl (Prep.ofDag dag) w (fun y => decide (y ∈ S)) t ≤ + tag4Size (Prep.ofDag dag).spineLen[t]! + mergedOf (Prep.ofDag dag) w + (fun y => decide (y ∈ S)) (uCost (Prep.ofDag dag) w fun y => decide (y ∈ S)) t := + fun hf => inl_merged_bounds _ w _ _ hf + have hAh := pos_part_cases (uInl (Prep.ofDag dag) w (fun y => decide (y ∈ S)) t) w + have hAc := pos_part_cases (mergedOf (Prep.ofDag dag) w (fun y => decide (y ∈ S)) + (uCost (Prep.ofDag dag) w fun y => decide (y ∈ S)) t) w + generalize uInl (Prep.ofDag dag) w (fun y => decide (y ∈ S)) t = I at hx hb hIMb hAh + generalize mergedOf (Prep.ofDag dag) w (fun y => decide (y ∈ S)) + (uCost (Prep.ofDag dag) w fun y => decide (y ∈ S)) t = M at hx hb hIMb hAc + generalize (if w ≤ I then I - w else 0) = Ah at hx hAh + generalize (if w ≤ M then M - w else 0) = Ac at hx hAc + have hexI := _root_.Int.ofNat_le.mpr hx + simp only [_root_.Int.natCast_add, _root_.Int.natCast_mul] at hexI + unfold storedGainWith + simp only [_root_.Int.ofNat_eq_natCast] + by_cases hf : (Prep.ofDag dag).family[t]! = .none + · have hC0 : C = 0 := by + rw [← hCdef] + exact hp.conts_zero hEnc hSin' hroots' htn' htS hf + subst hC0 + have hfb : ((Prep.ofDag dag).family[t]! == Family.none) = true := by simp [hf] + simp only [hfb, if_true] + have e := gain_alg_node (d : _root_.Int) (H : _root_.Int) (I : _root_.Int) + (b.inlineLB[t]! : _root_.Int) (w : _root_.Int) (Ah : _root_.Int) (by omega) (by omega) + (by have := hb.2.1; omega) (by omega) (by rcases hAh with ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> omega) + simp only [_root_.Int.natCast_zero, _root_.Int.zero_mul, _root_.Int.add_zero] at hexI + omega + · have hfb : ((Prep.ofDag dag).family[t]! == Family.none) = false := by simpa using hf + simp only [hfb, Bool.false_eq_true, if_false] + have hmLB := (hb.2.2 hf).1 + obtain ⟨hIM1, hIM2⟩ := hIMb hf + by_cases hH1 : h ≥ 1 + · rw [if_pos hH1] + have e := gain_alg_head (d : _root_.Int) (h : _root_.Int) (H : _root_.Int) (C : _root_.Int) + (I : _root_.Int) (M : _root_.Int) (b.mergedLB[t]! : _root_.Int) (w : _root_.Int) + (Ah : _root_.Int) (Ac : _root_.Int) (by omega) (by omega) (by omega) (by omega) (by omega) + (by omega) (by omega) (by omega) + (by rcases hAh with ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> omega) + (by rcases hAc with ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> omega) + omega + · rw [if_neg hH1] + have e := gain_alg_cont (d : _root_.Int) (H : _root_.Int) (C : _root_.Int) (I : _root_.Int) + (M : _root_.Int) (b.mergedLB[t]! : _root_.Int) + (tag4Size (Prep.ofDag dag).spineLen[t]! : _root_.Int) (w : _root_.Int) + (Ah : _root_.Int) (Ac : _root_.Int) (by omega) (by omega) (by omega) (by omega) + (by omega) (by omega) (by omega) (by omega) + (by rcases hAh with ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> omega) + (by rcases hAc with ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> omega) + omega + +/-! ## Certain-stored: every minimum stores the term -/ + +/-- The uniform length of a stored set. -/ +def ulen (dag : Dag) (w : Nat) (roots : Array Nat) (S : List Nat) : Nat := + uniformCost (Prep.ofDag dag) w (fun y => decide (y ∈ S)) S roots.toList + +/-- **Certain-stored, for any maybe-stored set.** If `S ⊆ ms`, `t ∉ S` would +make `S` strictly longer than `S ∪ {t}` when the gain of `t` (bounds below +`uniformBounds … ms`, counts below the visible counts of `ms`) exceeds the +growth of the count's TagN; so a set no longer than `S ∪ {t}` contains `t`. -/ +theorem mem_of_gain {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y) + (w : Nat) (ms : Array Bool) {S : List Nat} (hSin : ∀ s ∈ S, s < dag.size) + (hSms : ∀ s ∈ S, ms[s]! = true) {t : Nat} (htn : t < dag.size) {b : UBounds} + (hbI : b.inlineLB[t]! ≤ (uniformBounds (Prep.ofDag dag) w ms).inlineLB[t]!) + (hbM : b.mergedLB[t]! ≤ (uniformBounds (Prep.ofDag dag) w ms).mergedLB[t]!) + {d h : Nat} (hd : d ≤ (visibleCounts dag roots ms).1[t]!) + (hh : h ≤ (visibleCounts dag roots ms).2[t]!) (hhd : h ≤ d) (hd1 : 1 ≤ d) + (hmin : ulen dag w roots S ≤ ulen dag w roots (t :: S)) + (hgain : (tag0Size (S.length + 1) : _root_.Int) - tag0Size S.length < + storedGainWith (Prep.ofDag dag) b w t d h) : + t ∈ S := by + by_cases htS : t ∈ S + · exact htS + · exfalso + have := uniformCost_insert_le_counts hwf roots hroots hreach w ms hSin hSms htn htS hbI hbM + hd hh hhd hd1 + unfold ulen at hmin + have hm := _root_.Int.ofNat_le.mpr hmin + omega + +/-- The two thresholds: below `N` entries, a gain `≥ tag0StepBound N + 1` always +beats the growth of the table count's TagN; a gain `≥ 1` does when `S` and +`S ∪ {t}` share a count bracket. -/ +theorem tag0_growth_lt {n N : Nat} {g : _root_.Int} + (h : ((tag0StepBound N : _root_.Int) + 1 ≤ g ∧ n < N) ∨ + (1 ≤ g ∧ tag0Size (n + 1) = tag0Size n)) : + (tag0Size (n + 1) : _root_.Int) - tag0Size n < g := by + rcases h with ⟨h1, hn⟩ | ⟨h1, h2⟩ + · have := tag0Size_succ_le hn + omega + · omega + +/-- The restricted class: duplicate-free sets of terms of in-degree at least +two. -/ +def InClass (dag : Dag) (roots : Array Nat) (S : List Nat) : Prop := + S.Nodup ∧ ∀ s ∈ S, s < dag.size ∧ 2 ≤ (graphFacts dag roots).deg[s]! + +/-- `S` minimises the uniform length over the restricted class. -/ +def IsMinimum (dag : Dag) (w : Nat) (roots : Array Nat) (S : List Nat) : Prop := + InClass dag roots S ∧ ∀ S', InClass dag roots S' → ulen dag w roots S ≤ ulen dag w roots S' + +/-- **Stage 3 (certain-stored), for partial assignments.** Let `X` be a +minimum over the restricted class and `ms` any maybe-stored set containing +`X` (for a partial assignment respected by `X`: the candidates minus the +terms decided not stored). A term `t` of in-degree `≥ 2` whose gain under +`ms` (with any bounds below `uniformBounds … ms` and any counts `h ≤ d` +below the visible counts of `ms`) is `≥ tag0StepBound N + 1` (with `|X| < N` +whenever `t ∉ X`), or `≥ 1` when `|X|` and `|X| + 1` share a TagN count +bracket, is in `X`. -/ +theorem stored_in_minimum {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y) + (w : Nat) (ms : Array Bool) {X : List Nat} (hX : IsMinimum dag w roots X) + (hXms : ∀ s ∈ X, ms[s]! = true) {t : Nat} (htn : t < dag.size) + (hdeg : 2 ≤ (graphFacts dag roots).deg[t]!) {b : UBounds} + (hbI : b.inlineLB[t]! ≤ (uniformBounds (Prep.ofDag dag) w ms).inlineLB[t]!) + (hbM : b.mergedLB[t]! ≤ (uniformBounds (Prep.ofDag dag) w ms).mergedLB[t]!) + {d h : Nat} (hd : d ≤ (visibleCounts dag roots ms).1[t]!) + (hh : h ≤ (visibleCounts dag roots ms).2[t]!) (hhd : h ≤ d) (hd1 : 1 ≤ d) + {N : Nat} (hN : t ∉ X → X.length < N) + (hgain : (tag0StepBound N : _root_.Int) + 1 ≤ storedGainWith (Prep.ofDag dag) b w t d h ∨ + (1 ≤ storedGainWith (Prep.ofDag dag) b w t d h ∧ + tag0Size (X.length + 1) = tag0Size X.length)) : + t ∈ X := by + by_cases htX : t ∈ X + · exact htX + · have hcl : InClass dag roots (t :: X) := + ⟨List.nodup_cons.mpr ⟨htX, hX.1.1⟩, fun s hs => by + rcases List.mem_cons.mp hs with rfl | hs + · exact ⟨htn, hdeg⟩ + · exact hX.1.2 s hs⟩ + exact mem_of_gain hwf roots hroots hreach w ms (fun s hs => (hX.1.2 s hs).1) hXms htn hbI hbM + hd hh hhd hd1 (hX.2 _ hcl) + (tag0_growth_lt (by rcases hgain with h | h + · exact Or.inl ⟨h, hN htX⟩ + · exact Or.inr h)) + +/-- The bracket condition behind threshold 1: if every minimum contains a set +`G` and lies within a set `C` (both duplicate-free), with +`tag0Size |C| = tag0Size |G|`, then for a minimum `X` and `t ∈ C \ X`, +`|X|` and `|X| + 1` share a bracket. -/ +theorem same_bracket {X G C : List Nat} (hGX : ∀ g ∈ G, g ∈ X) (hXC : ∀ x ∈ X, x ∈ C) + (hG : G.Nodup) (hX : X.Nodup) (_hC : C.Nodup) {t : Nat} (htC : t ∈ C) (htX : t ∉ X) + (hbr : tag0Size C.length = tag0Size G.length) : + tag0Size (X.length + 1) = tag0Size X.length := by + have h1 : G.length ≤ X.length := List.Nodup.length_le_of_subset hG hGX + have h2 : X.length + 1 ≤ C.length := by + have hsub : t :: X ⊆ C := by + intro y hy + rcases List.mem_cons.mp hy with rfl | hy + · exact htC + · exact hXC y hy + have := List.Nodup.length_le_of_subset (List.nodup_cons.mpr ⟨htX, hX⟩) hsub + simpa using this + have a := tag0Size_mono h1 + have b := tag0Size_mono (show X.length ≤ X.length + 1 by omega) + have c := tag0Size_mono h2 + omega + +/-! ## Certain-excluded: the removal exchange -/ + +/-- Every telescope spine of `p` is shorter than `teleSubaddEnd` (`Ixon.tagNEnd5 4`, +the start of the 9-byte TagN rung), so merging two telescopes never costs more +header bytes than the two headers. `optimizeUniformExpanded` checks it. -/ +def SpinesFit (p : Prep) : Prop := + ∀ x, x < p.dag.size → p.spineLen[x]! < teleSubaddEnd + +/-- Telescope headers are subadditive below `teleSubaddEnd`. -/ +theorem tag4Size_add_le {a b : Nat} (ha : 1 ≤ a) (hb : 1 ≤ b) (hab : a + b < teleSubaddEnd) : + tag4Size (a + b) ≤ tag4Size a + tag4Size b := by + unfold teleSubaddEnd at hab + unfold tag4Size Ixon.tagNByteWidth + simp only [Ix.Compile.Verify.TagN.tagNEnd1_eq_4, Ix.Compile.Verify.TagN.tagNEnd2_eq_4, + Ix.Compile.Verify.TagN.tagNEnd3_eq_4, Ix.Compile.Verify.TagN.tagNEnd4_eq_4, + Ix.Compile.Verify.TagN.tagNEnd5_eq_4] at hab ⊢ + repeat' split + all_goals omega + +/-- `teleSubaddEnd` is tight: the widths are 1, 2, 3, 4 and 5 below it and the +next rung is 9 bytes wide, so at the bound the headers are not subadditive. -/ +theorem tag4Size_not_subadditive_at_end : + tag4Size 1 + tag4Size (teleSubaddEnd - 1) < tag4Size (1 + (teleSubaddEnd - 1)) := by + decide + +/-- A writing stays valid when the available set keeps its Shares. -/ +theorem Valid.restrict {p : Prep} {S S' : Nat → Bool} : + ∀ {x : Nat} {T : WTree}, Valid p S x T → (∀ s ∈ T.shares, S' s = true) → Valid p S' x T := by + intro x T h + induction h with + | share _ => intro hs; exact .share (hs _ (by simp [WTree.shares])) + | node hf hlen _ ih => + intro hs + refine .node hf hlen fun i hi => ih i hi fun s hsi => hs s ?_ + simp only [WTree.shares] + exact mem_sharess (List.getElem_mem hi) hsi + | teleCut hf hj1 hj hlen _ hS ih => + intro hs + refine .teleCut hf hj1 hj hlen (fun k hk => ih k hk fun s hsk => hs s ?_) + (hs _ (by simp [WTree.shares])) + simp only [WTree.shares, List.mem_append] + exact Or.inl (mem_sharess (List.getElem_mem hk) hsk) + | teleFull hf hlen _ _ ih iht => + intro hs + refine .teleFull hf hlen (fun k hk => ih k hk fun s hsk => hs s ?_) (iht fun s hst => hs s ?_) + · simp only [WTree.shares, List.mem_append] + exact Or.inl (mem_sharess (List.getElem_mem hk) hsk) + · simp only [WTree.shares, List.mem_append] + exact Or.inr hst + +theorem ownBytes_pos {h : Head} (hf : h.family = .none) : 1 ≤ h.ownBytes := by + cases h with + | sort i => exact tag4Size_pos _ + | var i => exact tag4Size_pos _ + | ref r us => simp only [Head.ownBytes]; have := tag4Size_pos us.size; omega + | recur r us => simp only [Head.ownBytes]; have := tag4Size_pos us.size; omega + | prj t f => simp only [Head.ownBytes]; have := tag4Size_pos f.toNat; omega + | str i => exact tag4Size_pos _ + | nat i => exact tag4Size_pos _ + | letE c => simp only [Head.ownBytes]; omega + | app => simp [Head.family] at hf + | lam _ => simp [Head.family] at hf + | all _ _ => simp [Head.family] at hf + +/-- An inline writing costs at least one byte. -/ +theorem PrepWF.cost_pos {p : Prep} (hp : PrepWF p) {S : Nat → Bool} {w x : Nat} {T : WTree} + (h : Valid p S x T) (hx : x < p.dag.size) (hns : T.isShare = false) : 1 ≤ T.cost p w := by + cases h with + | share => simp [WTree.isShare] at hns + | node hf => + have hfam : (p.dag.node x).head.family = .none := by rw [← hp.family x hx]; exact hf + have := ownBytes_pos hfam + simp only [WTree.cost] + omega + | @teleCut _ j => + have := tag4Size_pos j + simp only [WTree.cost] + omega + | teleFull => + have := tag4Size_pos p.spineLen[x]! + simp only [WTree.cost] + omega + +/-- A cut telescope continued by a writing of its cut node. -/ +def WTree.merge (x j : Nat) (sides : List WTree) : WTree → WTree + | .tele _ j' sides' tail' => .tele x (j + j') (sides ++ sides') tail' + | W => .tele x j sides W + +/-- The telescope case of `unshare`: a cut at `t` is continued by `W`. -/ +def unshareTele (p : Prep) (t : Nat) (W : WTree) (x j : Nat) (sides : List WTree) + (tail tail' : WTree) : WTree := + match tail with + | .share u => if u = t ∧ j < p.spineLen[x]! then WTree.merge x j sides W else .tele x j sides tail' + | _ => .tele x j sides tail' + +mutual +/-- Replace every Share of `t` by the writing `W` of `t`: at a head position by +`W` itself, at a telescope cut by continuing the telescope with `W`'s spine. -/ +def WTree.unshare (p : Prep) (t : Nat) (W : WTree) : WTree → WTree + | .share x => if x = t then W else .share x + | .node x kids => .node x (WTree.unshares p t W kids) + | .tele x j sides tail => + unshareTele p t W x j (WTree.unshares p t W sides) tail (WTree.unshare p t W tail) +def WTree.unshares (p : Prep) (t : Nat) (W : WTree) : List WTree → List WTree + | [] => [] + | k :: ks => WTree.unshare p t W k :: WTree.unshares p t W ks +end + +theorem unshares_eq (p : Prep) (t : Nat) (W : WTree) (l : List WTree) : + WTree.unshares p t W l = l.map (WTree.unshare p t W) := by + induction l with + | nil => rfl + | cons k ks ih => simp [WTree.unshares, ih] + +theorem sum_ineq2 {α : Type} (f g c _d : α → Nat) (A B : Nat) : + ∀ (l : List α), (∀ a ∈ l, f a + g a * A ≤ c a + g a * B) → + (l.map f).sum + (l.map g).sum * A ≤ (l.map c).sum + (l.map g).sum * B := by + intro l h + induction l with + | nil => simp + | cons x xs ih => + simp only [List.map_cons, List.sum_cons, Nat.add_mul] + have h1 := h x List.mem_cons_self + have h2 := ih fun a ha => h a (List.mem_cons_of_mem _ ha) + omega + + +/-- An inline writing of a telescope node is a telescope. -/ +theorem valid_tele_inv {p : Prep} {S : Nat → Bool} {t : Nat} {W : WTree} (h : Valid p S t W) + (hns : W.isShare = false) (hft : p.family[t]! ≠ .none) : + ∃ j' s' tl', W = .tele t j' s' tl' ∧ s'.length = j' ∧ + (∀ (k : Nat) (hk : k < s'.length), Valid p S (sideAt p t k) s'[k]) ∧ + ((1 ≤ j' ∧ j' < p.spineLen[t]! ∧ tl' = .share (spineAt p t j') ∧ + S (spineAt p t j') = true) ∨ + (j' = p.spineLen[t]! ∧ Valid p S p.tail[t]! tl')) := by + cases h with + | share => simp [WTree.isShare] at hns + | node hf => exact absurd hf hft + | teleCut _ hj1 hj hlen hsides hS => exact ⟨_, _, _, rfl, hlen, hsides, Or.inl ⟨hj1, hj, rfl, hS⟩⟩ + | teleFull _ hlen hsides htail => exact ⟨_, _, _, rfl, hlen, hsides, Or.inr ⟨rfl, htail⟩⟩ + +/-- **Unsharing.** Replacing the Shares of `t` by an inline writing `W` of +`t` gives a writing without `t` that is longer by at most `cost W - w` per +replaced Share (telescope headers are subadditive). -/ +theorem PrepWF.unshare_spec {p : Prep} (hp : PrepWF p) (hsp : SpinesFit p) (w : Nat) {A A' : Nat → Bool} {t : Nat} + (htn : t < p.dag.size) (hA' : ∀ y, A' y = true ↔ (A y = true ∧ y ≠ t)) {W : WTree} + (hW : Valid p A' t W) (hWs : W.isShare = false) : + ∀ {x : Nat} {T : WTree}, Valid p A x T → x < p.dag.size → + Valid p A' x (WTree.unshare p t W T) ∧ + (T.isShare = false → (WTree.unshare p t W T).isShare = false) ∧ + (WTree.unshare p t W T).cost p w + T.shares.count t * w ≤ + T.cost p w + T.shares.count t * W.cost p w := by + intro x T h + induction h with + | @share x hS => + intro hx + by_cases hxt : x = t + · subst hxt + simp only [WTree.unshare, if_true, WTree.shares, count_singleton', WTree.cost] + refine ⟨hW, fun h => by simp [WTree.isShare] at h, by omega⟩ + · simp only [WTree.unshare, hxt, if_false, WTree.shares, count_singleton', WTree.isShare] + refine ⟨.share ((hA' x).mpr ⟨hS, hxt⟩), fun h => by simp at h, by omega⟩ + | @node x kids hf hlen hkids ih => + intro hx + have hk : ∀ (i : Nat) (hi : i < kids.length), + Valid p A' ((p.dag.node x).child i) (WTree.unshare p t W kids[i]) ∧ + (WTree.unshare p t W kids[i]).cost p w + kids[i].shares.count t * w ≤ + kids[i].cost p w + kids[i].shares.count t * W.cost p w := by + intro i hi + have hc := hp.dag.childAt_lt hx (k := i) (by omega) + obtain ⟨h1, _, h3⟩ := ih i hi (by omega) + exact ⟨h1, h3⟩ + simp only [WTree.unshare, unshares_eq, WTree.isShare] + refine ⟨.node hf (by simp [hlen]) fun i hi => by + simp only [List.getElem_map] + exact (hk i (by simpa using hi)).1, fun _ => trivial, ?_⟩ + simp only [WTree.cost, WTree.costs_eq, List.map_map, Function.comp_def, WTree.shares, + sharess_count] + have := sum_ineq2 (fun T => (WTree.unshare p t W T).cost p w) (fun T => T.shares.count t) + (WTree.cost p w) (fun _ => 0) w (W.cost p w) kids (fun T hT => by + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + exact (hk i hi).2) + omega + | @teleCut x j sides hf hj1 hj hlen hsides hS ih => + intro hx + have hside : ∀ (k : Nat) (hk : k < sides.length), + Valid p A' (sideAt p x k) (WTree.unshare p t W sides[k]) ∧ + (WTree.unshare p t W sides[k]).cost p w + sides[k].shares.count t * w ≤ + sides[k].cost p w + sides[k].shares.count t * W.cost p w := by + intro k hk + have hsl := hp.sideAt_lt hx hf (k := k) (by omega) + obtain ⟨h1, _, h3⟩ := ih k hk (by omega) + exact ⟨h1, h3⟩ + have hsum := sum_ineq2 (fun T => (WTree.unshare p t W T).cost p w) (fun T => T.shares.count t) + (WTree.cost p w) (fun _ => 0) w (W.cost p w) sides (fun T hT => by + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + exact (hside i hi).2) + have hL1 : ∀ (k : Nat) (hk : k < (sides.map (WTree.unshare p t W)).length), + Valid p A' (sideAt p x k) (sides.map (WTree.unshare p t W))[k] := by + intro k hk + simp only [List.getElem_map] + exact (hside k (by simpa using hk)).1 + simp only [WTree.unshare, unshares_eq, unshareTele] + by_cases hut : spineAt p x j = t + · rw [if_pos ⟨hut, hj⟩] + obtain ⟨hts, htf, htlen, httail, hspat, hsideat, hse⟩ := hp.spine_shift hx hf (k := j) hj + rw [hut] at hts htf htlen httail hspat hsideat hse + have hft : p.family[t]! ≠ .none := by rw [htf]; exact hf + obtain ⟨j', s', tl', hWeq, hlen', hs', hcase⟩ := valid_tele_inv hW hWs hft + have hj'1 : 1 ≤ j' := by + rcases hcase with ⟨h1, _⟩ | ⟨h1, _⟩ + · exact h1 + · obtain ⟨hl1', _⟩ := hp.spine t hts hft + omega + have hjj : j + j' ≤ p.spineLen[x]! := by + rcases hcase with ⟨_, hj', _, _⟩ | ⟨hj', _⟩ <;> omega + have hT := tag4Size_add_le hj1 hj'1 (Nat.lt_of_le_of_lt hjj (hsp x hx)) + have hcW : W.cost p w = tag4Size j' + j' * (p.dag.node t).sideExtra + + (s'.map (WTree.cost p w)).sum + tl'.cost p w := by + rw [hWeq]; simp only [WTree.cost, WTree.costs_eq] + have hmerge : WTree.merge x j (sides.map (WTree.unshare p t W)) W = + .tele x (j + j') (sides.map (WTree.unshare p t W) ++ s') tl' := by + rw [hWeq]; rfl + rw [hmerge] + have hsidesV : ∀ (k : Nat) (hk : k < ((sides.map (WTree.unshare p t W)) ++ s').length), + Valid p A' (sideAt p x k) ((sides.map (WTree.unshare p t W)) ++ s')[k] := by + intro k hk + rw [List.getElem_append] + split + · rename_i hkj + exact hL1 k hkj + · rename_i hkj + have hk' : k - (sides.map (WTree.unshare p t W)).length < s'.length := by + simp only [List.length_append] at hk + omega + have := hs' _ hk' + rw [hsideat] at this + have e : j + (k - (sides.map (WTree.unshare p t W)).length) = k := by + simp only [List.length_map] at hkj ⊢ + omega + rwa [e] at this + have hlenL : ((sides.map (WTree.unshare p t W)) ++ s').length = j + j' := by + simp [hlen, hlen'] + have hcost : (WTree.tele x (j + j') (sides.map (WTree.unshare p t W) ++ s') tl').cost p w + + (WTree.tele x j sides (.share (spineAt p x j))).shares.count t * w ≤ + (WTree.tele x j sides (.share (spineAt p x j))).cost p w + + (WTree.tele x j sides (.share (spineAt p x j))).shares.count t * W.cost p w := by + simp only [WTree.cost, WTree.costs_eq, List.map_append, List.sum_append, List.map_map, + Function.comp_def, WTree.shares, sharess_count, List.count_append, count_singleton', hut, + if_true] + rw [hse] at hcW + simp only [Nat.add_mul, Nat.one_mul] at hsum ⊢ + omega + rcases hcase with ⟨_, hj', htl', hA'u⟩ | ⟨hj', htl'⟩ + · have hu : spineAt p t j' = spineAt p x (j + j') := hspat j' + refine ⟨?_, fun _ => rfl, hcost⟩ + rw [htl', hu] + exact .teleCut hf (by omega) (by rw [htlen] at hj'; omega) hlenL hsidesV + (by rw [← hu]; exact hA'u) + · have hlenx : j + j' = p.spineLen[x]! := by rw [hj', htlen]; omega + refine ⟨?_, fun _ => rfl, hcost⟩ + rw [hlenx] + exact .teleFull hf (by rw [hlenL, hlenx]) hsidesV (by rw [← httail]; exact htl') + · rw [if_neg (fun h => hut h.1)] + simp only [hut, if_false] + refine ⟨.teleCut hf hj1 hj (by simp [hlen]) hL1 ((hA' _).mpr ⟨hS, hut⟩), fun _ => rfl, ?_⟩ + simp only [WTree.cost, WTree.costs_eq, List.map_map, Function.comp_def, WTree.shares, + sharess_count, List.count_append, count_singleton', hut, if_false, Nat.add_zero] + omega + | @teleFull x sides tail hf hlen hsides htail ih iht => + intro hx + obtain ⟨hl1, _, _, htl, _⟩ := hp.spine x hx hf + have hside : ∀ (k : Nat) (hk : k < sides.length), + Valid p A' (sideAt p x k) (WTree.unshare p t W sides[k]) ∧ + (WTree.unshare p t W sides[k]).cost p w + sides[k].shares.count t * w ≤ + sides[k].cost p w + sides[k].shares.count t * W.cost p w := by + intro k hk + have hsl := hp.sideAt_lt hx hf (k := k) (by omega) + obtain ⟨h1, _, h3⟩ := ih k hk (by omega) + exact ⟨h1, h3⟩ + have hsum := sum_ineq2 (fun T => (WTree.unshare p t W T).cost p w) (fun T => T.shares.count t) + (WTree.cost p w) (fun _ => 0) w (W.cost p w) sides (fun T hT => by + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + exact (hside i hi).2) + have hL1 : ∀ (k : Nat) (hk : k < (sides.map (WTree.unshare p t W)).length), + Valid p A' (sideAt p x k) (sides.map (WTree.unshare p t W))[k] := by + intro k hk + simp only [List.getElem_map] + exact (hside k (by simpa using hk)).1 + obtain ⟨ht1, _, ht3⟩ := iht (by omega) + have hU : unshareTele p t W x p.spineLen[x]! (sides.map (WTree.unshare p t W)) tail + (WTree.unshare p t W tail) = + .tele x p.spineLen[x]! (sides.map (WTree.unshare p t W)) (WTree.unshare p t W tail) := by + unfold unshareTele + split + · rw [if_neg (fun h => Nat.lt_irrefl _ h.2)] + · rfl + simp only [WTree.unshare, unshares_eq] + rw [hU] + refine ⟨.teleFull hf (by simp [hlen]) hL1 ht1, fun _ => rfl, ?_⟩ + simp only [WTree.cost, WTree.costs_eq, List.map_map, Function.comp_def, WTree.shares, + sharess_count, List.count_append] + simp only [Nat.add_mul] at ht3 ⊢ + omega + +theorem sum_erase {S : List Nat} {t : Nat} (h : t ∈ S) (f : Nat → Nat) : + (S.map f).sum = f t + ((S.erase t).map f).sum := by + have hperm := List.perm_cons_erase h + rw [(hperm.map f).sum_nat, List.map_cons, List.sum_cons] + +theorem forall₂_map_of {R R' : Nat → WTree → Prop} (g : WTree → WTree) : + ∀ {xs : List Nat} {ys : List WTree}, List.Forall₂ R xs ys → + (∀ x ∈ xs, ∀ y, R x y → R' x (g y)) → List.Forall₂ R' xs (ys.map g) + | _, _, .nil, _ => .nil + | _, _, .cons h hs, hg => + .cons (hg _ List.mem_cons_self _ h) + (forall₂_map_of g hs fun x hx y hxy => hg x (List.mem_cons_of_mem _ hx) y hxy) + +/-- **Removal.** Dropping a stored `t` and writing its entry `W` at each of its +`R` Shares (continuing telescopes through it at cuts) costs at most +`R · (cost W - w) - cost W`: `L(S \ {t}) + cost W + R·w ≤ cost(E) + R·cost W`. -/ +theorem PrepWF.removal {p : Prep} (hp : PrepWF p) (hsp : SpinesFit p) (w : Nat) {S : List Nat} (hSnd : S.Nodup) + (hSin : ∀ s ∈ S, s < p.dag.size) {roots : List Nat} (hroots : ∀ r ∈ roots, r < p.dag.size) + {t : Nat} (htS : t ∈ S) {E : Nat → WTree} {R : List WTree} + (hEnc : EncodingWF p (fun y => decide (y ∈ S)) S E roots R) : + uniformCost p w (fun y => decide (y ∈ S.erase t)) (S.erase t) roots + (E t).cost p w + + encRefs S E R t * w ≤ + encodingCost p w S E R + encRefs S E R t * (E t).cost p w := by + have hA' : ∀ y, decide (y ∈ S.erase t) = true ↔ (decide (y ∈ S) = true ∧ y ≠ t) := by + intro y + simp only [decide_eq_true_eq, hSnd.mem_erase_iff] + exact ⟨fun h => ⟨h.2, h.1⟩, fun h => ⟨h.2, h.1⟩⟩ + have htn := hSin t htS + obtain ⟨hWv, hWs⟩ := hEnc.1 t htS + have hW' : Valid p (fun y => decide (y ∈ S.erase t)) t (E t) := Valid.restrict hWv fun s hs => by + obtain ⟨h1, _, h3⟩ := hp.shares_lt hWv htn s hs + have := h3 hWs + exact (hA' s).mpr ⟨h1, by omega⟩ + have hcnt0 : (E t).shares.count t = 0 := hp.shares_count_zero hWv htn hWs t (Nat.le_refl _) + have hU : ∀ {x : Nat} {T : WTree}, Valid p (fun y => decide (y ∈ S)) x T → x < p.dag.size → + Valid p (fun y => decide (y ∈ S.erase t)) x (WTree.unshare p t (E t) T) ∧ + (T.isShare = false → (WTree.unshare p t (E t) T).isShare = false) ∧ + (WTree.unshare p t (E t) T).cost p w + T.shares.count t * w ≤ + T.cost p w + T.shares.count t * (E t).cost p w := + fun hv hx => hp.unshare_spec hsp w htn hA' hW' hWs hv hx + have hEnc' : EncodingWF p (fun y => decide (y ∈ S.erase t)) (S.erase t) + (fun s => WTree.unshare p t (E t) (E s)) roots (R.map (WTree.unshare p t (E t))) := by + refine ⟨fun s hs => ?_, forall₂_map_of _ hEnc.2 fun r hr T hT => (hU hT (hroots r hr)).1⟩ + have hsS := (hSnd.mem_erase_iff.mp hs).2 + obtain ⟨h1, h2, _⟩ := hU (hEnc.1 s hsS).1 (hSin s hsS) + exact ⟨h1, h2 (hEnc.1 s hsS).2⟩ + have hle := hp.uniformCost_le w _ (fun s hs => hSin s (List.mem_of_mem_erase hs)) hroots hEnc' + unfold encodingCost at hle ⊢ + have hsumS := sum_ineq2 (fun s => (WTree.unshare p t (E t) (E s)).cost p w) + (fun s => (E s).shares.count t) (fun s => (E s).cost p w) (fun _ => 0) w ((E t).cost p w) + (S.erase t) (fun s hs => by + have hsS := (hSnd.mem_erase_iff.mp hs).2 + exact (hU (hEnc.1 s hsS).1 (hSin s hsS)).2.2) + have hsumR := sum_ineq2 (fun T => (WTree.unshare p t (E t) T).cost p w) + (fun T => T.shares.count t) (WTree.cost p w) (fun _ => 0) w ((E t).cost p w) R + (fun T hT => by + obtain ⟨r, hrm, hr⟩ := forall₂_mem_right' hEnc.2 T hT + exact (hU hr (hroots r hrm)).2.2) + have hcS := sum_erase htS (fun s => (E s).cost p w) + have hrS := sum_erase htS (fun s => (E s).shares.count t) + simp only [hcnt0, Nat.zero_add] at hrS + have htag := tag0Size_mono (show (S.erase t).length ≤ S.length by + rw [List.length_erase_of_mem htS]; omega) + unfold encRefs + simp only [List.map_map, Function.comp_def] at hle + simp only [Nat.add_mul] at hsumS hsumR ⊢ + rw [hrS] + omega + +theorem count_zero_of_sum_zero {α : Type} {f : α → Nat} {l : List α} (h : (l.map f).sum = 0) + {a : α} (ha : a ∈ l) : f a = 0 := by + have := le_sum_map_of_mem f ha + omega + +theorem forall₂_imp_mem2 {α β : Type} {R R' : α → β → Prop} : + ∀ {xs : List α} {ys : List β}, List.Forall₂ R xs ys → + (∀ x ∈ xs, ∀ y ∈ ys, R x y → R' x y) → List.Forall₂ R' xs ys + | _, _, .nil, _ => .nil + | _, _, .cons hr hs, h => + .cons (h _ List.mem_cons_self _ List.mem_cons_self hr) + (forall₂_imp_mem2 hs fun x hx y hy hxy => + h x (List.mem_cons_of_mem _ hx) y (List.mem_cons_of_mem _ hy) hxy) + +/-- **Unreferenced entries.** An entry that no writing shares can be dropped, +saving its at least one byte. -/ +theorem PrepWF.unreferenced {p : Prep} (hp : PrepWF p) (w : Nat) {S : List Nat} (hSnd : S.Nodup) + (hSin : ∀ s ∈ S, s < p.dag.size) {roots : List Nat} (hroots : ∀ r ∈ roots, r < p.dag.size) + {s : Nat} (hsS : s ∈ S) {E : Nat → WTree} {R : List WTree} + (hEnc : EncodingWF p (fun y => decide (y ∈ S)) S E roots R) (hrefs : encRefs S E R s = 0) : + uniformCost p w (fun y => decide (y ∈ S.erase s)) (S.erase s) roots + 1 ≤ + encodingCost p w S E R := by + unfold encRefs at hrefs + have hS0 : (S.map fun s' => (E s').shares.count s).sum = 0 := by omega + have hR0 : (R.map fun T => T.shares.count s).sum = 0 := by omega + have hres : ∀ {x : Nat} {T : WTree}, Valid p (fun y => decide (y ∈ S)) x T → x < p.dag.size → + T.shares.count s = 0 → Valid p (fun y => decide (y ∈ S.erase s)) x T := by + intro x T hv hx h0 + apply Valid.restrict hv + intro s' hs' + have h1 := (hp.shares_lt hv hx s' hs').1 + simp only [decide_eq_true_eq] at h1 ⊢ + rw [hSnd.mem_erase_iff] + refine ⟨fun h => ?_, h1⟩ + subst h + rw [List.count_eq_zero] at h0 + exact h0 hs' + have hEnc' : EncodingWF p (fun y => decide (y ∈ S.erase s)) (S.erase s) E roots R := by + refine ⟨fun s' hs' => ?_, forall₂_imp_mem2 hEnc.2 fun r hr T hT hv => + hres hv (hroots r hr) (count_zero_of_sum_zero hR0 hT)⟩ + have hs'S := (hSnd.mem_erase_iff.mp hs').2 + exact ⟨hres (hEnc.1 s' hs'S).1 (hSin s' hs'S) (count_zero_of_sum_zero hS0 hs'S), + (hEnc.1 s' hs'S).2⟩ + have hle := hp.uniformCost_le w _ (fun s hs => hSin s (List.mem_of_mem_erase hs)) hroots hEnc' + have hpos := hp.cost_pos (w := w) (hEnc.1 s hsS).1 (hSin s hsS) (hEnc.1 s hsS).2 + have hcS := sum_erase hsS (fun s => (E s).cost p w) + have htag := tag0Size_mono (show (S.erase s).length ≤ S.length by + rw [List.length_erase_of_mem hsS]; omega) + unfold encodingCost at hle ⊢ + omega + +/-- In an attaining encoding every entry attains its inline optimum. -/ +theorem PrepWF.entries_attain {p : Prep} (hp : PrepWF p) (w : Nat) {A : Nat → Bool} + {S roots : List Nat} {E : Nat → WTree} {R : List WTree} + (hSin : ∀ s ∈ S, s < p.dag.size) (hroots : ∀ r ∈ roots, r < p.dag.size) + (hEnc : EncodingWF p A S E roots R) + (hcost : encodingCost p w S E R = uniformCost p w A S roots) : + ∀ s ∈ S, (E s).cost p w = uInl p w A s := by + have he : ∀ s ∈ S, uInl p w A s ≤ (E s).cost p w := + fun s hs => (hp.valid_cost w A (hEnc.1 s hs).1 (hSin s hs)).2 (hEnc.1 s hs).2 + have hr : (roots.map (uCost p w A)).sum ≤ (R.map (WTree.cost p w)).sum := + forall₂_sum_le hEnc.2 fun r hr T hT => (hp.valid_cost w A hT (hroots r hr)).1 + have hsum : (S.map (uInl p w A)).sum ≤ (S.map fun s => (E s).cost p w).sum := + sum_le_sum_of_le S he + unfold encodingCost uniformCost at hcost + have heq : (S.map fun s => (E s).cost p w).sum = (S.map (uInl p w A)).sum := by omega + intro s hs + have key : ∀ (l : List Nat), (∀ s ∈ l, uInl p w A s ≤ (E s).cost p w) → + (l.map fun s => (E s).cost p w).sum = (l.map (uInl p w A)).sum → + ∀ s ∈ l, (E s).cost p w = uInl p w A s := by + intro l + induction l with + | nil => intro _ _ s hs; cases hs + | cons x xs ih => + intro hle hsum s hs + simp only [List.map_cons, List.sum_cons] at hsum + have h1 := hle x List.mem_cons_self + have h2 := sum_le_sum_of_le xs fun s hs => hle s (List.mem_cons_of_mem _ hs) + rcases List.mem_cons.mp hs with rfl | hs + · omega + · exact ih (fun s hs => hle s (List.mem_cons_of_mem _ hs)) (by omega) s hs + exact key S he heq s hs + +/-- An inline writing of `x` writes `x`. -/ +theorem PrepWF.written_self {p : Prep} (hp : PrepWF p) {S : Nat → Bool} {x : Nat} {T : WTree} + (h : Valid p S x T) (hx : x < p.dag.size) (hns : T.isShare = false) : x ∈ T.written p := by + cases h with + | share => simp [WTree.isShare] at hns + | node => simp [WTree.written] + | teleCut _ hj1 => + simp only [WTree.written, List.mem_append, List.mem_map, List.mem_range] + exact Or.inl (Or.inl ⟨0, by omega, rfl⟩) + | teleFull hf hlen => + have hl1 := (hp.spine x hx hf).1 + simp only [WTree.written, List.mem_append, List.mem_map, List.mem_range] + exact Or.inl (Or.inl ⟨0, by omega, rfl⟩) + +/-! ## Certain-excluded: no minimum stores the term -/ + +theorem inClass_erase {dag : Dag} {roots : Array Nat} {X : List Nat} (hX : InClass dag roots X) + (t : Nat) : InClass dag roots (X.erase t) := + ⟨hX.1.erase t, fun s hs => hX.2 s (List.mem_of_mem_erase hs)⟩ + +/-- In a minimum, every entry is shared somewhere. -/ +theorem refs_pos_of_minimum {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) {X : List Nat} + (hX : IsMinimum dag w roots X) {E : Nat → WTree} {R : List WTree} + (hEnc : EncodingWF (Prep.ofDag dag) (fun y => decide (y ∈ X)) X E roots.toList R) + (hcost : encodingCost (Prep.ofDag dag) w X E R = ulen dag w roots X) : + ∀ s ∈ X, 1 ≤ encRefs X E R s := by + intro s hs + have hp := prepWF_ofDag hwf + by_cases h0 : encRefs X E R s = 0 + · exfalso + have hu := hp.unreferenced w hX.1.1 (fun s hs => by rw [ofDag_dag]; exact (hX.1.2 s hs).1) + (by rw [ofDag_dag]; exact hroots) hs hEnc h0 + have hm := hX.2 _ (inClass_erase hX.1 s) + unfold ulen at hm hcost + omega + · omega + +/-- In a minimum, every term is written at most its occurrence count times. -/ +theorem writes_le_occ {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) {X : List Nat} + (hX : IsMinimum dag w roots X) {E : Nat → WTree} {R : List WTree} + (hEnc : EncodingWF (Prep.ofDag dag) (fun y => decide (y ∈ X)) X E roots.toList R) + (hcost : encodingCost (Prep.ofDag dag) w X E R = ulen dag w roots X) : + ∀ y, y < dag.size → encWrites (Prep.ofDag dag) X E R y ≤ (occurrences dag roots)[y]! := by + have hp := prepWF_ofDag hwf + have hXin : ∀ s ∈ X, s < (Prep.ofDag dag).dag.size := fun s hs => by + rw [ofDag_dag]; exact (hX.1.2 s hs).1 + have hroots' : ∀ r ∈ roots.toList, r < (Prep.ofDag dag).dag.size := by + rw [ofDag_dag]; exact hroots + have hrefs := refs_pos_of_minimum hwf roots hroots w hX hEnc hcost + have key : ∀ m, ∀ y, dag.size - y ≤ m → y < dag.size → + encWrites (Prep.ofDag dag) X E R y ≤ (occurrences dag roots)[y]! := by + intro m + induction m with + | zero => intro y hym hy; omega + | succ m ih => + intro y hym hy + have hsl := hp.enc_slots hEnc hXin hroots' (t := y) (by rw [ofDag_dag]; exact hy) + rw [ofDag_dag] at hsl + have hcnt : X.count y ≤ encRefs X E R y := by + rw [hX.1.1.count] + split + · rename_i hyX; exact hrefs y hyX + · omega + have hsum : ((List.range dag.size).map fun z => + encWrites (Prep.ofDag dag) X E R z * edgeAll (Prep.ofDag dag) z y).sum ≤ + ((List.range dag.size).map fun z => + edgeAll (Prep.ofDag dag) z y * (occurrences dag roots)[z]!).sum := by + apply sum_le_sum_of_le + intro z hz + rw [List.mem_range] at hz + by_cases hzy : y < z + · rw [Nat.mul_comm] + exact Nat.mul_le_mul_left _ (ih z (by omega) hz) + · rw [edgeAll_zero_of_le hp (by omega)] + simp + rw [occurrences_spec hwf roots hroots hy] + omega + intro y hy + exact key (dag.size - y) y (Nat.le_refl _) hy + +/-- In a minimum, a stored term is shared at most its occurrence count times. -/ +theorem refs_le_occ {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) {X : List Nat} + (hX : IsMinimum dag w roots X) {E : Nat → WTree} {R : List WTree} + (hEnc : EncodingWF (Prep.ofDag dag) (fun y => decide (y ∈ X)) X E roots.toList R) + (hcost : encodingCost (Prep.ofDag dag) w X E R = ulen dag w roots X) {t : Nat} + (htX : t ∈ X) : encRefs X E R t ≤ (occurrences dag roots)[t]! := by + have hp := prepWF_ofDag hwf + have hXin : ∀ s ∈ X, s < (Prep.ofDag dag).dag.size := fun s hs => by + rw [ofDag_dag]; exact (hX.1.2 s hs).1 + have hroots' : ∀ r ∈ roots.toList, r < (Prep.ofDag dag).dag.size := by + rw [ofDag_dag]; exact hroots + have htn := (hX.1.2 t htX).1 + have hwr := writes_le_occ hwf roots hroots w hX hEnc hcost + have hsl := hp.enc_slots hEnc hXin hroots' (t := t) (by rw [ofDag_dag]; exact htn) + rw [ofDag_dag] at hsl + have hcnt : X.count t = 1 := by rw [hX.1.1.count, if_pos htX] + have hw1 : 1 ≤ encWrites (Prep.ofDag dag) X E R t := by + have h1 : 1 ≤ ((E t).written (Prep.ofDag dag)).count t := + List.count_pos_iff.mpr (hp.written_self (hEnc.1 t htX).1 (hXin t htX) (hEnc.1 t htX).2) + have := le_sum_map_of_mem (fun s => ((E s).written (Prep.ofDag dag)).count t) htX + unfold encWrites + omega + have hsum : ((List.range dag.size).map fun z => + encWrites (Prep.ofDag dag) X E R z * edgeAll (Prep.ofDag dag) z t).sum ≤ + ((List.range dag.size).map fun z => + edgeAll (Prep.ofDag dag) z t * (occurrences dag roots)[z]!).sum := by + apply sum_le_sum_of_le + intro z hz + rw [List.mem_range] at hz + rw [Nat.mul_comm] + exact Nat.mul_le_mul_left _ (hwr z hz) + rw [occurrences_spec hwf roots hroots htn] + omega + +/-- `C_∅`, the unshared standalone length, is the inline cost with nothing +available. -/ +theorem base_eq_uInl {dag : Dag} (hwf : DagWF dag) (w : Nat) {t : Nat} (ht : t < dag.size) : + (Prep.ofDag dag).base[t]! = uInl (Prep.ofDag dag) w (fun _ => false) t := by + have hp := prepWF_ofDag hwf + have hrow := hp.evalFrom_spec (w := w) (avail := fun _ => false) + (Array.replicate dag.size none) + (fun u => by + simp only [widthOf, Array.getElem?_replicate, Bool.false_eq_true, if_false] + split <;> rfl) + { cost := Array.replicate dag.size 0, sides := Array.replicate dag.size 0, + below := Array.replicate dag.size none } + (by simp [ofDag_dag]) (Array.replicate dag.size true) + (fun t ht => by + rw [ofDag_dag] at ht + simp [ht]) + t (by rw [ofDag_dag]; exact ht) + have hb : (Prep.ofDag dag).base = (evalFrom (Prep.ofDag dag).dag (Prep.ofDag dag).family + (Prep.ofDag dag).spineLen (Prep.ofDag dag).tail + { cost := Array.replicate dag.size 0, sides := Array.replicate dag.size 0, + below := Array.replicate dag.size none } + (Array.replicate dag.size none) (Array.replicate dag.size true)).cost := rfl + rw [hb, hrow.1, hp.uCost_eq w _ t (by rw [ofDag_dag]; exact ht)] + unfold costOf + simp only [Bool.false_eq_true, if_false] + rfl + +/-- Inline costs only drop when terms become available. -/ +theorem PrepWF.uInl_le_empty {p : Prep} (hp : PrepWF p) (w : Nat) (A : Nat → Bool) {t : Nat} + (ht : t < p.dag.size) : uInl p w A t ≤ uInl p w (fun _ => false) t := by + obtain ⟨T, hT, hTs, hTc⟩ := (hp.exists_opt w (fun _ => false) t ht).2 + have hT' : Valid p A t T := Valid.mono (fun y h => by simp at h) hT + have := (hp.valid_cost w A hT' ht).2 hTs + omega + +/-- **Stage 3 (certain-excluded).** A term with `(occ - 1)·size < occ·w` +(`size` the unshared length `C_∅`) is in no minimum over the restricted +class: removing it from a minimum would be strictly shorter. -/ +theorem excluded_of_minimum {dag : Dag} (hwf : DagWF dag) (hsp : SpinesFit (Prep.ofDag dag)) + (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) {X : List Nat} + (hX : IsMinimum dag w roots X) {t : Nat} (htn : t < dag.size) + (hce : ((occurrences dag roots)[t]! - 1) * (Prep.ofDag dag).base[t]! < + (occurrences dag roots)[t]! * w) : t ∉ X := by + intro htX + have hp := prepWF_ofDag hwf + have hXin : ∀ s ∈ X, s < (Prep.ofDag dag).dag.size := fun s hs => by + rw [ofDag_dag]; exact (hX.1.2 s hs).1 + have hroots' : ∀ r ∈ roots.toList, r < (Prep.ofDag dag).dag.size := by + rw [ofDag_dag]; exact hroots + obtain ⟨E, R, hEnc, hcost⟩ := + hp.uniformCost_attained w (fun y => decide (y ∈ X)) X roots.toList hXin hroots' + have hI := hp.entries_attain w hXin hroots' hEnc hcost t htX + have hrem := hp.removal hsp w hX.1.1 hXin hroots' htX hEnc + have hmin := hX.2 _ (inClass_erase hX.1 t) + have hRocc := refs_le_occ hwf roots hroots w hX hEnc hcost htX + have hI1 := hp.cost_pos (w := w) (hEnc.1 t htX).1 (hXin t htX) (hEnc.1 t htX).2 + have hIb : (E t).cost (Prep.ofDag dag) w ≤ (Prep.ofDag dag).base[t]! := by + rw [hI, base_eq_uInl hwf w htn] + exact hp.uInl_le_empty w _ (by rw [ofDag_dag]; exact htn) + unfold ulen at hmin + rw [hcost] at hrem + generalize (E t).cost (Prep.ofDag dag) w = I at hrem hI1 hIb + generalize encRefs X E R t = Rf at hrem hRocc + generalize (occurrences dag roots)[t]! = o at hRocc hce + generalize (Prep.ofDag dag).base[t]! = B at hIb hce + have h1 : I + Rf * w ≤ Rf * I := by omega + have hRf : 1 ≤ Rf := by + rcases Nat.eq_zero_or_pos Rf with h | h + · subst h; simp at h1; omega + · exact h + have hIw : w < I := by + have : Rf * w < Rf * I := by omega + exact Nat.lt_of_mul_lt_mul_left this + -- (o-1)·B - o·w = (Rf-1)·B - Rf·w + (o-Rf)·(B-w) ≥ (Rf-1)·I - Rf·w ≥ 0 + have e1 := int_mul_le_mul_left' (show (I : _root_.Int) ≤ B by omega) + (show (0 : _root_.Int) ≤ (Rf : _root_.Int) - 1 by omega) + have e2 := _root_.Int.mul_nonneg (show (0 : _root_.Int) ≤ (o : _root_.Int) - Rf by omega) + (show (0 : _root_.Int) ≤ (B : _root_.Int) - w by omega) + have h1' : ((I + Rf * w : Nat) : _root_.Int) ≤ ((Rf * I : Nat) : _root_.Int) := + _root_.Int.ofNat_le.mpr h1 + have hce' : (((o - 1) * B : Nat) : _root_.Int) < ((o * w : Nat) : _root_.Int) := + _root_.Int.ofNat_lt.mpr hce + simp only [_root_.Int.natCast_add, _root_.Int.natCast_mul] at h1' + rw [_root_.Int.natCast_mul, _root_.Int.natCast_mul, _root_.Int.ofNat_sub (by omega)] at hce' + simp only [_root_.Int.sub_mul, _root_.Int.mul_sub, _root_.Int.one_mul, + _root_.Int.natCast_one] at e1 e2 hce' + rw [_root_.Int.mul_comm (Rf : _root_.Int) (I : _root_.Int)] at e1 h1' + omega + +/-! ## The executable classification -/ + +theorem vis_head_le {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (ms : Array Bool) {t : Nat} (ht : t < dag.size) : + (visibleCounts dag roots ms).2[t]! ≤ (visibleCounts dag roots ms).1[t]! := by + obtain ⟨e1, e2⟩ := visibleCounts_spec hwf roots hroots ms ht + rw [e1, e2] + apply Nat.add_le_add_left + apply sum_le_sum_of_le + intro y _ + unfold edgeAll + exact Nat.mul_le_mul_right _ (Nat.le_add_right _ _) + +theorem gain_d_pos {p : Prep} {b : UBounds} {w t d h : Nat} (hhd : h ≤ d) + (hg : 1 ≤ storedGainWith p b w t d h) : 1 ≤ d := by + rcases Nat.eq_zero_or_pos d with h0 | h0 + · subst h0 + have hh0 : h = 0 := by omega + subst hh0 + unfold storedGainWith at hg + simp only [_root_.Int.ofNat_eq_natCast, _root_.Int.natCast_zero, _root_.Int.zero_sub, + _root_.Int.zero_mul, _root_.Int.sub_zero] at hg + split at hg + · have := _root_.Int.natCast_nonneg (b.inlineLB[t]!); omega + · split at hg + · omega + · have := _root_.Int.natCast_nonneg (b.mergedLB[t]!) + have := _root_.Int.natCast_nonneg (tag4Size p.spineLen[t]!) + omega + · exact h0 + +theorem getElem!_range_map {α : Type} [Inhabited α] (f : Nat → α) {n t : Nat} (ht : t < n) : + ((Array.range n).map f)[t]! = f t := by + simp [ht] + +/-- Every minimum stores only search candidates. -/ +theorem minimum_in_candidates {dag : Dag} (hwf : DagWF dag) (hsp : SpinesFit (Prep.ofDag dag)) + (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) {X : List Nat} + (hX : IsMinimum dag w roots X) : + ∀ s ∈ X, (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)[s]! = true := by + intro s hs + have hsn := (hX.1.2 s hs).1 + unfold searchCandidates + rw [getElem!_range_map _ (by rw [ofDag_dag]; exact hsn)] + simp only [Bool.and_eq_true, Bool.not_eq_true', decide_eq_true_eq] + refine ⟨?_, (hX.1.2 s hs).2⟩ + cases hce : certainExcludedTest (Prep.ofDag dag) (graphFacts dag roots) w s + · rfl + · exfalso + unfold certainExcludedTest at hce + simp only [decide_eq_true_eq] at hce + exact excluded_of_minimum hwf hsp roots hroots w hX hsn hce hs + +theorem filter_size_range_map {α : Type} [Inhabited α] (n : Nat) (F : Nat → α) (P : α → Bool) : + (((Array.range n).map F).filter P).size = + ((List.range n).filter fun t => P ((Array.range n).map F)[t]!).length := by + rw [Array.size_eq_length_toList, Array.toList_filter, Array.toList_map, Array.toList_range, + List.filter_map, List.length_map] + congr 1 + apply List.filter_congr + intro t ht + rw [List.mem_range] at ht + simp only [Function.comp_def, getElem!_range_map F ht] + +/-- A minimum that omits a candidate has fewer terms than there are +candidates. -/ +theorem minimum_length_lt {dag : Dag} (hwf : DagWF dag) (hsp : SpinesFit (Prep.ofDag dag)) + (roots : Array Nat) (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) {X : List Nat} + (hX : IsMinimum dag w roots X) {t : Nat} (htn : t < dag.size) + (htc : (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)[t]! = true) + (htX : t ∉ X) : + X.length < ((searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w).filter id).size := by + have hn : (Prep.ofDag dag).dag.size = dag.size := by rw [ofDag_dag] + let C := (List.range dag.size).filter fun s => + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)[s]! + have hC : ((searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w).filter id).size = + C.length := by + simp only [searchCandidates, C] + rw [filter_size_range_map, hn] + rfl + rw [hC] + have hsub : t :: X ⊆ C := by + intro y hy + simp only [C, List.mem_filter, List.mem_range] + rcases List.mem_cons.mp hy with rfl | hy + · exact ⟨htn, htc⟩ + · exact ⟨(hX.1.2 y hy).1, minimum_in_candidates hwf hsp roots hroots w hX y hy⟩ + have := List.Nodup.length_le_of_subset (List.nodup_cons.mpr ⟨htX, hX.1.1⟩) hsub + simp only [List.length_cons] at this + omega + +/-- **Stage 3, the executable classes.** With the root-level candidates, +bounds and visible counts (as `uniformChoose` computes them), on a DAG whose +telescope spines fit (`SpinesFit`): a certain-excluded term is in no +minimum, and a term classified certain-stored at threshold +`tag0StepBound N + 1` (`N` the number of candidates), or at threshold 1 when +`|X|` and `|X| + 1` share a TagN count bracket, is in every minimum `X`. -/ +theorem classify_sound {dag : Dag} (hwf : DagWF dag) (hsp : SpinesFit (Prep.ofDag dag)) + (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y) + (w : Nat) {X : List Nat} (hX : IsMinimum dag w roots X) {t : Nat} (htn : t < dag.size) + (θ : _root_.Int) + (hθ : θ = (tag0StepBound ((searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w).filter + id).size : _root_.Int) + 1 ∨ (θ = 1 ∧ tag0Size (X.length + 1) = tag0Size X.length)) : + let p := Prep.ofDag dag + let f := graphFacts dag roots + let cand := searchCandidates p f w + let cls := classifyWith p f w (uniformBounds p w cand) (visibleCounts dag roots cand) θ + (cls[t]! = .certainExcluded → t ∉ X) ∧ (cls[t]! = .certainStored → t ∈ X) := by + intro p f cand cls + have hcls : cls[t]! = (if certainExcludedTest p f w t then .certainExcluded + else if f.deg[t]! < 2 then .lowDegree + else if storedGainWith p (uniformBounds p w cand) w t (visibleCounts dag roots cand).1[t]! + (visibleCounts dag roots cand).2[t]! ≥ θ then .certainStored + else .uncertain) := by + simp only [cls, classifyWith] + rw [getElem!_range_map _ (by simp only [p]; rw [ofDag_dag]; exact htn)] + refine ⟨fun h => ?_, fun h => ?_⟩ + · rw [hcls] at h + split at h + · rename_i hce + unfold certainExcludedTest at hce + simp only [decide_eq_true_eq] at hce + exact excluded_of_minimum hwf hsp roots hroots w hX htn hce + · split at h <;> (try split at h) <;> cases h + · rw [hcls] at h + split at h + · cases h + · split at h + · cases h + · split at h + · rename_i hce hdeg hg + have hhd := vis_head_le hwf roots hroots cand htn + have hg1 : 1 ≤ storedGainWith p (uniformBounds p w cand) w t + (visibleCounts dag roots cand).1[t]! (visibleCounts dag roots cand).2[t]! := by + rcases hθ with h | ⟨h, _⟩ <;> omega + have htc : (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)[t]! = true := by + unfold searchCandidates + rw [getElem!_range_map _ (by rw [ofDag_dag]; exact htn)] + simp only [Bool.and_eq_true, Bool.not_eq_true', decide_eq_true_eq] + exact ⟨by simpa using hce, Nat.le_of_not_lt hdeg⟩ + exact stored_in_minimum hwf roots hroots hreach w cand hX + (minimum_in_candidates hwf hsp roots hroots w hX) htn (Nat.le_of_not_lt hdeg) + (Nat.le_refl _) (Nat.le_refl _) (Nat.le_refl _) (Nat.le_refl _) hhd + (gain_d_pos hhd hg1) + (fun htX => minimum_length_lt hwf hsp roots hroots w hX htn htc htX) + (by rcases hθ with h | ⟨h, hb⟩ + · exact Or.inl (by rw [h] at hg; exact hg) + · exact Or.inr ⟨by rw [h] at hg; exact hg, hb⟩) + · cases h + +/-- **The threshold-1 test of `uniformStage`.** If the candidates and the terms +certain-stored at threshold `tag0StepBound N + 1` (`N` the number of +candidates) fill the same TagN count bracket, then for every minimum `X` and +candidate `t ∉ X`, `|X|` and `|X| + 1` share a bracket (so threshold 1 is +sound in `classify_sound` and `stored_in_minimum`). -/ +theorem threshold_one_sound {dag : Dag} (hwf : DagWF dag) (hsp : SpinesFit (Prep.ofDag dag)) + (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y) + (w : Nat) {X : List Nat} (hX : IsMinimum dag w roots X) {t : Nat} (htn : t < dag.size) : + let p := Prep.ofDag dag + let f := graphFacts dag roots + let cand := searchCandidates p f w + let clsMax := classifyWith p f w (uniformBounds p w cand) (visibleCounts dag roots cand) + ((tag0StepBound (cand.filter id).size : _root_.Int) + 1) + tag0Size (cand.filter id).size = tag0Size (clsMax.filter (· == .certainStored)).size → + cand[t]! = true → t ∉ X → tag0Size (X.length + 1) = tag0Size X.length := by + intro p f cand clsMax hbr htc htX + have hn : (Prep.ofDag dag).dag.size = dag.size := by rw [ofDag_dag] + let G := (List.range dag.size).filter fun s => clsMax[s]! == .certainStored + let C := (List.range dag.size).filter fun s => cand[s]! + have hG : (clsMax.filter (· == .certainStored)).size = G.length := by + simp only [clsMax, classifyWith, G] + rw [filter_size_range_map, hn] + have hC : (cand.filter id).size = C.length := by + simp only [cand, searchCandidates, C] + rw [filter_size_range_map, hn] + rfl + rw [hG, hC] at hbr + refine same_bracket (G := G) (C := C) ?_ ?_ (List.nodup_range.filter _) hX.1.1 + (List.nodup_range.filter _) ?_ htX hbr + · intro g hg + simp only [G, List.mem_filter, List.mem_range] at hg + have hcs : clsMax[g]! = .certainStored := by + have h2 := hg.2 + revert h2 + cases clsMax[g]! <;> intro h <;> first | rfl | (exact absurd h (by decide)) + exact (classify_sound hwf hsp roots hroots hreach w hX hg.1 _ (Or.inl rfl)).2 hcs + · intro x hx + simp only [C, List.mem_filter, List.mem_range] + exact ⟨(hX.1.2 x hx).1, minimum_in_candidates hwf hsp roots hroots w hX x hx⟩ + · simp only [C, List.mem_filter, List.mem_range] + exact ⟨htn, htc⟩ + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformDecomp.lean b/Ix/Compile/Verify/UniformDecomp.lean new file mode 100644 index 000000000..1bf62b13e --- /dev/null +++ b/Ix/Compile/Verify/UniformDecomp.lean @@ -0,0 +1,1043 @@ +import Ix.Compile.Verify.UniformClasses + +/-! +# Stage 4 (part): additive decomposition of the uniform cost + +With an *opaque* set `O` of available terms that cost exactly `w` wherever +they occur and end every telescope running into them (`OpaqueAt`; the +certain-stored terms are opaque in every candidate set containing them, +`certainStored_opaque`): + +* **Domination** (`teleFrom_dom`): a telescope's cheapest ending is decided + at or before its first opaque spine node. +* **Locality** (`PrepWF.uCost_local`): the costs of a term depend only on the + availability of the terms reachable from it along DAG paths whose + intermediate terms are not opaque (`NReach`). +* **Modularity** (`PrepWF.uCost_modular`, `uniformCost_modular`): if no + available non-opaque term reaches both of two added sets `Z₁`, `Z₂`, + adding both changes every cost, and the uniform length up to the count's + TagN, by the sum of adding each. +* **Components** (`components_modular`): with `cs` the certain-stored terms + and a labeling of the uncertain terms that is constant along non-opaque + paths, the uniform length without the TagN is modular across labels. +* **Search bound** (`lower_bound_sound`): the cost with every undecided term + available and only the decided entries paid is at most the length of + every completion. + +The rest of Stage 4 builds on these facts in other modules: that the +uncertain components are such a labeling (`componentsChecked_spec`, +`UniformChecks`), the invariants of the component search +(`UniformSearchSpec`), and the final theorems, a successful run stores a +minimum (`optimizeUniform_minimum`) and the `setPrec`-least one +(`optimizeUniform_least`, both in `UniformOptimality`). +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact + +/-! ## Paths that avoid opaque terms -/ + +/-- `v` is reachable from `y` along DAG edges whose intermediate terms are not +opaque (the endpoints may be). -/ +inductive NReach (p : Prep) (O : Nat → Bool) (y : Nat) : Nat → Prop + | refl : NReach p O y y + | tail {u v : Nat} : NReach p O y u → (u = y ∨ O u = false) → + (∃ k, k < (p.dag.node u).head.arity ∧ (p.dag.node u).child k = v) → NReach p O y v + +theorem NReach.edge {p : Prep} {O : Nat → Bool} {y k : Nat} + (hk : k < (p.dag.node y).head.arity) : NReach p O y ((p.dag.node y).child k) := + .tail .refl (Or.inl rfl) ⟨k, hk, rfl⟩ + +/-- A path from a non-opaque child extends to its parent. -/ +theorem NReach.of_child {p : Prep} {O : Nat → Bool} {y c : Nat} (hc : O c = false) + (hyc : ∃ k, k < (p.dag.node y).head.arity ∧ (p.dag.node y).child k = c) : + ∀ {v : Nat}, NReach p O c v → NReach p O y v := by + intro v h + induction h with + | refl => exact .tail .refl (Or.inl rfl) hyc + | tail _ hu he ih => + refine .tail ih (Or.inr ?_) he + rcases hu with rfl | hu + · exact hc + · exact hu + +/-- A path extends through a non-opaque intermediate term. -/ +theorem NReach.trans {p : Prep} {O : Nat → Bool} {y u : Nat} (h1 : NReach p O y u) + (hu : u = y ∨ O u = false) : ∀ {v : Nat}, NReach p O u v → NReach p O y v := by + intro v h + induction h with + | refl => exact h1 + | tail _ hw he ih => + refine .tail ih ?_ he + rcases hw with rfl | hw + · exact hu + · exact Or.inr hw + +theorem PrepWF.snext_edge {p : Prep} (hp : PrepWF p) {t : Nat} (ht : t < p.dag.size) + (hf : p.family[t]! ≠ .none) : + ∃ k, k < (p.dag.node t).head.arity ∧ (p.dag.node t).child k = snext p t := by + have hft : (p.dag.node t).head.family ≠ .none := by rw [← hp.family t ht]; exact hf + unfold snext Node.spineNext + cases hh : (p.dag.node t).head <;> simp only [hh, Head.family, ne_eq, not_true_eq_false] at hft + · exact ⟨0, by simp [Head.arity], rfl⟩ + · exact ⟨1, by simp [Head.arity], rfl⟩ + · exact ⟨1, by simp [Head.arity], rfl⟩ + +theorem PrepWF.side_edge {p : Prep} (hp : PrepWF p) {t : Nat} (ht : t < p.dag.size) + (hf : p.family[t]! ≠ .none) : + ∃ k, k < (p.dag.node t).head.arity ∧ (p.dag.node t).child k = (p.dag.node t).sideChild := by + have hft : (p.dag.node t).head.family ≠ .none := by rw [← hp.family t ht]; exact hf + unfold Node.sideChild + cases hh : (p.dag.node t).head <;> simp only [hh, Head.family, ne_eq, not_true_eq_false] at hft + · exact ⟨1, by simp [Head.arity], rfl⟩ + · exact ⟨0, by simp [Head.arity], rfl⟩ + · exact ⟨0, by simp [Head.arity], rfl⟩ + +/-- Along a telescope spine whose nodes `k, …, j-1` after `k` are not opaque, +the spine node `j` is reachable from the spine node `k`. -/ +theorem PrepWF.spine_nreach {p : Prep} (hp : PrepWF p) {O : Nat → Bool} {y : Nat} + (hy : y < p.dag.size) (hf : p.family[y]! ≠ .none) {k : Nat} : + ∀ j, k ≤ j → j < p.spineLen[y]! → (∀ i, k < i → i < j → O (spineAt p y i) = false) → + NReach p O (spineAt p y k) (spineAt p y j) := by + intro j + induction j with + | zero => intro hkj _ _; rw [show k = 0 by omega]; exact .refl + | succ j ih => + intro hkj hjl hO + by_cases hkj' : k = j + 1 + · subst hkj'; exact .refl + · have h1 := ih (by omega) (by omega) (fun i hi1 hi2 => hO i hi1 (by omega)) + obtain ⟨hts, htf, _⟩ := hp.spine_shift hy hf (k := j) (by omega) + have hf' : p.family[spineAt p y j]! ≠ .none := by rw [htf]; exact hf + refine .tail h1 ?_ ?_ + · by_cases hjk : j = k + · exact Or.inl (by rw [hjk]) + · exact Or.inr (hO j (by omega) (by omega)) + · obtain ⟨m, hm, he⟩ := hp.snext_edge hts hf' + exact ⟨m, hm, by rw [he, snext_spineAt]⟩ + +/-! ## Opaque terms -/ + +/-- `t` is available, its inline writing costs at least `w`, and (for a +telescope node) every continuation through it costs at least `w`. -/ +def OpaqueAt (p : Prep) (w : Nat) (A : Nat → Bool) (t : Nat) : Prop := + A t = true ∧ (p.family[t]! = .none → w ≤ uInl p w A t) ∧ + (p.family[t]! ≠ .none → w ≤ mergedOf p w A (uCost p w A) t) + +/-- An opaque term costs exactly `w`. -/ +theorem PrepWF.opaque_cost {p : Prep} (hp : PrepWF p) {w : Nat} {A : Nat → Bool} {t : Nat} + (ht : t < p.dag.size) (h : OpaqueAt p w A t) : uCost p w A t = w := by + rw [hp.uCost_eq w A t ht] + unfold costOf + rw [if_pos h.1] + have hinl : w ≤ inlOf p w A (uCost p w A) t := by + by_cases hf : p.family[t]! = .none + · exact h.2.1 hf + · have := (inl_merged_bounds p w A (uCost p w A) hf).1 + have := h.2.2 hf + unfold uInl at * + omega + exact Nat.min_eq_right hinl + +/-! ## Telescopes from a spine position -/ + +/-- The available cuts of `y` at spine positions `k ≤ j < K`, headers counted +from `y`, side bytes from position `k`. -/ +def cutsRange (p : Prep) (w : Nat) (A : Nat → Bool) (cost : Nat → Nat) (y k K : Nat) : + List Nat := + (List.range' k (K - k)).filterMap fun j => + if A (spineAt p y j) then some (tag4Size j + prefixSides p cost (spineAt p y k) (j - k) + w) + else none + +/-- The natural ending of `y`'s telescope, side bytes from position `k`. -/ +def natFrom (p : Prep) (cost : Nat → Nat) (y k : Nat) : Nat := + tag4Size p.spineLen[y]! + prefixSides p cost (spineAt p y k) (p.spineLen[y]! - k) + + cost p.tail[y]! + +/-- The cheapest ending of `y`'s telescope from spine position `k` on. -/ +def teleFrom (p : Prep) (w : Nat) (A : Nat → Bool) (cost : Nat → Nat) (y k : Nat) : Nat := + (cutsRange p w A cost y k p.spineLen[y]!).foldl min (natFrom p cost y k) + +theorem prefixSides_local (p : Prep) {f g : Nat → Nat} : + ∀ (j t : Nat), (∀ i, i < j → f (sideAt p t i) = g (sideAt p t i)) → + prefixSides p f t j = prefixSides p g t j := by + intro j + induction j with + | zero => intro _ _; rfl + | succ j ih => + intro t h + simp only [prefixSides, sideCost] + have h0 := h 0 (by omega) + simp only [sideAt, spineAt] at h0 + rw [h0, ih (snext p t) (fun i hi => by + have := h (i + 1) (by omega) + simp only [sideAt, spineAt] at this ⊢ + exact this)] + +theorem foldl_min_add (a : Nat) : ∀ (l : List Nat) (x : Nat), + (l.map (a + ·)).foldl min (a + x) = a + l.foldl min x := by + intro l + induction l with + | nil => intro x; rfl + | cons y ys ih => + intro x + simp only [List.map_cons, List.foldl_cons] + rw [show min (a + x) (a + y) = a + min x y by omega, ih] + +/-- With no available cut before position `k ≥ 1`, the inline cost of a +telescope is its first `k` sides plus its cheapest ending from `k`. -/ +theorem PrepWF.inl_split {p : Prep} (_hp : PrepWF p) (w : Nat) (A : Nat → Bool) + (cost : Nat → Nat) {y k : Nat} (hf : p.family[y]! ≠ .none) (hk1 : 1 ≤ k) + (hkl : k ≤ p.spineLen[y]!) (hnone : ∀ j, 1 ≤ j → j < k → A (spineAt p y j) = false) : + inlOf p w A cost y = prefixSides p cost y k + teleFrom p w A cost y k := by + unfold inlOf teleFrom + rw [if_neg hf] + have hcuts : cutCosts p w A cost y = + (cutsRange p w A cost y k p.spineLen[y]!).map (prefixSides p cost y k + ·) := by + unfold cutCosts cutsRange + have hsplit : List.range' 1 (p.spineLen[y]! - 1) = + List.range' 1 (k - 1) ++ List.range' k (p.spineLen[y]! - k) := by + have := List.range'_append_1 (s := 1) (m := k - 1) (n := p.spineLen[y]! - k) + rw [show 1 + (k - 1) = k by omega, show k - 1 + (p.spineLen[y]! - k) = p.spineLen[y]! - 1 by omega] at this + exact this.symm + rw [hsplit, List.filterMap_append] + have h1 : (List.range' 1 (k - 1)).filterMap (fun j => + if A (spineAt p y j) then some (tag4Size j + prefixSides p cost y j + w) else none) = [] := by + rw [List.filterMap_eq_nil_iff] + intro j hj + rw [List.mem_range'_1] at hj + rw [hnone j hj.1 (by omega)] + rfl + rw [h1, List.nil_append, List.map_filterMap] + apply filterMap_congr' + intro j hj + rw [List.mem_range'_1] at hj + split + · simp only [Option.map_some] + congr 1 + rw [show j = k + (j - k) by omega, prefixSides_add p cost k (j - k) y] + have : k + (j - k) - k = j - k := by omega + rw [this] + omega + · rfl + rw [hcuts] + have hnat : naturalCost p cost y = prefixSides p cost y k + natFrom p cost y k := by + unfold naturalCost natFrom + rw [show p.spineLen[y]! = k + (p.spineLen[y]! - k) by omega] + rw [prefixSides_add p cost k (p.spineLen[y]! - k) y] + rw [show k + (p.spineLen[y]! - k) - k = p.spineLen[y]! - k by omega] + omega + rw [hnat, foldl_min_add] + +theorem mem_cutsRange {p : Prep} {w : Nat} {A : Nat → Bool} {cost : Nat → Nat} {y k K e : Nat} : + e ∈ cutsRange p w A cost y k K ↔ ∃ j, k ≤ j ∧ j < K ∧ A (spineAt p y j) = true ∧ + e = tag4Size j + prefixSides p cost (spineAt p y k) (j - k) + w := by + unfold cutsRange + rw [List.mem_filterMap] + constructor + · rintro ⟨j, hj, he⟩ + rw [List.mem_range'_1] at hj + split at he + · rename_i hA + exact ⟨j, hj.1, by omega, hA, (Option.some.inj he).symm⟩ + · cases he + · rintro ⟨j, h1, h2, hA, rfl⟩ + exact ⟨j, List.mem_range'_1.mpr ⟨h1, by omega⟩, by rw [if_pos hA]⟩ + +theorem prefixSides_mono (p : Prep) (cost : Nat → Nat) (t : Nat) {a b : Nat} (h : a ≤ b) : + prefixSides p cost t a ≤ prefixSides p cost t b := by + rw [show b = a + (b - a) by omega, prefixSides_add p cost a (b - a) t] + omega + +/-- **Domination at an opaque spine node.** When the spine node at position +`K ≥ k` is opaque, no ending at or beyond it is cheaper than the cut there. -/ +theorem PrepWF.teleFrom_dom {p : Prep} (hp : PrepWF p) {w : Nat} {A : Nat → Bool} {y k K : Nat} + (hy : y < p.dag.size) (hf : p.family[y]! ≠ .none) (hkK : k ≤ K) (hK : K < p.spineLen[y]!) + (hop : OpaqueAt p w A (spineAt p y K)) : + teleFrom p w A (uCost p w A) y k = + (cutsRange p w A (uCost p w A) y k K).foldl min + (tag4Size K + prefixSides p (uCost p w A) (spineAt p y k) (K - k) + w) := by + have hsp : spineAt p (spineAt p y k) (K - k) = spineAt p y K := by + rw [← spineAt_add]; congr 1; omega + have hge : ∀ j, K ≤ j → tag4Size K + prefixSides p (uCost p w A) (spineAt p y k) (K - k) + w ≤ + tag4Size j + prefixSides p (uCost p w A) (spineAt p y k) (j - k) + w := by + intro j hj + have := tag4Size_mono hj + have := prefixSides_mono p (uCost p w A) (spineAt p y k) (show K - k ≤ j - k by omega) + omega + unfold teleFrom + apply foldl_min_unique + · -- the right side is one of the options + rcases List.mem_cons.mp (foldl_min_mem (cutsRange p w A (uCost p w A) y k K) + (tag4Size K + prefixSides p (uCost p w A) (spineAt p y k) (K - k) + w)) with h | h + · rw [h] + exact List.mem_cons_of_mem _ (mem_cutsRange.mpr ⟨K, hkK, hK, hop.1, rfl⟩) + · obtain ⟨j, h1, h2, hA, he⟩ := mem_cutsRange.mp h + exact List.mem_cons_of_mem _ (mem_cutsRange.mpr ⟨j, h1, by omega, hA, he⟩) + · intro e he + have hle := foldl_min_le (cutsRange p w A (uCost p w A) y k K) + (tag4Size K + prefixSides p (uCost p w A) (spineAt p y k) (K - k) + w) _ + List.mem_cons_self + rcases List.mem_cons.mp he with rfl | he + · -- the natural ending costs at least the cut + obtain ⟨hts, htf, htlen, httail, _, _, _⟩ := hp.spine_shift hy hf (k := K) hK + have hfK : p.family[spineAt p y K]! ≠ .none := by rw [htf]; exact hf + have hm := hop.2.2 hfK + have hmle := foldl_min_le (mergedCuts p w A (uCost p w A) (spineAt p y K)) + (prefixSides p (uCost p w A) (spineAt p y K) p.spineLen[spineAt p y K]! + + uCost p w A p.tail[spineAt p y K]!) _ List.mem_cons_self + unfold mergedOf at hm + rw [htlen, httail] at hm hmle + have hsplit : prefixSides p (uCost p w A) (spineAt p y k) (p.spineLen[y]! - k) = + prefixSides p (uCost p w A) (spineAt p y k) (K - k) + + prefixSides p (uCost p w A) (spineAt p y K) (p.spineLen[y]! - K) := by + rw [show p.spineLen[y]! - k = (K - k) + (p.spineLen[y]! - K) by omega, + prefixSides_add, hsp] + have := tag4Size_mono (show K ≤ p.spineLen[y]! by omega) + unfold natFrom + omega + · obtain ⟨j, h1, h2, hA, rfl⟩ := mem_cutsRange.mp he + by_cases hjK : j < K + · exact foldl_min_le _ _ _ (List.mem_cons_of_mem _ (mem_cutsRange.mpr ⟨j, h1, hjK, hA, rfl⟩)) + · exact Nat.le_trans hle (hge j (by omega)) + +/-! ## Locality -/ + +/-- Every opaque term is opaque under `A`. -/ +def OpaqueOn (p : Prep) (w : Nat) (O A : Nat → Bool) : Prop := + ∀ t, t < p.dag.size → O t = true → OpaqueAt p w A t + +/-- The cost of a term below `y` agrees under `A` and `B` when it is opaque or +when `A` and `B` agree on everything it reaches. -/ +def CostAgree (p : Prep) (w : Nat) (O A B : Nat → Bool) (y : Nat) : Prop := + ∀ c, c < y → (∀ v, NReach p O c v → A v = B v) → uCost p w A c = uCost p w B c + +theorem PrepWF.cost_agree_of {p : Prep} (hp : PrepWF p) {w : Nat} {O A B : Nat → Bool} {y : Nat} + (hy : y < p.dag.size) (hA : OpaqueOn p w O A) (hB : OpaqueOn p w O B) + (hc : CostAgree p w O A B y) {u c : Nat} (hcy : c < y) + (hu : ∃ k, k < (p.dag.node u).head.arity ∧ (p.dag.node u).child k = c) {z : Nat} + (hzu : NReach p O z u) (hzu' : u = z ∨ O u = false) + (hagree : ∀ v, NReach p O z v → A v = B v) : uCost p w A c = uCost p w B c := by + by_cases hO : O c = true + · rw [hp.opaque_cost (by omega) (hA c (by omega) hO), hp.opaque_cost (by omega) (hB c (by omega) hO)] + · have hO' : O c = false := by simpa using hO + exact hc c hcy fun v hv => hagree v (hzu.trans hzu' (NReach.of_child hO' hu hv)) + +theorem exists_min_nat (P : Nat → Prop) (h : ∃ n, P n) : ∃ n, P n ∧ ∀ m, m < n → ¬ P m := by + classical + obtain ⟨n, hn⟩ := h + induction n using Nat.strongRecOn with + | _ n ih => + by_cases hm : ∃ m, m < n ∧ P m + · obtain ⟨m, hmn, hpm⟩ := hm + exact ih m hmn hpm + · exact ⟨n, hn, fun m hmn hpm => hm ⟨m, hmn, hpm⟩⟩ + +/-- **Locality of a telescope ending.** The cheapest ending of `y`'s telescope +from position `k ≥ 1` is the same under `A` and `B` when the spine node there +is opaque, or when `A` and `B` agree on everything it reaches. -/ +theorem PrepWF.teleFrom_local_lt {p : Prep} (hp : PrepWF p) (w : Nat) (O : Nat → Bool) {y k : Nat} + (hy : y < p.dag.size) (hf : p.family[y]! ≠ .none) (hkl : k < p.spineLen[y]!) + {A B : Nat → Bool} (hA : OpaqueOn p w O A) (hB : OpaqueOn p w O B) + (hc : CostAgree p w O A B y) + (hagree : O (spineAt p y k) = false → ∀ v, NReach p O (spineAt p y k) v → A v = B v) : + teleFrom p w A (uCost p w A) y k = teleFrom p w B (uCost p w B) y k := by + classical + have hsk : ∀ j, j < p.spineLen[y]! → spineAt p y j < p.dag.size ∧ + p.family[spineAt p y j]! ≠ .none := by + intro j hj + obtain ⟨hts, htf, _⟩ := hp.spine_shift hy hf (k := j) hj + exact ⟨hts, by rw [htf]; exact hf⟩ + -- agreement on the spine prefix `[k, J)` free of opaque nodes after `k` + have hside : ∀ J, J ≤ p.spineLen[y]! → O (spineAt p y k) = false → + (∀ i, k < i → i < J → O (spineAt p y i) = false) → + (∀ j, k ≤ j → j < J → A (spineAt p y j) = B (spineAt p y j)) ∧ + (∀ m, k + m ≤ J → prefixSides p (uCost p w A) (spineAt p y k) m = + prefixSides p (uCost p w B) (spineAt p y k) m) := by + intro J hJ hOk hO + have hreach : ∀ j, k ≤ j → j < J → NReach p O (spineAt p y k) (spineAt p y j) := + fun j h1 h2 => hp.spine_nreach hy hf j h1 (by omega) (fun i hi1 hi2 => hO i hi1 (by omega)) + have hnO : ∀ j, k ≤ j → j < J → (spineAt p y j = spineAt p y k ∨ O (spineAt p y j) = false) := by + intro j h1 h2 + by_cases hjk : j = k + · exact Or.inl (by rw [hjk]) + · exact Or.inr (hO j (by omega) h2) + refine ⟨fun j h1 h2 => hagree hOk _ (hreach j h1 h2), fun m hm => ?_⟩ + apply prefixSides_local + intro i hi + have hsa : sideAt p (spineAt p y k) i = sideAt p y (k + i) := by + unfold sideAt; rw [spineAt_add] + rw [hsa] + obtain ⟨hts, hfs⟩ := hsk (k + i) (by omega) + have hlt := hp.sideAt_lt hy hf (k := k + i) (by omega) + exact hp.cost_agree_of hy hA hB hc hlt (hp.side_edge hts hfs) (hreach (k + i) (by omega) (by omega)) + (hnO (k + i) (by omega) (by omega)) (hagree hOk) + by_cases hex : ∃ K, k ≤ K ∧ K < p.spineLen[y]! ∧ O (spineAt p y K) = true + · obtain ⟨K, ⟨hK1, hK2, hK3⟩, hKmin⟩ := exists_min_nat _ hex + have hmin : ∀ i, k ≤ i → i < K → O (spineAt p y i) = false := by + intro i h1 h2 + cases hOi : O (spineAt p y i) + · rfl + · exact absurd ⟨h1, by omega, hOi⟩ (hKmin i h2) + obtain ⟨hts, _⟩ := hsk K hK2 + rw [hp.teleFrom_dom hy hf hK1 hK2 (hA _ hts hK3), hp.teleFrom_dom hy hf hK1 hK2 (hB _ hts hK3)] + by_cases hKk : K = k + · have : (cutsRange p w A (uCost p w A) y k K) = [] := by + unfold cutsRange; rw [hKk]; simp + have h2 : (cutsRange p w B (uCost p w B) y k K) = [] := by + unfold cutsRange; rw [hKk]; simp + rw [this, h2, hKk] + simp [prefixSides] + · have hOk : O (spineAt p y k) = false := hmin k (Nat.le_refl _) (by omega) + obtain ⟨hav, hps⟩ := hside K (by omega) hOk (fun i h1 h2 => hmin i (by omega) h2) + have hlist : cutsRange p w A (uCost p w A) y k K = cutsRange p w B (uCost p w B) y k K := by + unfold cutsRange + apply filterMap_congr' + intro j hj + rw [List.mem_range'_1] at hj + rw [hav j hj.1 (by omega), hps (j - k) (by omega)] + rw [hlist, hps (K - k) (by omega)] + · have hnoO : ∀ i, k ≤ i → i < p.spineLen[y]! → O (spineAt p y i) = false := by + intro i h1 h2 + cases hOi : O (spineAt p y i) + · rfl + · exact absurd ⟨i, h1, h2, hOi⟩ hex + have hOk := hnoO k (Nat.le_refl _) hkl + obtain ⟨hav, hps⟩ := hside p.spineLen[y]! (Nat.le_refl _) hOk + (fun i h1 h2 => hnoO i (by omega) h2) + have hlist : cutsRange p w A (uCost p w A) y k p.spineLen[y]! = + cutsRange p w B (uCost p w B) y k p.spineLen[y]! := by + unfold cutsRange + apply filterMap_congr' + intro j hj + rw [List.mem_range'_1] at hj + rw [hav j hj.1 (by omega), hps (j - k) (by omega)] + -- the tail + obtain ⟨hl1, _, hend, htl, _⟩ := hp.spine y hy hf + have hlast := hsk (p.spineLen[y]! - 1) (by omega) + have htail : uCost p w A p.tail[y]! = uCost p w B p.tail[y]! := by + have hedge := hp.snext_edge hlast.1 hlast.2 + rw [snext_spineAt, show p.spineLen[y]! - 1 + 1 = p.spineLen[y]! by omega, hend] at hedge + refine hp.cost_agree_of hy hA hB hc htl hedge + (hp.spine_nreach hy hf (p.spineLen[y]! - 1) (by omega) (by omega) + (fun i h1 h2 => hnoO i (by omega) (by omega))) ?_ (hagree hOk) + by_cases hlk : p.spineLen[y]! - 1 = k + · exact Or.inl (by rw [hlk]) + · exact Or.inr (hnoO _ (by omega) (by omega)) + unfold teleFrom natFrom + rw [hlist, hps (p.spineLen[y]! - k) (by omega), htail] + +theorem PrepWF.teleFrom_local {p : Prep} (hp : PrepWF p) (w : Nat) (O : Nat → Bool) {y k : Nat} + (hy : y < p.dag.size) (hf : p.family[y]! ≠ .none) (hkl : k ≤ p.spineLen[y]!) + {A B : Nat → Bool} (hA : OpaqueOn p w O A) (hB : OpaqueOn p w O B) + (hc : CostAgree p w O A B y) + (hagree : O (spineAt p y k) = false → ∀ v, NReach p O (spineAt p y k) v → A v = B v) : + teleFrom p w A (uCost p w A) y k = teleFrom p w B (uCost p w B) y k := by + by_cases hkl' : k = p.spineLen[y]! + · obtain ⟨hl1, _, hend, htl, _⟩ := hp.spine y hy hf + have hcuts : ∀ (C : Nat → Bool) (cost : Nat → Nat), + cutsRange p w C cost y k p.spineLen[y]! = [] := by + intro C cost; unfold cutsRange; rw [hkl']; simp + have htail : uCost p w A p.tail[y]! = uCost p w B p.tail[y]! := by + by_cases hO : O p.tail[y]! = true + · rw [hp.opaque_cost (by omega) (hA _ (by omega) hO), + hp.opaque_cost (by omega) (hB _ (by omega) hO)] + · rw [hkl', hend] at hagree + exact hc _ htl (hagree (by simpa using hO)) + unfold teleFrom natFrom + rw [hcuts, hcuts, htail, hkl', Nat.sub_self] + rfl + · exact hp.teleFrom_local_lt w O hy hf (by omega) hA hB hc hagree + +/-- **Locality.** The costs of `y` are the same under two availabilities +(both making every opaque term opaque) that agree on every term reachable +from `y` along paths whose intermediate terms are not opaque. -/ +theorem PrepWF.uCost_local {p : Prep} (hp : PrepWF p) (w : Nat) (O : Nat → Bool) : + ∀ y, y < p.dag.size → ∀ (A B : Nat → Bool), OpaqueOn p w O A → OpaqueOn p w O B → + (∀ v, NReach p O y v → A v = B v) → + uCost p w A y = uCost p w B y ∧ uInl p w A y = uInl p w B y := by + intro y + induction y using Nat.strongRecOn with + | _ y ih => + intro hy A B hA hB hagree + have hc : CostAgree p w O A B y := fun c hcy hcag => (ih c hcy (by omega) A B hA hB hcag).1 + have hinl : uInl p w A y = uInl p w B y := by + unfold uInl + by_cases hf : p.family[y]! = .none + · unfold inlOf + rw [if_pos hf, if_pos hf] + apply foldl_add_congr + intro c hcm + obtain ⟨i, hi, rfl⟩ := Array.mem_iff_getElem.mp hcm + have har := hp.dag.arity y hy + rw [← dag_node_eq hy] at har + have hci : (p.dag.node y).child i = (p.dag.node y).children[i] := + Ix.Compile.Verify.SharingExact.child_eq_getElem _ i hi + rw [← hci] + have hlt := hp.dag.childAt_lt hy (k := i) (by omega) + exact hp.cost_agree_of hy hA hB hc hlt ⟨i, by omega, rfl⟩ .refl (Or.inl rfl) hagree + · rw [hp.inl_split w A _ hf (Nat.le_refl _) ((hp.spine y hy hf).1) (fun j h1 h2 => by omega), + hp.inl_split w B _ hf (Nat.le_refl _) ((hp.spine y hy hf).1) (fun j h1 h2 => by omega)] + have hside : prefixSides p (uCost p w A) y 1 = prefixSides p (uCost p w B) y 1 := by + simp only [prefixSides, sideCost] + have hlt := hp.sideChild_lt (t := y) hy hf + rw [hp.cost_agree_of hy hA hB hc hlt (hp.side_edge hy hf) .refl (Or.inl rfl) hagree] + have hs1 : spineAt p y 1 = snext p y := rfl + rw [hside, hp.teleFrom_local w O (k := 1) hy hf ((hp.spine y hy hf).1) hA hB hc + (fun hO1 v hv => by + rw [hs1] at hO1 hv + exact hagree v (NReach.trans (.tail .refl (Or.inl rfl) (hp.snext_edge hy hf)) + (Or.inr hO1) hv))] + refine ⟨?_, hinl⟩ + rw [hp.uCost_eq w A y hy, hp.uCost_eq w B y hy] + unfold costOf + rw [hagree y .refl] + unfold uInl at hinl + rw [hinl] + +/-! ## Modularity -/ + +theorem arr_foldl_add_eq_sum (f : Nat → Nat) (a : Nat) (arr : Array Nat) : + arr.foldl (fun acc c => acc + f c) a = a + (arr.toList.map f).sum := by + rw [← Array.foldl_toList] + generalize arr.toList = l + induction l generalizing a with + | nil => simp + | cons x xs ih => + simp only [List.foldl_cons, List.map_cons, List.sum_cons, ih] + omega + +theorem prefixSides_modular (p : Prep) {f12 f0 f1 f2 : Nat → Nat} : + ∀ (j t : Nat), (∀ i, i < j → f12 (sideAt p t i) + f0 (sideAt p t i) = + f1 (sideAt p t i) + f2 (sideAt p t i)) → + prefixSides p f12 t j + prefixSides p f0 t j = prefixSides p f1 t j + prefixSides p f2 t j := by + intro j + induction j with + | zero => intro _ _; rfl + | succ j ih => + intro t h + simp only [prefixSides, sideCost] + have h0 := h 0 (by omega) + simp only [sideAt, spineAt] at h0 + have hr := ih (snext p t) (fun i hi => by + have := h (i + 1) (by omega) + simp only [sideAt, spineAt] at this ⊢ + exact this) + omega + +/-- Adding `Z₁`, `Z₂` to a base availability `A₀`. -/ +def addAvail (A Z : Nat → Bool) : Nat → Bool := fun v => A v || Z v + +/-- No term reachable from `x` (along non-opaque paths) is in `Z`. -/ +def Unreached (p : Prep) (O Z : Nat → Bool) (x : Nat) : Prop := + ∀ v, NReach p O x v → Z v = false + +theorem agree_of_unreached {p : Prep} {O A Z : Nat → Bool} {x : Nat} (h : Unreached p O Z x) : + ∀ v, NReach p O x v → addAvail A Z v = A v := by + intro v hv + simp [addAvail, h v hv] + +/-- **Modularity.** Let every opaque term be opaque under the base `A₀` and +under each of `A₀ ∪ Z₁`, `A₀ ∪ Z₂`, `A₀ ∪ Z₁ ∪ Z₂`, and let no available +non-opaque term reach both `Z₁` and `Z₂` (along non-opaque paths). Then +adding both changes every cost by the sum of adding each: +`C₁₂ + C₀ = C₁ + C₂` for `uCost` and for `uInl`. -/ +theorem PrepWF.uCost_modular {p : Prep} (hp : PrepWF p) (w : Nat) (O A0 Z1 Z2 : Nat → Bool) + (h0 : OpaqueOn p w O A0) (h1 : OpaqueOn p w O (addAvail A0 Z1)) + (h2 : OpaqueOn p w O (addAvail A0 Z2)) + (h12 : OpaqueOn p w O (addAvail (addAvail A0 Z1) Z2)) + (hsep : ∀ v, v < p.dag.size → addAvail (addAvail A0 Z1) Z2 v = true → O v = false → + Unreached p O Z1 v ∨ Unreached p O Z2 v) : + ∀ y, y < p.dag.size → + uCost p w (addAvail (addAvail A0 Z1) Z2) y + uCost p w A0 y = + uCost p w (addAvail A0 Z1) y + uCost p w (addAvail A0 Z2) y ∧ + uInl p w (addAvail (addAvail A0 Z1) Z2) y + uInl p w A0 y = + uInl p w (addAvail A0 Z1) y + uInl p w (addAvail A0 Z2) y := by + -- shorthands + have hA12_1 : ∀ x, Unreached p O Z2 x → ∀ v, NReach p O x v → + addAvail (addAvail A0 Z1) Z2 v = addAvail A0 Z1 v := + fun x hx => agree_of_unreached hx + have hA2_0 : ∀ x, Unreached p O Z2 x → ∀ v, NReach p O x v → addAvail A0 Z2 v = A0 v := + fun x hx => agree_of_unreached hx + have hA12_2 : ∀ x, Unreached p O Z1 x → ∀ v, NReach p O x v → + addAvail (addAvail A0 Z1) Z2 v = addAvail A0 Z2 v := by + intro x hx v hv + simp [addAvail, hx v hv] + have hA1_0 : ∀ x, Unreached p O Z1 x → ∀ v, NReach p O x v → addAvail A0 Z1 v = A0 v := + fun x hx => agree_of_unreached hx + have hcostAgree : ∀ (A B : Nat → Bool), OpaqueOn p w O A → OpaqueOn p w O B → ∀ y, + y < p.dag.size → CostAgree p w O A B y := + fun A B hA hB y hy c hcy hag => (hp.uCost_local w O c (by omega) A B hA hB hag).1 + intro y + induction y using Nat.strongRecOn with + | _ y ih => + intro hy + -- a side that one of the sets does not reach + have hlocal : Unreached p O Z1 y ∨ Unreached p O Z2 y → + uCost p w (addAvail (addAvail A0 Z1) Z2) y + uCost p w A0 y = + uCost p w (addAvail A0 Z1) y + uCost p w (addAvail A0 Z2) y ∧ + uInl p w (addAvail (addAvail A0 Z1) Z2) y + uInl p w A0 y = + uInl p w (addAvail A0 Z1) y + uInl p w (addAvail A0 Z2) y := by + rintro (hu | hu) + · obtain ⟨a1, a2⟩ := hp.uCost_local w O y hy _ _ h12 h2 (hA12_2 y hu) + obtain ⟨b1, b2⟩ := hp.uCost_local w O y hy _ _ h1 h0 (hA1_0 y hu) + omega + · obtain ⟨a1, a2⟩ := hp.uCost_local w O y hy _ _ h12 h1 (hA12_1 y hu) + obtain ⟨b1, b2⟩ := hp.uCost_local w O y hy _ _ h2 h0 (hA2_0 y hu) + omega + -- the inline costs are modular in every case + have hinl : uInl p w (addAvail (addAvail A0 Z1) Z2) y + uInl p w A0 y = + uInl p w (addAvail A0 Z1) y + uInl p w (addAvail A0 Z2) y := by + unfold uInl + by_cases hf : p.family[y]! = .none + · unfold inlOf + simp only [if_pos hf] + rw [arr_foldl_add_eq_sum, arr_foldl_add_eq_sum, arr_foldl_add_eq_sum, + arr_foldl_add_eq_sum] + have hch : ∀ c ∈ (p.dag.node y).children.toList, + uCost p w (addAvail (addAvail A0 Z1) Z2) c + uCost p w A0 c = + uCost p w (addAvail A0 Z1) c + uCost p w (addAvail A0 Z2) c := by + intro c hc + have hlt := hp.dag.child_lt hy (Array.mem_toList_iff.mp hc) + exact (ih c hlt (by omega)).1 + have e := congrArg List.sum (List.map_congr_left hch) + simp only [sum_map_add'] at e + omega + · have hl1 := (hp.spine y hy hf).1 + have hsub : ∀ (X : Nat → Bool), (X = A0 ∨ X = addAvail A0 Z1 ∨ X = addAvail A0 Z2 ∨ + X = addAvail (addAvail A0 Z1) Z2) → ∀ v, X v = true → + addAvail (addAvail A0 Z1) Z2 v = true := by + intro X hX v hv + rcases hX with h | h | h | h <;> rw [h] at hv <;> + (simp only [addAvail] at hv ⊢; revert hv; cases A0 v <;> cases Z1 v <;> cases Z2 v <;> decide) + have hsides : ∀ j, j ≤ p.spineLen[y]! → + prefixSides p (uCost p w (addAvail (addAvail A0 Z1) Z2)) y j + + prefixSides p (uCost p w A0) y j = + prefixSides p (uCost p w (addAvail A0 Z1)) y j + + prefixSides p (uCost p w (addAvail A0 Z2)) y j := by + intro j hj + apply prefixSides_modular + intro i hi + exact (ih _ (hp.sideAt_lt hy hf (k := i) (by omega)) (by + have := hp.sideAt_lt hy hf (k := i) (by omega); omega)).1 + by_cases hex : ∃ k, 1 ≤ k ∧ k < p.spineLen[y]! ∧ + addAvail (addAvail A0 Z1) Z2 (spineAt p y k) = true + · obtain ⟨K1, ⟨hK1a, hK1b, hK1c⟩, hKmin⟩ := exists_min_nat _ hex + have hnone : ∀ (X : Nat → Bool), (∀ v, X v = true → + addAvail (addAvail A0 Z1) Z2 v = true) → + ∀ j, 1 ≤ j → j < K1 → X (spineAt p y j) = false := by + intro X hX j h1 h2 + cases hXj : X (spineAt p y j) + · rfl + · exact absurd ⟨h1, by omega, hX _ hXj⟩ (hKmin j h2) + rw [hp.inl_split w _ _ hf hK1a (by omega) (hnone _ (hsub _ (Or.inr (Or.inr (Or.inr rfl))))), + hp.inl_split w _ _ hf hK1a (by omega) (hnone _ (hsub _ (Or.inl rfl))), + hp.inl_split w _ _ hf hK1a (by omega) (hnone _ (hsub _ (Or.inr (Or.inl rfl)))), + hp.inl_split w _ _ hf hK1a (by omega) (hnone _ (hsub _ (Or.inr (Or.inr (Or.inl rfl)))))] + have hpre := hsides K1 (by omega) + obtain ⟨hts, _⟩ := hp.spine_shift hy hf (k := K1) hK1b + have htele : teleFrom p w (addAvail (addAvail A0 Z1) Z2) + (uCost p w (addAvail (addAvail A0 Z1) Z2)) y K1 + + teleFrom p w A0 (uCost p w A0) y K1 = + teleFrom p w (addAvail A0 Z1) (uCost p w (addAvail A0 Z1)) y K1 + + teleFrom p w (addAvail A0 Z2) (uCost p w (addAvail A0 Z2)) y K1 := by + by_cases hOK : O (spineAt p y K1) = true + · rw [hp.teleFrom_dom hy hf (Nat.le_refl _) hK1b (h12 _ hts hOK), + hp.teleFrom_dom hy hf (Nat.le_refl _) hK1b (h0 _ hts hOK), + hp.teleFrom_dom hy hf (Nat.le_refl _) hK1b (h1 _ hts hOK), + hp.teleFrom_dom hy hf (Nat.le_refl _) hK1b (h2 _ hts hOK)] + simp [cutsRange, prefixSides] + · have hOK' : O (spineAt p y K1) = false := by simpa using hOK + rcases hsep _ hts hK1c hOK' with hu | hu + · rw [hp.teleFrom_local w O hy hf (by omega) h12 h2 (hcostAgree _ _ h12 h2 y hy) + (fun _ => hA12_2 _ hu), + hp.teleFrom_local w O hy hf (by omega) h1 h0 (hcostAgree _ _ h1 h0 y hy) + (fun _ => hA1_0 _ hu)] + omega + · rw [hp.teleFrom_local w O hy hf (by omega) h12 h1 (hcostAgree _ _ h12 h1 y hy) + (fun _ => hA12_1 _ hu), + hp.teleFrom_local w O hy hf (by omega) h2 h0 (hcostAgree _ _ h2 h0 y hy) + (fun _ => hA2_0 _ hu)] + omega + · have hnone : ∀ (X : Nat → Bool), (∀ v, X v = true → + addAvail (addAvail A0 Z1) Z2 v = true) → + ∀ j, 1 ≤ j → j < p.spineLen[y]! → X (spineAt p y j) = false := by + intro X hX j h1 h2 + cases hXj : X (spineAt p y j) + · rfl + · exact absurd ⟨j, h1, h2, hX _ hXj⟩ hex + rw [hp.inl_split w _ _ hf hl1 (Nat.le_refl _) (hnone _ (hsub _ (Or.inr (Or.inr (Or.inr rfl))))), + hp.inl_split w _ _ hf hl1 (Nat.le_refl _) (hnone _ (hsub _ (Or.inl rfl))), + hp.inl_split w _ _ hf hl1 (Nat.le_refl _) (hnone _ (hsub _ (Or.inr (Or.inl rfl)))), + hp.inl_split w _ _ hf hl1 (Nat.le_refl _) (hnone _ (hsub _ (Or.inr (Or.inr (Or.inl rfl)))))] + have hpre := hsides p.spineLen[y]! (Nat.le_refl _) + obtain ⟨_, _, _, htl, _⟩ := hp.spine y hy hf + have htail := (ih p.tail[y]! htl (by omega)).1 + simp only [teleFrom, natFrom, cutsRange, Nat.sub_self, List.range'_zero, + List.filterMap_nil, List.foldl_nil, prefixSides] + omega + by_cases hreach : Unreached p O Z1 y ∨ Unreached p O Z2 y + · exact hlocal hreach + · refine ⟨?_, hinl⟩ + by_cases hO : O y = true + · rw [hp.opaque_cost hy (h12 y hy hO), hp.opaque_cost hy (h0 y hy hO), + hp.opaque_cost hy (h1 y hy hO), hp.opaque_cost hy (h2 y hy hO)] + · have hO' : O y = false := by simpa using hO + have hA : addAvail (addAvail A0 Z1) Z2 y = false := by + cases hav : addAvail (addAvail A0 Z1) Z2 y + · rfl + · exact absurd (hsep y hy hav hO') hreach + have hA0 : A0 y = false := by simp [addAvail] at hA; exact hA.1.1 + have hA1 : addAvail A0 Z1 y = false := by simp [addAvail] at hA ⊢; exact hA.1 + have hA2 : addAvail A0 Z2 y = false := by simp [addAvail] at hA ⊢; exact ⟨hA.1.1, hA.2⟩ + rw [hp.uCost_eq w _ y hy, hp.uCost_eq w A0 y hy, hp.uCost_eq w (addAvail A0 Z1) y hy, + hp.uCost_eq w (addAvail A0 Z2) y hy] + unfold costOf + rw [hA, hA0, hA1, hA2] + simp only [Bool.false_eq_true, if_false] + unfold uInl at hinl + exact hinl + +/-! ## The uniform length -/ + +theorem mem_append_avail (a b : List Nat) (y : Nat) : + decide (y ∈ a ++ b) = (decide (y ∈ a) || decide (y ∈ b)) := by + by_cases ha : y ∈ a <;> by_cases hb : y ∈ b <;> simp [ha, hb] + +/-- **Modularity of the uniform length.** For stored lists `cs`, `z₁`, `z₂` +with every term of `cs` opaque (in the base and the three extensions), no term +of `z₁`, `z₂` opaque, and no available non-opaque term reaching both `z₁` +and `z₂` along non-opaque paths: +`L(cs ++ z₁ ++ z₂) + L(cs) = L(cs ++ z₁) + L(cs ++ z₂)` up to the count's +TagN (each side carries the other side's TagN terms). -/ +theorem uniformCost_modular {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) {cs z1 z2 : List Nat} + (hin : ∀ t ∈ cs ++ z1 ++ z2, t < dag.size) + (hop : ∀ (A : List Nat), (A = cs ∨ A = cs ++ z1 ∨ A = cs ++ z2 ∨ A = cs ++ z1 ++ z2) → + OpaqueOn (Prep.ofDag dag) w (fun y => decide (y ∈ cs)) (fun y => decide (y ∈ A))) + (_hz : ∀ t ∈ z1 ++ z2, t ∉ cs) + (hsep : ∀ v, v < dag.size → v ∈ z1 ++ z2 → + Unreached (Prep.ofDag dag) (fun y => decide (y ∈ cs)) (fun y => decide (y ∈ z1)) v ∨ + Unreached (Prep.ofDag dag) (fun y => decide (y ∈ cs)) (fun y => decide (y ∈ z2)) v) : + ulen dag w roots (cs ++ z1 ++ z2) + ulen dag w roots cs + + tag0Size (cs ++ z1).length + tag0Size (cs ++ z2).length = + ulen dag w roots (cs ++ z1) + ulen dag w roots (cs ++ z2) + + tag0Size (cs ++ z1 ++ z2).length + tag0Size cs.length := by + have hp := prepWF_ofDag hwf + let O : Nat → Bool := fun y => decide (y ∈ cs) + let A0 : Nat → Bool := fun y => decide (y ∈ cs) + let Z1 : Nat → Bool := fun y => decide (y ∈ z1) + let Z2 : Nat → Bool := fun y => decide (y ∈ z2) + have e1 : (fun y => decide (y ∈ cs ++ z1)) = addAvail A0 Z1 := by + funext y; simp only [addAvail, A0, Z1]; exact mem_append_avail cs z1 y + have e2 : (fun y => decide (y ∈ cs ++ z2)) = addAvail A0 Z2 := by + funext y; simp only [addAvail, A0, Z2]; exact mem_append_avail cs z2 y + have e12 : (fun y => decide (y ∈ cs ++ z1 ++ z2)) = addAvail (addAvail A0 Z1) Z2 := by + funext y; simp only [addAvail, A0, Z1, Z2] + rw [mem_append_avail (cs ++ z1) z2 y, mem_append_avail cs z1 y] + have h0 := hop cs (Or.inl rfl) + have h1 : OpaqueOn (Prep.ofDag dag) w O (addAvail A0 Z1) := by + rw [← e1]; exact hop _ (Or.inr (Or.inl rfl)) + have h2 : OpaqueOn (Prep.ofDag dag) w O (addAvail A0 Z2) := by + rw [← e2]; exact hop _ (Or.inr (Or.inr (Or.inl rfl))) + have h12 : OpaqueOn (Prep.ofDag dag) w O (addAvail (addAvail A0 Z1) Z2) := by + rw [← e12]; exact hop _ (Or.inr (Or.inr (Or.inr rfl))) + have hsep' : ∀ v, v < (Prep.ofDag dag).dag.size → addAvail (addAvail A0 Z1) Z2 v = true → + O v = false → Unreached (Prep.ofDag dag) O Z1 v ∨ Unreached (Prep.ofDag dag) O Z2 v := by + intro v hv hav hO + rw [ofDag_dag] at hv + have : v ∈ z1 ++ z2 := by + simp only [addAvail, A0, Z1, Z2, O, Bool.or_eq_true, decide_eq_true_eq, + decide_eq_false_iff_not] at hav hO + rw [List.mem_append] + rcases hav with (h | h) | h + · exact absurd h hO + · exact Or.inl h + · exact Or.inr h + exact hsep v hv this + have hmod := hp.uCost_modular w O A0 Z1 Z2 h0 h1 h2 h12 hsep' + have hloc1 : ∀ t ∈ z1, uInl (Prep.ofDag dag) w (addAvail (addAvail A0 Z1) Z2) t = + uInl (Prep.ofDag dag) w (addAvail A0 Z1) t := by + intro t ht + have htn := hin t (by simp [ht]) + rcases hsep t htn (by simp [ht]) with hu | hu + · exact absurd (hu t .refl) (by simp [ht]) + · exact (hp.uCost_local w O t (by rw [ofDag_dag]; exact htn) _ _ h12 h1 + (agree_of_unreached hu)).2 + have hloc2 : ∀ t ∈ z2, uInl (Prep.ofDag dag) w (addAvail (addAvail A0 Z1) Z2) t = + uInl (Prep.ofDag dag) w (addAvail A0 Z2) t := by + intro t ht + have htn := hin t (by simp [ht]) + rcases hsep t htn (by simp [ht]) with hu | hu + · have hagree : ∀ v, NReach (Prep.ofDag dag) O t v → + addAvail (addAvail A0 Z1) Z2 v = addAvail A0 Z2 v := by + intro v hv + have := hu v hv + simp only [addAvail, Z1] at this ⊢ + rw [this] + simp + exact (hp.uCost_local w O t (by rw [ofDag_dag]; exact htn) _ _ h12 h2 hagree).2 + · exact absurd (hu t .refl) (by simp [ht]) + simp only [ulen, uniformCost] + rw [e1, e2, e12] + simp only [List.map_append, List.sum_append] + have hcs := congrArg List.sum (List.map_congr_left (l := cs) fun t ht => + (hmod t (by rw [ofDag_dag]; exact hin t (by simp [ht]))).2) + have hr := congrArg List.sum (List.map_congr_left (l := roots.toList) fun r hr => + (hmod r (by rw [ofDag_dag]; exact hroots r hr)).1) + simp only [sum_map_add'] at hcs hr + rw [List.map_congr_left hloc1, List.map_congr_left hloc2] + simp only [A0] at hcs hr ⊢ + omega + +/-! ## Certain-stored terms are opaque; components are separated -/ + +/-- A gain of at least 1 puts the bounds above the reference width. -/ +theorem gain_opaque_bounds {p : Prep} {b : UBounds} {w t d h : Nat} (hhd : h ≤ d) + (hg : 1 ≤ storedGainWith p b w t d h) : + (p.family[t]! = .none → w < b.inlineLB[t]!) ∧ + (p.family[t]! ≠ .none → w ≤ b.mergedLB[t]!) := by + have hd1 := gain_d_pos hhd hg + unfold storedGainWith at hg + simp only [_root_.Int.ofNat_eq_natCast] at hg + refine ⟨fun hf => ?_, fun hf => ?_⟩ + · have hfb : (p.family[t]! == Family.none) = true := by simp [hf] + rw [if_pos hfb] at hg + by_cases hlt : w < b.inlineLB[t]! + · exact hlt + · exfalso + have e := int_mul_le_mul_left' (show ((b.inlineLB[t]! : Nat) : _root_.Int) ≤ (w : _root_.Int) by omega) + (show (0 : _root_.Int) ≤ (d : _root_.Int) - 1 by omega) + simp only [_root_.Int.sub_mul, _root_.Int.one_mul] at e hg + omega + · have hfb : (p.family[t]! == Family.none) = false := by simpa using hf + rw [if_neg (by simp [hfb])] at hg + by_cases hle : w ≤ b.mergedLB[t]! + · exact hle + · exfalso + have e := int_mul_le_mul_left' (show ((b.mergedLB[t]! : Nat) : _root_.Int) ≤ (w : _root_.Int) - 1 by omega) + (show (0 : _root_.Int) ≤ (d : _root_.Int) - 1 by omega) + have hT := tag4Size_pos p.spineLen[t]! + split at hg + · simp only [_root_.Int.sub_mul, _root_.Int.mul_sub, _root_.Int.one_mul, _root_.Int.mul_one] at e hg + omega + · simp only [_root_.Int.sub_mul, _root_.Int.mul_sub, _root_.Int.one_mul, _root_.Int.mul_one] at e hg + omega + +/-- **Certain-stored terms are opaque** in every available set within the +candidates that contains them. -/ +theorem certainStored_opaque {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) (θ : _root_.Int) (hθ : 1 ≤ θ) + {t : Nat} (htn : t < dag.size) + (hcls : (classifyWith (Prep.ofDag dag) (graphFacts dag roots) w + (uniformBounds (Prep.ofDag dag) w (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)) + (visibleCounts dag roots (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)) θ)[t]! = + .certainStored) + {A : Nat → Bool} (hAt : A t = true) + (hA : ∀ v, A v = true → + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)[v]! = true) : + OpaqueAt (Prep.ofDag dag) w A t := by + have hp := prepWF_ofDag hwf + let cand := searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w + have hg : θ ≤ storedGainWith (Prep.ofDag dag) (uniformBounds (Prep.ofDag dag) w cand) w t + (visibleCounts dag roots cand).1[t]! (visibleCounts dag roots cand).2[t]! := by + simp only [classifyWith] at hcls + rw [getElem!_range_map _ (by rw [ofDag_dag]; exact htn)] at hcls + split at hcls + · cases hcls + · split at hcls + · cases hcls + · split at hcls + · rename_i hg; exact hg + · cases hcls + have hhd := vis_head_le hwf roots hroots cand htn + have hg1 : 1 ≤ storedGainWith (Prep.ofDag dag) (uniformBounds (Prep.ofDag dag) w cand) w t + (visibleCounts dag roots cand).1[t]! (visibleCounts dag roots cand).2[t]! := by omega + obtain ⟨hb1, hb2⟩ := gain_opaque_bounds hhd hg1 + have hbs := hp.bounds_sound w cand A hA t (by rw [ofDag_dag]; exact htn) + refine ⟨hAt, fun hf => ?_, fun hf => ?_⟩ + · have := hb1 hf; have := hbs.2.1; omega + · have := hb2 hf; have := (hbs.2.2 hf).1; omega + +/-- **Decomposition over components (Stage 4).** Let `cs` list the +certain-stored terms (threshold `θ ≥ 1`), and `z₁`, `z₂` uncertain terms +from different components of a labeling that is constant along non-opaque +paths between uncertain terms. Then the uniform length is modular: +`L(cs ∪ z₁ ∪ z₂) + L(cs) = L(cs ∪ z₁) + L(cs ∪ z₂)` up to the count's +TagN; by induction, the length without the TagN is a sum over +components. -/ +theorem components_modular {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) (θ : _root_.Int) (hθ : 1 ≤ θ) + {cs z1 z2 : List Nat} + (hcs : ∀ t ∈ cs, t < dag.size ∧ + (classifyWith (Prep.ofDag dag) (graphFacts dag roots) w + (uniformBounds (Prep.ofDag dag) w + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)) + (visibleCounts dag roots + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)) θ)[t]! = .certainStored) + (hz : ∀ t ∈ z1 ++ z2, t < dag.size ∧ + (classifyWith (Prep.ofDag dag) (graphFacts dag roots) w + (uniformBounds (Prep.ofDag dag) w + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)) + (visibleCounts dag roots + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)) θ)[t]! = .uncertain) + (comp : Nat → Nat) + (hcomp : ∀ a b, a ∈ z1 ++ z2 → b ∈ z1 ++ z2 → + NReach (Prep.ofDag dag) (fun y => decide (y ∈ cs)) a b → comp a = comp b) + (hdisj : ∀ a ∈ z1, ∀ b ∈ z2, comp a ≠ comp b) : + ulen dag w roots (cs ++ z1 ++ z2) + ulen dag w roots cs + + tag0Size (cs ++ z1).length + tag0Size (cs ++ z2).length = + ulen dag w roots (cs ++ z1) + ulen dag w roots (cs ++ z2) + + tag0Size (cs ++ z1 ++ z2).length + tag0Size cs.length := by + have hcand : ∀ t, t < dag.size → (classifyWith (Prep.ofDag dag) (graphFacts dag roots) w + (uniformBounds (Prep.ofDag dag) w + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)) + (visibleCounts dag roots + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)) θ)[t]! ≠ .certainExcluded → + (classifyWith (Prep.ofDag dag) (graphFacts dag roots) w + (uniformBounds (Prep.ofDag dag) w + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)) + (visibleCounts dag roots + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)) θ)[t]! ≠ .lowDegree → + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)[t]! = true := by + intro t ht h1 h2 + simp only [classifyWith] at h1 h2 + rw [getElem!_range_map _ (by rw [ofDag_dag]; exact ht)] at h1 h2 + unfold searchCandidates + rw [getElem!_range_map _ (by rw [ofDag_dag]; exact ht)] + simp only [Bool.and_eq_true, Bool.not_eq_true', decide_eq_true_eq] + by_cases hce : certainExcludedTest (Prep.ofDag dag) (graphFacts dag roots) w t = true + · exact absurd (by rw [if_pos hce]) h1 + · rw [if_neg hce] at h1 h2 + by_cases hdeg : (graphFacts dag roots).deg[t]! < 2 + · exact absurd (by rw [if_pos hdeg]) h2 + · exact ⟨by simpa using hce, by omega⟩ + have hin : ∀ t ∈ cs ++ z1 ++ z2, t < dag.size := by + intro t ht + rw [List.mem_append] at ht + rcases ht with ht | ht + · rw [List.mem_append] at ht + rcases ht with ht | ht + · exact (hcs t ht).1 + · exact (hz t (by simp [ht])).1 + · exact (hz t (by simp [ht])).1 + have hinCand : ∀ t ∈ cs ++ z1 ++ z2, + (searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w)[t]! = true := by + intro t ht + have htn := hin t ht + apply hcand t htn + · rw [List.mem_append, List.mem_append] at ht + rcases ht with (ht | ht) | ht + · rw [(hcs t ht).2]; exact fun h => by cases h + · rw [(hz t (by simp [ht])).2]; exact fun h => by cases h + · rw [(hz t (by simp [ht])).2]; exact fun h => by cases h + · rw [List.mem_append, List.mem_append] at ht + rcases ht with (ht | ht) | ht + · rw [(hcs t ht).2]; exact fun h => by cases h + · rw [(hz t (by simp [ht])).2]; exact fun h => by cases h + · rw [(hz t (by simp [ht])).2]; exact fun h => by cases h + apply uniformCost_modular hwf roots hroots w hin + · intro A hA t ht hO + simp only [decide_eq_true_eq] at hO + have htcs := hcs t hO + rw [ofDag_dag] at ht + apply certainStored_opaque hwf roots hroots w θ hθ ht htcs.2 + · simp only [decide_eq_true_eq] + rcases hA with rfl | rfl | rfl | rfl <;> simp [hO] + · intro v hv + simp only [decide_eq_true_eq] at hv + apply hinCand v + simp only [List.mem_append] + rcases hA with rfl | rfl | rfl | rfl + · exact Or.inl (Or.inl hv) + · simp only [List.mem_append] at hv + rcases hv with h | h + · exact Or.inl (Or.inl h) + · exact Or.inl (Or.inr h) + · simp only [List.mem_append] at hv + rcases hv with h | h + · exact Or.inl (Or.inl h) + · exact Or.inr h + · simp only [List.mem_append] at hv + exact hv + · intro t ht htcs + have h1 := (hz t ht).2 + rw [(hcs t htcs).2] at h1 + cases h1 + · intro v hv hvz + by_cases h1 : Unreached (Prep.ofDag dag) (fun y => decide (y ∈ cs)) (fun y => decide (y ∈ z1)) v + · exact Or.inl h1 + · right + intro b hb + cases hbz : decide (b ∈ z2) + · exact hbz + · exfalso + apply h1 + intro a ha + cases haz : decide (a ∈ z1) + · exact haz + · exfalso + simp only [decide_eq_true_eq] at hbz haz + have e1 := hcomp v a hvz (by simp [haz]) ha + have e2 := hcomp v b hvz (by simp [hbz]) hb + exact hdisj a haz b hbz (by rw [← e1, ← e2]) + +/-! ## The search lower bound -/ + +/-- Costs only drop when more terms are available. -/ +theorem PrepWF.costs_antitone {p : Prep} (hp : PrepWF p) (w : Nat) {A B : Nat → Bool} + (hAB : ∀ v, A v = true → B v = true) {t : Nat} (ht : t < p.dag.size) : + uCost p w B t ≤ uCost p w A t ∧ uInl p w B t ≤ uInl p w A t := by + obtain ⟨⟨T, hT, hTc⟩, ⟨U, hU, hUs, hUc⟩⟩ := hp.exists_opt w A t ht + have h1 := (hp.valid_cost w B (Valid.mono hAB hT) ht).1 + have h2 := (hp.valid_cost w B (Valid.mono hAB hU) ht).2 hUs + omega + +/-- A sub-list of a duplicate-free list sums to at most the whole. -/ +theorem sum_le_of_subset (f : Nat → Nat) : ∀ {l X : List Nat}, l.Nodup → X.Nodup → + (∀ t ∈ l, t ∈ X) → (l.map f).sum ≤ (X.map f).sum + | [], _, _, _, _ => by simp + | a :: as, X, hl, hX, hsub => by + have haX := hsub a List.mem_cons_self + rw [sum_erase haX f, List.map_cons, List.sum_cons] + have hnd := List.nodup_cons.mp hl + have := sum_le_of_subset f hnd.2 (hX.erase a) (fun t ht => by + rw [hX.mem_erase_iff] + exact ⟨fun h => hnd.1 (h ▸ ht), hsub t (List.mem_cons_of_mem _ ht)⟩) + omega + +/-- **The lower bound of a search node is sound.** For decided-stored `F` +and undecided `U`, the cost with `F ∪ U` available but only the entries of +`F` paid is at most the length (without the count's TagN) of every +completion `F ⊆ X ⊆ F ∪ U`. -/ +theorem lower_bound_sound {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) {F U X : List Nat} + (hF : ∀ t ∈ F, t ∈ X) (hX : ∀ t ∈ X, t ∈ F ∨ t ∈ U) (hXn : ∀ t ∈ X, t < dag.size) + (hFnd : F.Nodup) (hXnd : X.Nodup) : + (F.map (uInl (Prep.ofDag dag) w fun y => decide (y ∈ F ∨ y ∈ U))).sum + + (roots.toList.map (uCost (Prep.ofDag dag) w fun y => decide (y ∈ F ∨ y ∈ U))).sum ≤ + ulen dag w roots X - tag0Size X.length := by + suffices h : (F.map (uInl (Prep.ofDag dag) w fun y => decide (y ∈ F ∨ y ∈ U))).sum + + (roots.toList.map (uCost (Prep.ofDag dag) w fun y => decide (y ∈ F ∨ y ∈ U))).sum + + tag0Size X.length ≤ ulen dag w roots X by omega + have hp := prepWF_ofDag hwf + have hsub : ∀ v, decide (v ∈ X) = true → decide (v ∈ F ∨ v ∈ U) = true := by + intro v hv + simp only [decide_eq_true_eq] at hv ⊢ + exact hX v hv + have hroot : (roots.toList.map (uCost (Prep.ofDag dag) w fun y => decide (y ∈ F ∨ y ∈ U))).sum ≤ + (roots.toList.map (uCost (Prep.ofDag dag) w fun y => decide (y ∈ X))).sum := + sum_le_sum_of_le roots.toList fun r hr => + (hp.costs_antitone w hsub (by rw [ofDag_dag]; exact hroots r hr)).1 + have hent : (F.map (uInl (Prep.ofDag dag) w fun y => decide (y ∈ F ∨ y ∈ U))).sum ≤ + (F.map (uInl (Prep.ofDag dag) w fun y => decide (y ∈ X))).sum := + sum_le_sum_of_le F fun t ht => + (hp.costs_antitone w hsub (by rw [ofDag_dag]; exact hXn t (hF t ht))).2 + have hsubl : (F.map (uInl (Prep.ofDag dag) w fun y => decide (y ∈ X))).sum ≤ + (X.map (uInl (Prep.ofDag dag) w fun y => decide (y ∈ X))).sum := by + exact sum_le_of_subset _ hFnd hXnd hF + unfold ulen uniformCost + omega + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformExchange.lean b/Ix/Compile/Verify/UniformExchange.lean new file mode 100644 index 000000000..ac309d15a --- /dev/null +++ b/Ix/Compile/Verify/UniformExchange.lean @@ -0,0 +1,1357 @@ +import Ix.Compile.Verify.UniformWritings + +/-! +# The monotone exchange + +Adding a term `t ∉ S` to the stored set: every writing of the `S`-optimal +encoding is rewritten with `t`'s occurrences replaced by `Share(t)` (head +occurrences: a whole writing of `t`; continuation occurrences: the rest of +a telescope from `t` on), and `t` gets its `S`-optimal inline writing as +its entry. Descendants of `t` are untouched, each ancestor body gets a +`w`-byte leaf where `t`'s part was, and telescopes only shorten. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact + +/-! ## Merged part of a telescope -/ + +/-- The bytes of a telescope from `t` on, without its header: the side +bytes of the first `j` spine nodes and the tail (`w` for a cut). -/ +def mergedCuts (p : Prep) (w : Nat) (S : Nat → Bool) (cost : Nat → Nat) (t : Nat) : List Nat := + (List.range' 1 (p.spineLen[t]! - 1)).filterMap fun j => + if S (spineAt p t j) then some (prefixSides p cost t j + w) else none + +/-- `M_S(t)`: the cheapest headerless continuation of a telescope through +`t`. -/ +def mergedOf (p : Prep) (w : Nat) (S : Nat → Bool) (cost : Nat → Nat) (t : Nat) : Nat := + (mergedCuts p w S cost t).foldl min + (prefixSides p cost t p.spineLen[t]! + cost p.tail[t]!) + +theorem mem_mergedCuts {p : Prep} {w : Nat} {S : Nat → Bool} {f : Nat → Nat} {x c : Nat} + (h : c ∈ mergedCuts p w S f x) : + ∃ j, 1 ≤ j ∧ j < p.spineLen[x]! ∧ S (spineAt p x j) = true ∧ c = prefixSides p f x j + w := by + unfold mergedCuts at h + obtain ⟨j, hj, hjv⟩ := List.mem_filterMap.mp h + rw [List.mem_range'_1] at hj + split at hjv + · rename_i hS + simp only [Option.some.injEq] at hjv + exact ⟨j, hj.1, by omega, hS, hjv.symm⟩ + · cases hjv + +theorem merged_mem_mergedCuts (p : Prep) (w : Nat) (S : Nat → Bool) (f : Nat → Nat) {x j : Nat} + (hj1 : 1 ≤ j) (hj : j < p.spineLen[x]!) (hS : S (spineAt p x j) = true) : + prefixSides p f x j + w ∈ mergedCuts p w S f x := by + unfold mergedCuts + apply List.mem_filterMap.mpr + refine ⟨j, List.mem_range'_1.mpr ⟨hj1, by omega⟩, ?_⟩ + rw [if_pos hS] + +theorem tag4Size_pos (n : Nat) : 1 ≤ tag4Size n := + Ix.Compile.Verify.TagN.tagNByteWidth_pos 4 n + +theorem tag4Size_mono {a b : Nat} (h : a ≤ b) : tag4Size a ≤ tag4Size b := + Ix.Compile.Verify.TagN.tagNByteWidth_mono 4 h + +theorem tag0Size_mono {a b : Nat} (h : a ≤ b) : tag0Size a ≤ tag0Size b := + Ix.Compile.Verify.TagN.tagNByteWidth_mono 0 h + +/-- One more table entry grows the TagN (`f = 0`) table count by at most +`tag0StepBound n` bytes, for every count below `n`. -/ +theorem tag0Size_succ_le {k n : Nat} (h : k < n) : + tag0Size (k + 1) ≤ tag0Size k + tag0StepBound n := by + unfold tag0Size tag0StepBound Ixon.tagNByteWidth + simp only [Ix.Compile.Verify.TagN.tagNEnd1_eq_0, Ix.Compile.Verify.TagN.tagNEnd2_eq_0, + Ix.Compile.Verify.TagN.tagNEnd3_eq_0, Ix.Compile.Verify.TagN.tagNEnd4_eq_0, + Ix.Compile.Verify.TagN.tagNEnd5_eq_0] + repeat' split + all_goals omega + +/-- An inline telescope writing costs its header plus its merged part: +`1 + M_S(t) ≤ inl_S(t) ≤ tag4Size (spineLen t) + M_S(t)`. -/ +theorem inl_merged_bounds (p : Prep) (w : Nat) (S : Nat → Bool) (f : Nat → Nat) {t : Nat} + (hf : p.family[t]! ≠ .none) : + 1 + mergedOf p w S f t ≤ inlOf p w S f t ∧ + inlOf p w S f t ≤ tag4Size p.spineLen[t]! + mergedOf p w S f t := by + rw [inl_tele w S f hf] + constructor + · rcases List.mem_cons.mp (foldl_min_mem (cutCosts p w S f t) (naturalCost p f t)) with h | h + · rw [h] + have := foldl_min_le (mergedCuts p w S f t) + (prefixSides p f t p.spineLen[t]! + f p.tail[t]!) _ List.mem_cons_self + have := tag4Size_pos p.spineLen[t]! + unfold mergedOf naturalCost at * + omega + · obtain ⟨j, hj1, hj, hS, hc⟩ := mem_cutCosts h + rw [hc] + have := foldl_min_le (mergedCuts p w S f t) + (prefixSides p f t p.spineLen[t]! + f p.tail[t]!) _ + (List.mem_cons_of_mem _ (merged_mem_mergedCuts p w S f hj1 hj hS)) + have := tag4Size_pos j + unfold mergedOf cutCost at * + omega + · rcases List.mem_cons.mp (foldl_min_mem (mergedCuts p w S f t) + (prefixSides p f t p.spineLen[t]! + f p.tail[t]!)) with h | h + · have := foldl_min_le (cutCosts p w S f t) (naturalCost p f t) _ List.mem_cons_self + unfold mergedOf naturalCost at * + omega + · obtain ⟨j, hj1, hj, hS, hc⟩ := mem_mergedCuts h + have := foldl_min_le (cutCosts p w S f t) (naturalCost p f t) _ + (List.mem_cons_of_mem _ (cut_mem_cutCosts p w S f hj1 hj hS)) + have := tag4Size_mono (show j ≤ p.spineLen[t]! by omega) + unfold mergedOf cutCost at * + omega + +/-! ## Monotone validity -/ + +theorem Valid.mono {p : Prep} {S S' : Nat → Bool} (hSS : ∀ y, S y = true → S' y = true) : + ∀ {x : Nat} {T : WTree}, Valid p S x T → Valid p S' x T := by + intro x T h + induction h with + | share hS => exact .share (hSS _ hS) + | node hf hlen _ ih => exact .node hf hlen ih + | teleCut hf hj1 hj hlen _ hS ih => exact .teleCut hf hj1 hj hlen ih (hSS _ hS) + | teleFull hf hlen _ _ ih iht => exact .teleFull hf hlen ih iht + +/-! ## Replacing the occurrences of `t` -/ + +/-- The position of `t` among the spine nodes `1 … j-1` of `x`, if any. -/ +def spineHit (p : Prep) (x j t : Nat) : Option Nat := + (List.range' 1 (j - 1)).find? fun k => spineAt p x k == t + +mutual +/-- Replace the occurrences of `t`: a whole writing of `t` (if `rh`) and the +rest of a telescope from `t` on (if `rc`) become `Share(t)`. -/ +def WTree.subst (p : Prep) (t : Nat) (rh rc : Bool) : WTree → WTree + | .share x => .share x + | .node x kids => + if x = t then (if rh then .share t else .node x kids) + else .node x (WTree.substs p t rh rc kids) + | .tele x j sides tail => + if x = t then (if rh then .share t else .tele x j sides tail) + else match spineHit p x j t with + | some k => + if rc then .tele x k ((WTree.substs p t rh rc sides).take k) (.share t) + else .tele x j (WTree.substs p t rh rc sides) (WTree.subst p t rh rc tail) + | none => .tele x j (WTree.substs p t rh rc sides) (WTree.subst p t rh rc tail) +def WTree.substs (p : Prep) (t : Nat) (rh rc : Bool) : List WTree → List WTree + | [] => [] + | k :: ks => WTree.subst p t rh rc k :: WTree.substs p t rh rc ks +end + +mutual +/-- Head occurrences of `t`: writings of `t` (a writing of `t` is one). -/ +def WTree.occH (t : Nat) : WTree → Nat + | .share _ => 0 + | .node x kids => if x = t then 1 else WTree.occHs t kids + | .tele x _ sides tail => if x = t then 1 else WTree.occHs t sides + WTree.occH t tail +def WTree.occHs (t : Nat) : List WTree → Nat + | [] => 0 + | k :: ks => WTree.occH t k + WTree.occHs t ks +end + +mutual +/-- Continuation occurrences of `t`: telescopes running through `t`. -/ +def WTree.occC (p : Prep) (t : Nat) : WTree → Nat + | .share _ => 0 + | .node x kids => if x = t then 0 else WTree.occCs p t kids + | .tele x j sides tail => + if x = t then 0 + else (if (spineHit p x j t).isSome then 1 else 0) + WTree.occCs p t sides + WTree.occC p t tail +def WTree.occCs (p : Prep) (t : Nat) : List WTree → Nat + | [] => 0 + | k :: ks => WTree.occC p t k + WTree.occCs p t ks +end + +theorem substs_eq (p : Prep) (t : Nat) (rh rc : Bool) (l : List WTree) : + WTree.substs p t rh rc l = l.map (WTree.subst p t rh rc) := by + induction l with + | nil => rfl + | cons k ks ih => simp [WTree.substs, ih] + +theorem occHs_eq (t : Nat) (l : List WTree) : WTree.occHs t l = (l.map (WTree.occH t)).sum := by + induction l with + | nil => rfl + | cons k ks ih => simp [WTree.occHs, ih] + +theorem occCs_eq (p : Prep) (t : Nat) (l : List WTree) : + WTree.occCs p t l = (l.map (WTree.occC p t)).sum := by + induction l with + | nil => rfl + | cons k ks ih => simp [WTree.occCs, ih] + +theorem spineHit_spec {p : Prep} {x j t k : Nat} (h : spineHit p x j t = some k) : + 1 ≤ k ∧ k < j ∧ spineAt p x k = t := by + unfold spineHit at h + have hm := List.mem_of_find?_eq_some h + have hp := List.find?_some h + rw [List.mem_range'_1] at hm + simp only [beq_iff_eq] at hp + exact ⟨hm.1, by omega, hp⟩ + +theorem spineHit_none {p : Prep} {x j t : Nat} (h : ∀ k, 1 ≤ k → k < j → spineAt p x k ≠ t) : + spineHit p x j t = none := by + unfold spineHit + rw [List.find?_eq_none] + intro k hk + rw [List.mem_range'_1] at hk + simpa using h k hk.1 (by omega) + +theorem sum_map_eq_zero {α : Type} {f : α → Nat} {l : List α} (h : ∀ a ∈ l, f a = 0) : + (l.map f).sum = 0 := by + induction l with + | nil => rfl + | cons x xs ih => + simp only [List.map_cons, List.sum_cons, h x List.mem_cons_self, + ih (fun a ha => h a (List.mem_cons_of_mem _ ha))] + +theorem map_eq_self {α : Type} {f : α → α} {l : List α} (h : ∀ a ∈ l, f a = a) : + l.map f = l := by + induction l with + | nil => rfl + | cons x xs ih => + simp only [List.map_cons, h x List.mem_cons_self, + ih (fun a ha => h a (List.mem_cons_of_mem _ ha))] + +theorem forall_mem_of_getElem {α : Type} {P : α → Prop} {l : List α} + (h : ∀ (i : Nat) (hi : i < l.length), P l[i]) : ∀ a ∈ l, P a := by + intro a ha + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp ha + exact h i hi + +theorem PrepWF.spineAt_le {p : Prep} (hp : PrepWF p) {x k : Nat} (hx : x < p.dag.size) + (hf : p.family[x]! ≠ .none) (hk : k < p.spineLen[x]!) : spineAt p x k ≤ x := + ((hp.spine x hx hf).2.1 k hk).1 + +/-- Writings of terms below `t` contain no occurrence of `t`. -/ +theorem PrepWF.below_t {p : Prep} (hp : PrepWF p) {S : Nat → Bool} {t : Nat} (rh rc : Bool) : + ∀ {x : Nat} {T : WTree}, Valid p S x T → x < t → x < p.dag.size → + T.occH t = 0 ∧ T.occC p t = 0 ∧ T.subst p t rh rc = T := by + intro x T h + induction h with + | share _ => intro _ _; exact ⟨rfl, rfl, rfl⟩ + | @node x kids hf hlen _ ih => + intro hxt hx + have hne : x ≠ t := by omega + have hk := forall_mem_of_getElem (l := kids) (P := fun (a : WTree) => a.occH t = 0 ∧ a.occC p t = 0 ∧ + a.subst p t rh rc = a) fun i hi => by + have hc := hp.dag.childAt_lt hx (k := i) (by omega) + exact ih i hi (by omega) (by omega) + simp only [WTree.occH, WTree.occC, WTree.subst, hne, if_false, occHs_eq, occCs_eq, + substs_eq] + exact ⟨sum_map_eq_zero fun a ha => (hk a ha).1, sum_map_eq_zero fun a ha => (hk a ha).2.1, + by rw [map_eq_self fun a ha => (hk a ha).2.2]⟩ + | @teleCut x j sides hf hj1 hj hlen _ hS ih => + intro hxt hx + have hne : x ≠ t := by omega + have hk := forall_mem_of_getElem (l := sides) (P := fun (a : WTree) => a.occH t = 0 ∧ a.occC p t = 0 ∧ + a.subst p t rh rc = a) fun i hi => by + have hc := hp.sideAt_lt hx hf (k := i) (by omega) + exact ih i hi (by omega) (by omega) + have hhit : spineHit p x j t = none := spineHit_none fun k h1 h2 => by + have := hp.spineAt_le hx hf (k := k) (by omega); omega + simp only [WTree.occH, WTree.occC, WTree.subst, hne, if_false, occHs_eq, occCs_eq, + substs_eq, hhit, Option.isSome_none, Bool.false_eq_true] + exact ⟨by rw [sum_map_eq_zero fun a ha => (hk a ha).1], + by rw [sum_map_eq_zero fun a ha => (hk a ha).2.1], + by rw [map_eq_self fun a ha => (hk a ha).2.2]⟩ + | @teleFull x sides tail hf hlen _ _ ih iht => + intro hxt hx + have hne : x ≠ t := by omega + obtain ⟨_, _, _, htl, _⟩ := hp.spine x hx hf + have hk := forall_mem_of_getElem (l := sides) (P := fun (a : WTree) => a.occH t = 0 ∧ a.occC p t = 0 ∧ + a.subst p t rh rc = a) fun i hi => by + have hc := hp.sideAt_lt hx hf (k := i) (by omega) + exact ih i hi (by omega) (by omega) + have hhit : spineHit p x p.spineLen[x]! t = none := spineHit_none fun k h1 h2 => by + have := hp.spineAt_le hx hf (k := k) (by omega); omega + obtain ⟨ht1, ht2, ht3⟩ := iht (by omega) (by omega) + simp only [WTree.occH, WTree.occC, WTree.subst, hne, if_false, occHs_eq, occCs_eq, + substs_eq, hhit, Option.isSome_none, Bool.false_eq_true] + exact ⟨by rw [sum_map_eq_zero fun a ha => (hk a ha).1, ht1], + by rw [sum_map_eq_zero fun a ha => (hk a ha).2.1, ht2], + by rw [map_eq_self fun a ha => (hk a ha).2.2, ht3]⟩ + +/-! ## The continuation bound -/ + +/-- Facts about the spine from its `k`-th node on. -/ +theorem PrepWF.spine_shift {p : Prep} (hp : PrepWF p) {x k : Nat} (hx : x < p.dag.size) + (hf : p.family[x]! ≠ .none) (hk : k < p.spineLen[x]!) : + spineAt p x k < p.dag.size ∧ p.family[spineAt p x k]! = p.family[x]! ∧ + p.spineLen[spineAt p x k]! = p.spineLen[x]! - k ∧ + p.tail[spineAt p x k]! = p.tail[x]! ∧ + (∀ i, spineAt p (spineAt p x k) i = spineAt p x (k + i)) ∧ + (∀ i, sideAt p (spineAt p x k) i = sideAt p x (k + i)) ∧ + (p.dag.node (spineAt p x k)).sideExtra = (p.dag.node x).sideExtra := by + obtain ⟨_, hsp, _, _, _⟩ := hp.spine x hx hf + obtain ⟨hle, hfam, hlen, htl⟩ := hsp k hk + refine ⟨by omega, hfam, hlen, htl, fun i => (spineAt_add p k i x).symm, fun i => ?_, + hp.sideExtra_spine hx hf hk⟩ + unfold sideAt + rw [spineAt_add] + +theorem costs_drop_getElem (p : Prep) (w : Nat) (l : List WTree) (k : Nat) : + ((l.drop k).map (WTree.cost p w)).sum = + ((List.range (l.length - k)).map fun i => (l[k + i]?.getD default).cost p w).sum := by + congr 1 + apply List.ext_getElem (by simp) + intro i h1 h2 + simp only [List.getElem_map, List.getElem_drop, List.getElem_range] + rw [List.getElem?_eq_getElem (by simp at h1; omega)] + rfl + +/-- The part of a telescope writing from its `k`-th spine node on is at +least `M_S` of that node. -/ +theorem PrepWF.merged_le_rest {p : Prep} (hp : PrepWF p) (w : Nat) (S : Nat → Bool) + {x j : Nat} {sides : List WTree} {tail : WTree} (hx : x < p.dag.size) + (hf : p.family[x]! ≠ .none) (hlen : sides.length = j) + (hsides : ∀ (k : Nat) (h : k < sides.length), Valid p S (sideAt p x k) sides[k]) + (htail : (j < p.spineLen[x]! ∧ S (spineAt p x j) = true ∧ tail = .share (spineAt p x j)) ∨ + (j = p.spineLen[x]! ∧ Valid p S p.tail[x]! tail)) + {k : Nat} (hkj : k < j) (hjl : j ≤ p.spineLen[x]!) : + mergedOf p w S (uCost p w S) (spineAt p x k) ≤ + (j - k) * (p.dag.node x).sideExtra + ((sides.drop k).map (WTree.cost p w)).sum + + tail.cost p w := by + obtain ⟨hts, htf, htlen, httail, hspat, hsideat, hext⟩ := hp.spine_shift hx hf (k := k) (by omega) + have htf' : p.family[spineAt p x k]! ≠ .none := by rw [htf]; exact hf + have hpre : prefixSides p (uCost p w S) (spineAt p x k) (j - k) ≤ + (j - k) * (p.dag.node x).sideExtra + ((sides.drop k).map (WTree.cost p w)).sum := by + rw [hp.prefixSides_eq _ hts htf' (by omega), hext, costs_drop_getElem, hlen] + have : ∀ i ∈ List.range (j - k), uCost p w S (sideAt p (spineAt p x k) i) ≤ + (sides[k + i]?.getD default).cost p w := by + intro i hi + rw [List.mem_range] at hi + rw [hsideat, List.getElem?_eq_getElem (by omega)] + exact (hp.valid_cost w S (hsides (k + i) (by omega)) + (by have := hp.sideAt_lt hx hf (k := k + i) (by omega); omega)).1 + have := sum_le_sum_of_le _ this + omega + unfold mergedOf + rcases htail with ⟨hjl', hS, rfl⟩ | ⟨hjeq, hvt⟩ + · have hmem := merged_mem_mergedCuts p w S (uCost p w S) (x := spineAt p x k) (j := j - k) + (by omega) (by omega) (by rw [hspat, show k + (j - k) = j by omega]; exact hS) + have := foldl_min_le _ (prefixSides p (uCost p w S) (spineAt p x k) + p.spineLen[spineAt p x k]! + uCost p w S p.tail[spineAt p x k]!) _ + (List.mem_cons_of_mem _ hmem) + simp only [WTree.cost] + omega + · have := foldl_min_le (mergedCuts p w S (uCost p w S) (spineAt p x k)) + (prefixSides p (uCost p w S) (spineAt p x k) p.spineLen[spineAt p x k]! + + uCost p w S p.tail[spineAt p x k]!) _ List.mem_cons_self + obtain ⟨_, _, _, htl, _⟩ := hp.spine x hx hf + have htc := (hp.valid_cost w S hvt (by omega)).1 + rw [htlen, httail, ← hjeq] at this ⊢ + omega + +/-! ## The substitution lemma -/ + +theorem sum_ineq {α : Type} (f g h c : α → Nat) (A B : Nat) : + ∀ (l : List α), (∀ a ∈ l, f a + g a * A + h a * B ≤ c a) → + (l.map f).sum + (l.map g).sum * A + (l.map h).sum * B ≤ (l.map c).sum := by + intro l + induction l with + | nil => intro _; simp + | cons x xs ih => + intro hl + have h1 := hl x List.mem_cons_self + have h2 := ih (fun a ha => hl a (List.mem_cons_of_mem _ ha)) + simp only [List.map_cons, List.sum_cons, Nat.add_mul] + omega + +theorem sum_take_drop {α : Type} (f : α → Nat) (l : List α) (k : Nat) : + (l.map f).sum = ((l.take k).map f).sum + ((l.drop k).map f).sum := by + have := congrArg (fun l => (l.map f).sum) (List.take_append_drop k l) + simp only [List.map_append, List.sum_append] at this + exact this.symm + +/-- The stored set with `t` added. -/ +def addT (S : Nat → Bool) (t : Nat) : Nat → Bool := fun y => S y || y == t + +theorem addT_le (S : Nat → Bool) (t : Nat) : ∀ y, S y = true → addT S t y = true := by + intro y h; simp [addT, h] + +theorem addT_self (S : Nat → Bool) (t : Nat) : addT S t t = true := by simp [addT] + +/-- **Substitution.** Replacing the occurrences of `t ∉ S` in a writing gives +a writing for `S ∪ {t}`, shorter by `I_S(t) - w` per replaced head +occurrence and by `M_S(t) - w` per replaced continuation occurrence. -/ +theorem PrepWF.subst_spec {p : Prep} (hp : PrepWF p) (w : Nat) {S : Nat → Bool} {t : Nat} + (hSt : S t = false) (htn : t < p.dag.size) (rh rc : Bool) + (hrh : rh = true → w ≤ uInl p w S t) + (hrc : rc = true → w ≤ mergedOf p w S (uCost p w S) t) : + ∀ {x : Nat} {T : WTree}, Valid p S x T → x < p.dag.size → + Valid p (addT S t) x (T.subst p t rh rc) ∧ + (T.subst p t rh rc).cost p w + + T.occH t * (if rh then uInl p w S t - w else 0) + + T.occC p t * (if rc then mergedOf p w S (uCost p w S) t - w else 0) ≤ + T.cost p w := by + -- writings of `t` itself + have hself : ∀ {T : WTree}, Valid p S t T → T.isShare = false → + T.occC p t = 0 → T.occH t = 1 → + Valid p (addT S t) t (if rh then .share t else T) ∧ + (if rh then .share t else T).cost p w + T.occH t * (if rh then uInl p w S t - w else 0) + + T.occC p t * (if rc then mergedOf p w S (uCost p w S) t - w else 0) ≤ T.cost p w := by + intro T hT hTs hC hH + rw [hC, hH] + have hI := (hp.valid_cost w S hT htn).2 hTs + cases rh with + | true => + refine ⟨.share (addT_self S t), ?_⟩ + have := hrh rfl + simp only [if_true, WTree.cost] + omega + | false => + exact ⟨hT.mono (addT_le S t), by simp⟩ + intro x T h + induction h with + | @share x hS => + intro _ + exact ⟨.share (addT_le S t _ hS), by simp [WTree.subst, WTree.occH, WTree.occC]⟩ + | @node x kids hf hlen hkids ih => + intro hx + by_cases hxt : x = t + · subst hxt + have := hself (Valid.node hf hlen hkids) rfl (by simp [WTree.occC]) (by simp [WTree.occH]) + simpa [WTree.subst] using this + · have hk : ∀ (i : Nat) (hi : i < kids.length), + Valid p (addT S t) ((p.dag.node x).child i) (kids[i].subst p t rh rc) ∧ + (kids[i].subst p t rh rc).cost p w + + kids[i].occH t * (if rh then uInl p w S t - w else 0) + + kids[i].occC p t * (if rc then mergedOf p w S (uCost p w S) t - w else 0) ≤ + kids[i].cost p w := fun i hi => + ih i hi (by have := hp.dag.childAt_lt hx (k := i) (by omega); omega) + simp only [WTree.subst, hxt, if_false, WTree.occH, WTree.occC, WTree.cost, substs_eq, + occHs_eq, occCs_eq, WTree.costs_eq] + refine ⟨.node hf (by simp [hlen]) fun i hi => by + simp only [List.getElem_map] + exact (hk i (by simpa using hi)).1, ?_⟩ + have := sum_ineq (fun a => (a.subst p t rh rc).cost p w) (WTree.occH t) (WTree.occC p t) + (WTree.cost p w) _ _ kids (forall_mem_of_getElem (l := kids) + (P := fun a => (a.subst p t rh rc).cost p w + a.occH t * _ + a.occC p t * _ ≤ a.cost p w) + fun i hi => (hk i hi).2) + simp only [List.map_map, Function.comp_def] + omega + | @teleCut x j sides hf hj1 hj hlen hsides hS ih => + intro hx + by_cases hxt : x = t + · subst hxt + have := hself (Valid.teleCut hf hj1 hj hlen hsides hS) rfl (by simp [WTree.occC]) + (by simp [WTree.occH]) + simpa [WTree.subst] using this + · have hk : ∀ (i : Nat) (hi : i < sides.length), + Valid p (addT S t) (sideAt p x i) (sides[i].subst p t rh rc) ∧ + (sides[i].subst p t rh rc).cost p w + + sides[i].occH t * (if rh then uInl p w S t - w else 0) + + sides[i].occC p t * (if rc then mergedOf p w S (uCost p w S) t - w else 0) ≤ + sides[i].cost p w := fun i hi => + ih i hi (by have := hp.sideAt_lt hx hf (k := i) (by omega); omega) + have hvalid : ∀ (i : Nat) (hi : i < (sides.map (WTree.subst p t rh rc)).length), + Valid p (addT S t) (sideAt p x i) (sides.map (WTree.subst p t rh rc))[i] := by + intro i hi + simp only [List.getElem_map] + exact (hk i (by simpa using hi)).1 + have hsum := sum_ineq (fun a => (a.subst p t rh rc).cost p w) (WTree.occH t) + (WTree.occC p t) (WTree.cost p w) (if rh then uInl p w S t - w else 0) + (if rc then mergedOf p w S (uCost p w S) t - w else 0) sides + (forall_mem_of_getElem (l := sides) + (P := fun a => (a.subst p t rh rc).cost p w + a.occH t * _ + a.occC p t * _ ≤ + a.cost p w) fun i hi => (hk i hi).2) + cases hhit : spineHit p x j t with + | none => + simp only [WTree.subst, hxt, if_false, hhit, WTree.occH, WTree.occC, WTree.cost, + substs_eq, occHs_eq, occCs_eq, WTree.costs_eq, Option.isSome_none, Bool.false_eq_true, + if_false, Nat.add_zero, Nat.zero_add] + refine ⟨.teleCut hf hj1 hj (by simp [hlen]) hvalid (addT_le S t _ hS), ?_⟩ + simp only [List.map_map, Function.comp_def] + omega + | some k => + obtain ⟨hk1, hkj, hkt⟩ := spineHit_spec hhit + cases rc with + | false => + simp only [WTree.subst, hxt, if_false, hhit, WTree.occH, WTree.occC, WTree.cost, + substs_eq, occHs_eq, occCs_eq, WTree.costs_eq, Bool.false_eq_true, + Nat.add_zero] + refine ⟨.teleCut hf hj1 hj (by simp [hlen]) hvalid (addT_le S t _ hS), ?_⟩ + simp only [List.map_map, Function.comp_def] at hsum ⊢ + simp only [Bool.false_eq_true, if_false, Nat.mul_zero] at hsum ⊢ + omega + | true => + simp only [WTree.subst, hxt, if_false, hhit, if_true, WTree.occH, WTree.occC, WTree.cost, + substs_eq, occHs_eq, occCs_eq, WTree.costs_eq, Option.isSome_some, + Nat.add_zero] + have hM := hp.merged_le_rest w S hx hf hlen hsides + (Or.inl ⟨hj, hS, rfl⟩) (k := k) hkj (by omega) + rw [hkt] at hM + have hMw := hrc rfl + -- the sides from `k` on contain no occurrence of `t` + have hdrop : ∀ a ∈ sides.drop k, a.occH t = 0 ∧ a.occC p t = 0 := by + intro a ha + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp ha + simp only [List.getElem_drop] + obtain ⟨_, _, hlen', _, _, hsideat, _⟩ := hp.spine_shift hx hf (k := k) (by omega) + have hsl := hp.sideAt_lt hx hf (k := k + i) (by simp at hi; omega) + have hst : sideAt p x (k + i) < t := by + rw [← hkt, ← hsideat] + exact hp.sideAt_lt (by rw [hkt]; omega) (by + obtain ⟨_, hfam, _⟩ := hp.spine_shift hx hf (k := k) (by omega) + rw [hfam]; exact hf) + (by rw [hlen']; simp at hi; omega) + have := hp.below_t (S := S) (t := t) rh true + (hsides (k + i) (by simp at hi; omega)) hst (by omega) + exact ⟨this.1, this.2.1⟩ + have hH : (sides.map (WTree.occH t)).sum = ((sides.take k).map (WTree.occH t)).sum := by + rw [sum_take_drop _ sides k, sum_map_eq_zero fun a ha => (hdrop a ha).1] + simp + have hC : (sides.map (WTree.occC p t)).sum = + ((sides.take k).map (WTree.occC p t)).sum := by + rw [sum_take_drop _ sides k, sum_map_eq_zero fun a ha => (hdrop a ha).2] + simp + have hcost : (sides.map (WTree.cost p w)).sum = ((sides.take k).map (WTree.cost p w)).sum + + ((sides.drop k).map (WTree.cost p w)).sum := sum_take_drop _ sides k + have hsumk := sum_ineq (fun a => (a.subst p t rh true).cost p w) (WTree.occH t) + (WTree.occC p t) (WTree.cost p w) (if rh then uInl p w S t - w else 0) + (mergedOf p w S (uCost p w S) t - w) (sides.take k) (fun a ha => by + have := hsum + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp ha + simp only [List.getElem_take] + have := (hk i (by simp at hi; omega)).2 + simpa using this) + have htag := tag4Size_mono (show k ≤ j by omega) + refine ⟨?_, ?_⟩ + · rw [show WTree.share t = WTree.share (spineAt p x k) by rw [hkt]] + refine .teleCut hf hk1 (by omega) (by simp [hlen]; omega) (fun i hi => ?_) + (by rw [hkt]; exact addT_self S t) + simp only [List.getElem_take, List.getElem_map] + exact (hk i (by simp at hi; omega)).1 + · rw [hH, hC, hcost, ← List.map_take] + simp only [List.map_map, Function.comp_def, WTree.cost] at hsumk hM ⊢ + have hjk : k * (p.dag.node x).sideExtra + (j - k) * (p.dag.node x).sideExtra = + j * (p.dag.node x).sideExtra := by + rw [← Nat.add_mul]; congr 1; omega + rw [Nat.add_mul, Nat.one_mul] + omega + | @teleFull x sides tail hf hlen hsides htail ih iht => + intro hx + obtain ⟨_, _, _, htl, _⟩ := hp.spine x hx hf + by_cases hxt : x = t + · subst hxt + have := hself (Valid.teleFull hf hlen hsides htail) rfl (by simp [WTree.occC]) + (by simp [WTree.occH]) + simpa [WTree.subst] using this + · have hk : ∀ (i : Nat) (hi : i < sides.length), + Valid p (addT S t) (sideAt p x i) (sides[i].subst p t rh rc) ∧ + (sides[i].subst p t rh rc).cost p w + + sides[i].occH t * (if rh then uInl p w S t - w else 0) + + sides[i].occC p t * (if rc then mergedOf p w S (uCost p w S) t - w else 0) ≤ + sides[i].cost p w := fun i hi => + ih i hi (by have := hp.sideAt_lt hx hf (k := i) (by omega); omega) + have hvalid : ∀ (i : Nat) (hi : i < (sides.map (WTree.subst p t rh rc)).length), + Valid p (addT S t) (sideAt p x i) (sides.map (WTree.subst p t rh rc))[i] := by + intro i hi + simp only [List.getElem_map] + exact (hk i (by simpa using hi)).1 + have hsum := sum_ineq (fun a => (a.subst p t rh rc).cost p w) (WTree.occH t) + (WTree.occC p t) (WTree.cost p w) (if rh then uInl p w S t - w else 0) + (if rc then mergedOf p w S (uCost p w S) t - w else 0) sides + (forall_mem_of_getElem (l := sides) + (P := fun a => (a.subst p t rh rc).cost p w + a.occH t * _ + a.occC p t * _ ≤ + a.cost p w) fun i hi => (hk i hi).2) + obtain ⟨htv, htc⟩ := iht (by omega) + cases hhit : spineHit p x p.spineLen[x]! t with + | none => + simp only [WTree.subst, hxt, if_false, hhit, WTree.occH, WTree.occC, WTree.cost, + substs_eq, occHs_eq, occCs_eq, WTree.costs_eq, Option.isSome_none, Bool.false_eq_true, + if_false, Nat.zero_add] + refine ⟨.teleFull hf (by simp [hlen]) hvalid htv, ?_⟩ + simp only [List.map_map, Function.comp_def, Nat.add_mul] at hsum htc ⊢ + omega + | some k => + obtain ⟨hk1, hkj, hkt⟩ := spineHit_spec hhit + cases rc with + | false => + simp only [WTree.subst, hxt, if_false, hhit, WTree.occH, WTree.occC, WTree.cost, + substs_eq, occHs_eq, occCs_eq, WTree.costs_eq, Bool.false_eq_true] + refine ⟨.teleFull hf (by simp [hlen]) hvalid htv, ?_⟩ + simp only [List.map_map, Function.comp_def, Nat.add_mul] at hsum htc ⊢ + simp only [Bool.false_eq_true, if_false, Nat.mul_zero, Nat.add_zero] at hsum htc ⊢ + omega + | true => + simp only [WTree.subst, hxt, if_false, hhit, if_true, WTree.occH, WTree.occC, WTree.cost, + substs_eq, occHs_eq, occCs_eq, WTree.costs_eq, Option.isSome_some] + obtain ⟨hts, htf, hlen', httail, _, hsideat, _⟩ := + hp.spine_shift hx hf (k := k) (by omega) + + have hM := hp.merged_le_rest w S hx hf hlen hsides + (Or.inr ⟨rfl, htail⟩) (k := k) hkj (Nat.le_refl _) + rw [hkt] at hM + have hMw := hrc rfl + have htf' : p.family[t]! ≠ .none := by rw [← hkt, htf]; exact hf + have httl : p.tail[x]! < t := by + rw [← httail, hkt] + exact (hp.spine t (by omega) htf').2.2.2.1 + obtain ⟨hto1, hto2, _⟩ := hp.below_t (S := S) (t := t) rh true htail httl (by omega) + have hdrop : ∀ a ∈ sides.drop k, a.occH t = 0 ∧ a.occC p t = 0 := by + intro a ha + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp ha + simp only [List.getElem_drop] + have hst : sideAt p x (k + i) < t := by + rw [← hkt, ← hsideat] + exact hp.sideAt_lt (by rw [hkt]; omega) (by rw [hkt]; exact htf') + (by rw [hlen']; simp at hi; omega) + have := hp.below_t (S := S) (t := t) rh true + (hsides (k + i) (by simp at hi; omega)) hst (by omega) + exact ⟨this.1, this.2.1⟩ + have hH : (sides.map (WTree.occH t)).sum = ((sides.take k).map (WTree.occH t)).sum := by + rw [sum_take_drop _ sides k, sum_map_eq_zero fun a ha => (hdrop a ha).1] + simp + have hC : (sides.map (WTree.occC p t)).sum = + ((sides.take k).map (WTree.occC p t)).sum := by + rw [sum_take_drop _ sides k, sum_map_eq_zero fun a ha => (hdrop a ha).2] + simp + have hcost : (sides.map (WTree.cost p w)).sum = ((sides.take k).map (WTree.cost p w)).sum + + ((sides.drop k).map (WTree.cost p w)).sum := sum_take_drop _ sides k + have hsumk := sum_ineq (fun a => (a.subst p t rh true).cost p w) (WTree.occH t) + (WTree.occC p t) (WTree.cost p w) (if rh then uInl p w S t - w else 0) + (mergedOf p w S (uCost p w S) t - w) (sides.take k) (fun a ha => by + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp ha + simp only [List.getElem_take] + have := (hk i (by simp at hi; omega)).2 + simpa using this) + have htag := tag4Size_mono (show k ≤ p.spineLen[x]! by omega) + refine ⟨?_, ?_⟩ + · rw [show WTree.share t = WTree.share (spineAt p x k) by rw [hkt]] + refine .teleCut hf hk1 (by omega) (by simp [hlen]; omega) (fun i hi => ?_) + (by rw [hkt]; exact addT_self S t) + simp only [List.getElem_take, List.getElem_map] + exact (hk i (by simp at hi; omega)).1 + · rw [hH, hC, hcost, ← List.map_take, hto1, hto2] + simp only [List.map_map, Function.comp_def] at hsumk hM ⊢ + have hjk : k * (p.dag.node x).sideExtra + + (p.spineLen[x]! - k) * (p.dag.node x).sideExtra = + p.spineLen[x]! * (p.dag.node x).sideExtra := by + rw [← Nat.add_mul]; congr 1; omega + simp only [Nat.add_zero, Nat.add_mul, Nat.one_mul] + omega + +/-! ## Edges into `t` -/ + +/-- The number of edges from `y` to `t` that are (`cont = true`) or are not +(`cont = false`) telescope continuations, as `graphFacts` counts them. -/ +def edgeMult (p : Prep) (y t : Nat) (cont : Bool) : Nat := + ((List.range (p.dag.node y).head.arity).filter fun i => + (p.dag.node y).child i == t && + continuationEdge (p.dag.node y) i (p.dag.node t) == cont).length + +theorem PrepWF.edgeMult_node {p : Prep} (hp : PrepWF p) {y : Nat} (hy : y < p.dag.size) + (hf : p.family[y]! = .none) (t : Nat) : + edgeMult p y t true = 0 ∧ + edgeMult p y t false = ((List.range (p.dag.node y).head.arity).filter fun i => + (p.dag.node y).child i == t).length := by + have hfy : (p.dag.node y).head.family = .none := by rw [← hp.family y hy]; exact hf + have hc : ∀ i, continuationEdge (p.dag.node y) i (p.dag.node t) = false := by + intro i + unfold continuationEdge + cases hh : (p.dag.node y).head <;> simp_all [Head.family] + unfold edgeMult + simp only [hc] + constructor + · simp + · congr 1 + apply List.filter_congr + intro i _ + simp + +theorem PrepWF.edgeMult_tele {p : Prep} (hp : PrepWF p) {y t : Nat} (hy : y < p.dag.size) + (ht : t < p.dag.size) (hf : p.family[y]! ≠ .none) : + edgeMult p y t true = + (if snext p y = t ∧ p.family[t]! = p.family[y]! then 1 else 0) ∧ + edgeMult p y t false = (if (p.dag.node y).sideChild = t then 1 else 0) + + (if snext p y = t ∧ p.family[t]! ≠ p.family[y]! then 1 else 0) := by + have hfy : (p.dag.node y).head.family ≠ .none := by rw [← hp.family y hy]; exact hf + rw [hp.family y hy, hp.family t ht] + unfold edgeMult snext Node.spineNext Node.sideChild continuationEdge + cases hh : (p.dag.node y).head <;> simp only [hh, Head.family, ne_eq, not_true_eq_false] at hfy + all_goals cases ht' : (p.dag.node t).head <;> + simp [Head.arity, Head.family, List.range_succ, List.filter_cons] + all_goals (repeat' split) <;> simp_all + +theorem edgeMult_zero_of_le {p : Prep} (hp : PrepWF p) {y t : Nat} (hyt : y ≤ t) (c : Bool) : + edgeMult p y t c = 0 := by + unfold edgeMult + by_cases hy : y < p.dag.size + · rw [List.length_eq_zero_iff, List.filter_eq_nil_iff] + intro i hi + rw [List.mem_range] at hi + have := hp.dag.childAt_lt hy hi + simp only [Bool.and_eq_true, beq_iff_eq, not_and] + intro h; omega + · have : p.dag.node y = default := by + simp [Dag.node, Dag.size] at hy ⊢; simp [hy] + rw [this] + rfl + +/-- The spine nodes of a telescope strictly decrease. -/ +theorem PrepWF.spineAt_strict {p : Prep} (hp : PrepWF p) {x : Nat} (hx : x < p.dag.size) + (hf : p.family[x]! ≠ .none) : + ∀ {a b : Nat}, a < b → b ≤ p.spineLen[x]! → spineAt p x b < spineAt p x a := by + intro a b hab hb + obtain ⟨hts, htf, htlen, httail, hspat, _, _⟩ := hp.spine_shift hx hf (k := a) (by omega) + have htf' : p.family[spineAt p x a]! ≠ .none := by rw [htf]; exact hf + by_cases hbl : b = p.spineLen[x]! + · subst hbl + rw [(hp.spine x hx hf).2.2.1, ← httail] + exact (hp.spine (spineAt p x a) hts htf').2.2.2.1 + · have := hp.spineAt_lt (t := spineAt p x a) (k := b - a) hts htf' (by omega) + (by rw [htlen]; omega) + rw [hspat, show a + (b - a) = b by omega] at this + exact this + +theorem snext_spineAt (p : Prep) (t k : Nat) : snext p (spineAt p t k) = spineAt p t (k + 1) := by + rw [spineAt_add p k 1] + rfl + +theorem sum_range_succ' (f : Nat → Nat) (j : Nat) : + ((List.range (j + 1)).map f).sum = ((List.range j).map f).sum + f j := by + rw [List.range_succ, List.map_append, List.sum_append] + simp + +/-- A sum of indicators of a property holding at most once. -/ +theorem sum_indicator_unique (P : Nat → Prop) [DecidablePred P] (j : Nat) + (huniq : ∀ a b, a < j → b < j → P a → P b → a = b) : + ((List.range j).map fun k => if P k then 1 else 0).sum = + if ∃ k, k < j ∧ P k then 1 else 0 := by + induction j with + | zero => simp + | succ j ih => + rw [sum_range_succ', ih (fun a b ha hb => huniq a b (by omega) (by omega))] + by_cases hj : P j + · have hnone : ¬ ∃ k, k < j ∧ P k := by + rintro ⟨k, hk, hPk⟩ + have := huniq k j (by omega) (by omega) hPk hj + omega + rw [if_neg hnone, if_pos hj, if_pos ⟨j, by omega, hj⟩] + · rw [if_neg hj, Nat.add_zero] + by_cases hex : ∃ k, k < j ∧ P k + · obtain ⟨k, hk, hPk⟩ := hex + rw [if_pos ⟨k, hk, hPk⟩, if_pos ⟨k, by omega, hPk⟩] + · rw [if_neg hex, if_neg] + rintro ⟨k, hk, hPk⟩ + by_cases hkj : k = j + · subst hkj; exact hj hPk + · exact hex ⟨k, by omega, hPk⟩ + +theorem sum_zero_of_forall {f : Nat → Nat} {j : Nat} (h : ∀ k, k < j → f k = 0) : + ((List.range j).map f).sum = 0 := + sum_map_eq_zero fun k hk => h k (List.mem_range.mp hk) + +theorem spineHit_isSome_iff {p : Prep} {x j t : Nat} : + (spineHit p x j t).isSome = true ↔ ∃ k, 1 ≤ k ∧ k < j ∧ spineAt p x k = t := by + constructor + · intro h + obtain ⟨k, hk⟩ := Option.isSome_iff_exists.mp h + obtain ⟨h1, h2, h3⟩ := spineHit_spec hk + exact ⟨k, h1, h2, h3⟩ + · rintro ⟨k, h1, h2, h3⟩ + cases hs : spineHit p x j t with + | some _ => rfl + | none => + unfold spineHit at hs + rw [List.find?_eq_none] at hs + have := hs k (List.mem_range'_1.mpr ⟨h1, by omega⟩) + simp [h3] at this + +/-- The non-continuation spine edges of a telescope prefix: only the last +node of a full telescope has one (into the natural tail). -/ +theorem PrepWF.spine_head_edges {p : Prep} (hp : PrepWF p) {x j t : Nat} (hx : x < p.dag.size) + (hf : p.family[x]! ≠ .none) (hj : j ≤ p.spineLen[x]!) : + ((List.range j).map fun k => + if snext p (spineAt p x k) = t ∧ p.family[t]! ≠ p.family[spineAt p x k]! then 1 else 0).sum = + if j = p.spineLen[x]! ∧ p.tail[x]! = t then 1 else 0 := by + obtain ⟨hl1, hk, hend, _, htf⟩ := hp.spine x hx hf + have hzero : ∀ k, k + 1 < p.spineLen[x]! → + (if snext p (spineAt p x k) = t ∧ p.family[t]! ≠ p.family[spineAt p x k]! then 1 else 0) = 0 := by + intro k hk1 + rw [if_neg] + rintro ⟨hn, hne⟩ + rw [snext_spineAt] at hn + apply hne + rw [← hn, (hk (k + 1) hk1).2.1, (hk k (by omega)).2.1] + by_cases hjl : j = p.spineLen[x]! + · subst hjl + obtain ⟨m, hm⟩ : ∃ m, p.spineLen[x]! = m + 1 := ⟨p.spineLen[x]! - 1, by omega⟩ + rw [hm, sum_range_succ', sum_zero_of_forall fun k hk => hzero k (by omega), Nat.zero_add, + snext_spineAt, ← hm, hend] + have hfm := (hk m (by omega)).2.1 + by_cases htt : p.tail[x]! = t + · subst htt + rw [if_pos ⟨rfl, by rw [hfm]; exact htf⟩, if_pos ⟨rfl, rfl⟩] + · rw [if_neg (fun h => htt h.1), if_neg (fun h => htt h.2)] + · rw [sum_zero_of_forall fun k hk => hzero k (by omega), if_neg (fun h => hjl h.1)] + +/-- The continuation spine edges of a telescope prefix into `t`: one if `t` +is among its inner spine nodes. -/ +theorem PrepWF.spine_cont_edges {p : Prep} (hp : PrepWF p) {x j t : Nat} (hx : x < p.dag.size) + (hf : p.family[x]! ≠ .none) (hj : j ≤ p.spineLen[x]!) + (hjt : j < p.spineLen[x]! → spineAt p x j ≠ t) : + ((List.range j).map fun k => + if snext p (spineAt p x k) = t ∧ p.family[t]! = p.family[spineAt p x k]! then 1 else 0).sum = + if (spineHit p x j t).isSome then 1 else 0 := by + obtain ⟨hl1, hk, hend, _, htf⟩ := hp.spine x hx hf + have heq : ∀ k ∈ List.range j, + (if snext p (spineAt p x k) = t ∧ p.family[t]! = p.family[spineAt p x k]! then 1 else 0) = + (if spineAt p x (k + 1) = t ∧ k + 1 < j then 1 else 0) := by + intro k hk' + rw [List.mem_range] at hk' + rw [snext_spineAt] + by_cases hkj : k + 1 < j + · have hfam : p.family[spineAt p x (k + 1)]! = p.family[spineAt p x k]! := by + rw [(hk (k + 1) (by omega)).2.1, (hk k (by omega)).2.1] + by_cases ht : spineAt p x (k + 1) = t + · rw [if_pos ⟨ht, by rw [← ht, hfam]⟩, if_pos ⟨ht, hkj⟩] + · rw [if_neg (fun h => ht h.1), if_neg (fun h => ht h.1)] + · rw [if_neg (show ¬(spineAt p x (k + 1) = t ∧ k + 1 < j) from fun h => hkj h.2)] + rw [if_neg] + rintro ⟨ht, hfam⟩ + have hkj' : k + 1 = j := by omega + by_cases hjl : j < p.spineLen[x]! + · exact hjt hjl (by rw [← hkj']; exact ht) + · have : k + 1 = p.spineLen[x]! := by omega + rw [this, hend] at ht + apply htf + rw [ht, hfam, (hk k (by omega)).2.1] + rw [List.map_congr_left heq] + rw [sum_indicator_unique (fun k => spineAt p x (k + 1) = t ∧ k + 1 < j) j (by + intro a b ha hb ⟨hPa, _⟩ ⟨hPb, _⟩ + rcases Nat.lt_trichotomy a b with hab | hab | hab + · have := hp.spineAt_strict hx hf (a := a + 1) (b := b + 1) (by omega) (by omega) + omega + · exact hab + · have := hp.spineAt_strict hx hf (a := b + 1) (b := a + 1) (by omega) (by omega) + omega)] + congr 1 + apply propext + rw [spineHit_isSome_iff] + constructor + · rintro ⟨k, _, ht, hkj⟩ + exact ⟨k + 1, by omega, hkj, ht⟩ + · rintro ⟨k, hk1, hkj, ht⟩ + exact ⟨k - 1, by omega, by rw [show k - 1 + 1 = k by omega]; exact ht, by omega⟩ + +/-! ## Occurrences are edges of written nodes -/ + +mutual +/-- The terms a writing writes inline (each spine node of a telescope). -/ +def WTree.written (p : Prep) : WTree → List Nat + | .share _ => [] + | .node x kids => x :: WTree.writtens p kids + | .tele x j sides tail => + (List.range j).map (spineAt p x) ++ WTree.writtens p sides ++ WTree.written p tail +def WTree.writtens (p : Prep) : List WTree → List Nat + | [] => [] + | k :: ks => WTree.written p k ++ WTree.writtens p ks +end + +/-- Whether a writing writes `t` itself inline at its top. -/ +def WTree.topIs (t : Nat) : WTree → Bool + | .share _ => false + | .node x _ => x == t + | .tele x _ _ _ => x == t + +theorem writtens_sum (p : Prep) (f : Nat → Nat) (l : List WTree) : + ((WTree.writtens p l).map f).sum = (l.map fun T => ((T.written p).map f).sum).sum := by + induction l with + | nil => rfl + | cons k ks ih => simp [WTree.writtens, ih] + +theorem sum_map_eq_range {α : Type} [Inhabited α] (f : α → Nat) (l : List α) : + (l.map f).sum = ((List.range l.length).map fun i => f (l[i]?.getD default)).sum := by + congr 1 + apply List.ext_getElem (by simp) + intro i h1 h2 + simp only [List.getElem_map, List.getElem_range] + rw [List.getElem?_eq_getElem (by simpa using h1)] + rfl + +theorem filter_length_eq_sum (P : Nat → Bool) (l : List Nat) : + (l.filter P).length = (l.map fun i => if P i = true then 1 else 0).sum := by + induction l with + | nil => rfl + | cons x xs ih => + simp only [List.filter_cons, List.map_cons, List.sum_cons] + split <;> simp [ih] <;> omega + +theorem sum_map_add' {α : Type} (f g : α → Nat) (l : List α) : + (l.map fun a => f a + g a).sum = (l.map f).sum + (l.map g).sum := by + induction l with + | nil => rfl + | cons x xs ih => simp only [List.map_cons, List.sum_cons, ih]; omega + +theorem top_iff {p : Prep} {S : Nat → Bool} {t : Nat} (hSt : S t = false) : + ∀ {x : Nat} {T : WTree}, Valid p S x T → (T.topIs t = true ↔ x = t) := by + intro x T h + cases h with + | share hS => + simp only [WTree.topIs, Bool.false_eq_true, false_iff] + intro hxt; subst hxt; rw [hS] at hSt; cases hSt + | node => simp [WTree.topIs] + | teleCut => simp [WTree.topIs] + | teleFull => simp [WTree.topIs] + +theorem writtens_mem {p : Prep} {y : Nat} {l : List WTree} (h : y ∈ WTree.writtens p l) : + ∃ T ∈ l, y ∈ T.written p := by + induction l with + | nil => simp [WTree.writtens] at h + | cons k ks ih => + simp only [WTree.writtens, List.mem_append] at h + rcases h with h | h + · exact ⟨k, List.mem_cons_self, h⟩ + · obtain ⟨T, hT, hy⟩ := ih h + exact ⟨T, List.mem_cons_of_mem _ hT, hy⟩ + +/-- The edges into `t` from the first `j` spine nodes of `x`. -/ +theorem PrepWF.spine_edges {p : Prep} (hp : PrepWF p) {x j t : Nat} (hx : x < p.dag.size) + (ht : t < p.dag.size) (hf : p.family[x]! ≠ .none) (hj : j ≤ p.spineLen[x]!) + (hjt : j < p.spineLen[x]! → spineAt p x j ≠ t) : + (((List.range j).map (spineAt p x)).map fun y => edgeMult p y t false).sum = + ((List.range j).map fun k => if sideAt p x k = t then 1 else 0).sum + + (if j = p.spineLen[x]! ∧ p.tail[x]! = t then 1 else 0) ∧ + (((List.range j).map (spineAt p x)).map fun y => edgeMult p y t true).sum = + if (spineHit p x j t).isSome then 1 else 0 := by + have hk : ∀ k ∈ List.range j, spineAt p x k < p.dag.size ∧ p.family[spineAt p x k]! ≠ .none := by + intro k hk + rw [List.mem_range] at hk + obtain ⟨hts, htf, _⟩ := hp.spine_shift hx hf (k := k) (by omega) + exact ⟨hts, by rw [htf]; exact hf⟩ + simp only [List.map_map, Function.comp_def] + constructor + · rw [List.map_congr_left fun k hk1 => (hp.edgeMult_tele (hk k hk1).1 ht (hk k hk1).2).2] + rw [sum_map_add', hp.spine_head_edges hx hf hj] + rfl + · rw [List.map_congr_left fun k hk1 => (hp.edgeMult_tele (hk k hk1).1 ht (hk k hk1).2).1] + exact hp.spine_cont_edges hx hf hj hjt + +/-- **Occurrences are edges.** In a writing for `S ∌ t`, the head occurrences +of `t` are the writing itself (if it writes `t`) plus one per non-continuation +edge from a written node into `t`, and the continuation occurrences are one +per continuation edge from a written node into `t`. -/ +theorem PrepWF.occ_edges {p : Prep} (hp : PrepWF p) {S : Nat → Bool} {t : Nat} + (hSt : S t = false) (htn : t < p.dag.size) : + ∀ {x : Nat} {T : WTree}, Valid p S x T → x < p.dag.size → + T.occH t = (if T.topIs t then 1 else 0) + + ((T.written p).map fun y => edgeMult p y t false).sum ∧ + T.occC p t = ((T.written p).map fun y => edgeMult p y t true).sum ∧ + (∀ y ∈ T.written p, y ≤ x) := by + have hzero : ∀ (c : Bool) (l : List Nat), (∀ y ∈ l, y ≤ t) → + (l.map fun y => edgeMult p y t c).sum = 0 := + fun c l hl => sum_map_eq_zero fun y hy => edgeMult_zero_of_le hp (hl y hy) c + intro x T h + induction h with + | share _ => intro _; simp [WTree.occH, WTree.occC, WTree.topIs, WTree.written] + | @node x kids hf hlen hkids ih => + intro hx + have hk : ∀ (i : Nat) (hi : i < kids.length), + kids[i].occH t = (if (p.dag.node x).child i = t then 1 else 0) + + ((kids[i].written p).map fun y => edgeMult p y t false).sum ∧ + kids[i].occC p t = ((kids[i].written p).map fun y => edgeMult p y t true).sum ∧ + (∀ y ∈ kids[i].written p, y ≤ (p.dag.node x).child i) := by + intro i hi + have hc := hp.dag.childAt_lt hx (k := i) (by omega) + obtain ⟨h1, h2, h3⟩ := ih i hi (by omega) + refine ⟨?_, h2, h3⟩ + rw [h1] + congr 1 + by_cases hct : (p.dag.node x).child i = t + · rw [if_pos ((top_iff hSt (hkids i hi)).mpr hct), if_pos hct] + · rw [if_neg (fun h => hct ((top_iff hSt (hkids i hi)).mp (by simpa using h))), + if_neg hct] + have hwle : ∀ y ∈ (WTree.node x kids).written p, y ≤ x := by + intro y hy + simp only [WTree.written] at hy + rcases List.mem_cons.mp hy with rfl | hy + · exact Nat.le_refl _ + · obtain ⟨T, hT, hyT⟩ := writtens_mem hy + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have := (hk i hi).2.2 y hyT + have := hp.dag.childAt_lt hx (k := i) (by omega) + omega + refine ⟨?_, ?_, hwle⟩ + · by_cases hxt : x = t + · subst hxt + rw [hzero false _ hwle] + simp [WTree.occH, WTree.topIs] + · simp only [WTree.occH, hxt, if_false, WTree.topIs, occHs_eq, WTree.written, + List.map_cons, List.sum_cons, writtens_sum, beq_iff_eq] + have hper : ∀ T ∈ kids, T.occH t = (if T.topIs t then 1 else 0) + + ((T.written p).map fun y => edgeMult p y t false).sum := by + intro T hT + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have := (ih i hi (by have := hp.dag.childAt_lt hx (k := i) (by omega); omega)).1 + exact this + rw [List.map_congr_left hper, sum_map_add'] + have hind : (kids.map fun T => if T.topIs t then 1 else 0).sum = + edgeMult p x t false := by + rw [(hp.edgeMult_node hx hf t).2, filter_length_eq_sum, sum_map_eq_range, hlen] + congr 1 + apply List.map_congr_left + intro i hi + rw [List.mem_range] at hi + rw [List.getElem?_eq_getElem (by omega), Option.getD_some] + by_cases hct : (p.dag.node x).child i = t + · rw [if_pos ((top_iff hSt (hkids i (by omega))).mpr hct)]; simp [hct] + · rw [if_neg (fun h => hct ((top_iff hSt (hkids i (by omega))).mp (by simpa using h)))] + simp [hct] + rw [hind] + omega + · by_cases hxt : x = t + · subst hxt + rw [hzero true _ hwle] + simp [WTree.occC] + · simp only [WTree.occC, hxt, if_false, occCs_eq, WTree.written, List.map_cons, + List.sum_cons, writtens_sum] + rw [(hp.edgeMult_node hx hf t).1, Nat.zero_add] + congr 1 + apply List.map_congr_left + intro T hT + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + exact (hk i hi).2.1 + | @teleCut x j sides hf hj1 hj hlen hsides hS ih => + intro hx + have hside : ∀ T ∈ sides, T.occH t = (if T.topIs t then 1 else 0) + + ((T.written p).map fun y => edgeMult p y t false).sum ∧ + T.occC p t = ((T.written p).map fun y => edgeMult p y t true).sum ∧ + (∀ y ∈ T.written p, y < x) := by + intro T hT + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hsl := hp.sideAt_lt hx hf (k := i) (by omega) + obtain ⟨h1, h2, h3⟩ := ih i hi (by omega) + exact ⟨h1, h2, fun y hy => by have := h3 y hy; omega⟩ + have hwle : ∀ y ∈ (WTree.tele x j sides (.share (spineAt p x j))).written p, y ≤ x := by + intro y hy + simp only [WTree.written, List.append_nil, List.mem_append] at hy + rcases hy with hy | hy + · obtain ⟨k, hk, rfl⟩ := List.mem_map.mp hy + exact hp.spineAt_le hx hf (by rw [List.mem_range] at hk; omega) + · obtain ⟨T, hT, hyT⟩ := writtens_mem hy + exact Nat.le_of_lt ((hside T hT).2.2 y hyT) + refine ⟨?_, ?_, hwle⟩ + · by_cases hxt : x = t + · subst hxt + rw [hzero false _ hwle] + simp [WTree.occH, WTree.topIs] + · have hjt : spineAt p x j ≠ t := by intro h; rw [h] at hS; rw [hS] at hSt; cases hSt + obtain ⟨hF, _⟩ := hp.spine_edges hx htn hf (Nat.le_of_lt hj) (fun _ => hjt) + simp only [WTree.occH, hxt, if_false, WTree.topIs, occHs_eq, WTree.written, + List.map_append, List.sum_append, writtens_sum, beq_iff_eq, List.append_nil] + rw [hF, List.map_congr_left (fun T hT => (hside T hT).1), sum_map_add'] + have hind : (sides.map fun T => if T.topIs t then 1 else 0).sum = + ((List.range j).map fun k => if sideAt p x k = t then 1 else 0).sum := by + rw [sum_map_eq_range, hlen] + congr 1 + apply List.map_congr_left + intro i hi + rw [List.mem_range] at hi + rw [List.getElem?_eq_getElem (by omega), Option.getD_some] + by_cases hct : sideAt p x i = t + · rw [if_pos ((top_iff hSt (hsides i (by omega))).mpr hct), if_pos hct] + · rw [if_neg (fun h => hct ((top_iff hSt (hsides i (by omega))).mp (by simpa using h))), + if_neg hct] + rw [hind, if_neg (fun h => by omega)] + simp + · by_cases hxt : x = t + · subst hxt + rw [hzero true _ hwle] + simp [WTree.occC] + · have hjt : spineAt p x j ≠ t := by intro h; rw [h] at hS; rw [hS] at hSt; cases hSt + obtain ⟨_, hT⟩ := hp.spine_edges hx htn hf (Nat.le_of_lt hj) (fun _ => hjt) + simp only [WTree.occC, hxt, if_false, occCs_eq, WTree.written, List.map_append, + List.sum_append, writtens_sum, List.append_nil] + rw [hT, List.map_congr_left (fun T hT => (hside T hT).2.1)] + simp + | @teleFull x sides tail hf hlen hsides htail ih iht => + intro hx + obtain ⟨_, _, _, htl, _⟩ := hp.spine x hx hf + have hside : ∀ T ∈ sides, T.occH t = (if T.topIs t then 1 else 0) + + ((T.written p).map fun y => edgeMult p y t false).sum ∧ + T.occC p t = ((T.written p).map fun y => edgeMult p y t true).sum ∧ + (∀ y ∈ T.written p, y < x) := by + intro T hT + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hsl := hp.sideAt_lt hx hf (k := i) (by omega) + obtain ⟨h1, h2, h3⟩ := ih i hi (by omega) + exact ⟨h1, h2, fun y hy => by have := h3 y hy; omega⟩ + obtain ⟨ht1, ht2, ht3⟩ := iht (by omega) + have hwle : ∀ y ∈ (WTree.tele x p.spineLen[x]! sides tail).written p, y ≤ x := by + intro y hy + simp only [WTree.written, List.mem_append] at hy + rcases hy with (hy | hy) | hy + · obtain ⟨k, hk, rfl⟩ := List.mem_map.mp hy + exact hp.spineAt_le hx hf (by rw [List.mem_range] at hk; omega) + · obtain ⟨T, hT, hyT⟩ := writtens_mem hy + exact Nat.le_of_lt ((hside T hT).2.2 y hyT) + · have := ht3 y hy; omega + refine ⟨?_, ?_, hwle⟩ + · by_cases hxt : x = t + · subst hxt + rw [hzero false _ hwle] + simp [WTree.occH, WTree.topIs] + · obtain ⟨hF, _⟩ := hp.spine_edges hx htn hf (Nat.le_refl _) (fun h => absurd h (by omega)) + simp only [WTree.occH, hxt, if_false, WTree.topIs, occHs_eq, WTree.written, + List.map_append, List.sum_append, writtens_sum, beq_iff_eq] + rw [hF, List.map_congr_left (fun T hT => (hside T hT).1), sum_map_add', ht1] + have hind : (sides.map fun T => if T.topIs t then 1 else 0).sum = + ((List.range p.spineLen[x]!).map fun k => if sideAt p x k = t then 1 else 0).sum := by + rw [sum_map_eq_range, hlen] + congr 1 + apply List.map_congr_left + intro i hi + rw [List.mem_range] at hi + rw [List.getElem?_eq_getElem (by omega), Option.getD_some] + by_cases hct : sideAt p x i = t + · rw [if_pos ((top_iff hSt (hsides i (by omega))).mpr hct), if_pos hct] + · rw [if_neg (fun h => hct ((top_iff hSt (hsides i (by omega))).mp (by simpa using h))), + if_neg hct] + have htop : (if tail.topIs t then 1 else 0) = + (if p.spineLen[x]! = p.spineLen[x]! ∧ p.tail[x]! = t then 1 else 0) := by + by_cases htt : p.tail[x]! = t + · rw [if_pos ((top_iff hSt htail).mpr htt), if_pos ⟨rfl, htt⟩] + · rw [if_neg (fun h => htt ((top_iff hSt htail).mp (by simpa using h))), + if_neg (fun h => htt h.2)] + rw [hind, htop] + omega + · by_cases hxt : x = t + · subst hxt + rw [hzero true _ hwle] + simp [WTree.occC] + · obtain ⟨_, hT⟩ := hp.spine_edges hx htn hf (Nat.le_refl _) (fun h => absurd h (by omega)) + simp only [WTree.occC, hxt, if_false, occCs_eq, WTree.written, List.map_append, + List.sum_append, writtens_sum] + rw [hT, List.map_congr_left (fun T hT => (hside T hT).2.1), ht2] +/-! ## Every reachable term is written -/ + +open Ix.Compile.Verify.SharingExact (Desc) + +mutual +/-- The Shares a writing uses. -/ +def WTree.shares : WTree → List Nat + | .share x => [x] + | .node _ kids => WTree.sharess kids + | .tele _ _ sides tail => WTree.sharess sides ++ WTree.shares tail +def WTree.sharess : List WTree → List Nat + | [] => [] + | k :: ks => WTree.shares k ++ WTree.sharess ks +end + +theorem sharess_mem {y : Nat} {l : List WTree} (h : y ∈ WTree.sharess l) : + ∃ T ∈ l, y ∈ T.shares := by + induction l with + | nil => simp [WTree.sharess] at h + | cons k ks ih => + simp only [WTree.sharess, List.mem_append] at h + rcases h with h | h + · exact ⟨k, List.mem_cons_self, h⟩ + · obtain ⟨T, hT, hy⟩ := ih h + exact ⟨T, List.mem_cons_of_mem _ hT, hy⟩ + +theorem mem_sharess {y : Nat} {l : List WTree} {T : WTree} (hT : T ∈ l) (h : y ∈ T.shares) : + y ∈ WTree.sharess l := by + induction l with + | nil => cases hT + | cons k ks ih => + simp only [WTree.sharess, List.mem_append] + rcases List.mem_cons.mp hT with rfl | hT + · exact Or.inl h + · exact Or.inr (ih hT) + +theorem mem_writtens {p : Prep} {y : Nat} {l : List WTree} {T : WTree} (hT : T ∈ l) + (h : y ∈ T.written p) : y ∈ WTree.writtens p l := by + induction l with + | nil => cases hT + | cons k ks ih => + simp only [WTree.writtens, List.mem_append] + rcases List.mem_cons.mp hT with rfl | hT + · exact Or.inl h + · exact Or.inr (ih hT) + +/-- The Shares of a writing of `x` are stored terms below `x` (strictly, for +an inline writing). -/ +theorem PrepWF.shares_lt {p : Prep} (hp : PrepWF p) {S : Nat → Bool} : + ∀ {x : Nat} {T : WTree}, Valid p S x T → x < p.dag.size → + ∀ s ∈ T.shares, S s = true ∧ (s ≤ x) ∧ (T.isShare = false → s < x) := by + intro x T h + induction h with + | share hS => + intro _ s hs + simp only [WTree.shares, List.mem_singleton] at hs + subst hs + exact ⟨hS, Nat.le_refl _, fun h => by simp [WTree.isShare] at h⟩ + | @node x kids hf hlen _ ih => + intro hx s hs + simp only [WTree.shares] at hs + obtain ⟨T, hT, hsT⟩ := sharess_mem hs + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hc := hp.dag.childAt_lt hx (k := i) (by omega) + obtain ⟨h1, h2, _⟩ := ih i hi (by omega) s hsT + exact ⟨h1, by omega, fun _ => by omega⟩ + | @teleCut x j sides hf hj1 hj hlen _ hS ih => + intro hx s hs + simp only [WTree.shares, List.mem_append, List.mem_singleton] at hs + rcases hs with hs | rfl + · obtain ⟨T, hT, hsT⟩ := sharess_mem hs + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hsl := hp.sideAt_lt hx hf (k := i) (by omega) + obtain ⟨h1, h2, _⟩ := ih i hi (by omega) s hsT + exact ⟨h1, by omega, fun _ => by omega⟩ + · have := hp.spineAt_lt hx hf hj1 hj + exact ⟨hS, by omega, fun _ => this⟩ + | @teleFull x sides tail hf hlen _ _ ih iht => + intro hx s hs + obtain ⟨_, _, _, htl, _⟩ := hp.spine x hx hf + simp only [WTree.shares, List.mem_append] at hs + rcases hs with hs | hs + · obtain ⟨T, hT, hsT⟩ := sharess_mem hs + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hT + have hsl := hp.sideAt_lt hx hf (k := i) (by omega) + obtain ⟨h1, h2, _⟩ := ih i hi (by omega) s hsT + exact ⟨h1, by omega, fun _ => by omega⟩ + · obtain ⟨h1, h2, _⟩ := iht (by omega) s hs + exact ⟨h1, by omega, fun _ => by omega⟩ + +theorem PrepWF.tele_child {p : Prep} (hp : PrepWF p) {y k : Nat} (hy : y < p.dag.size) + (hf : p.family[y]! ≠ .none) (hk : k < (p.dag.node y).children.size) : + (p.dag.node y).child k = (p.dag.node y).sideChild ∨ (p.dag.node y).child k = snext p y := by + have ha := hp.dag.arity y hy + rw [← dag_node_eq hy] at ha + have hfy : (p.dag.node y).head.family ≠ .none := by rw [← hp.family y hy]; exact hf + unfold Node.sideChild snext Node.spineNext + cases hh : (p.dag.node y).head <;> simp only [hh, Head.family, ne_eq, not_true_eq_false] at hfy <;> + simp only [hh, Head.arity] at ha <;> rw [ha] at hk <;> + (rcases k with _ | _ | k) <;> simp_all <;> omega + +/-- **Coverage.** Every term below `x` is written by a writing of `x` or lies +below one of its Shares. -/ +theorem PrepWF.cover {p : Prep} (hp : PrepWF p) {S : Nat → Bool} : + ∀ {x : Nat} {T : WTree}, Valid p S x T → x < p.dag.size → + ∀ y, Desc p.dag x y → y ∈ T.written p ∨ ∃ s ∈ T.shares, Desc p.dag s y := by + intro x T h + induction h with + | @share x _ => + intro _ y hd + exact Or.inr ⟨x, by simp [WTree.shares], hd⟩ + | @node x kids hf hlen _ ih => + intro hx y hd + cases hd with + | refl => exact Or.inl (by simp [WTree.written]) + | @child _ _ k hk hd' => + have ha := hp.dag.arity x hx + rw [← dag_node_eq hx] at ha + have hkl : k < kids.length := by omega + have hc := hp.dag.childAt_lt hx (k := k) (by omega) + rcases ih k hkl (by omega) y hd' with hw | ⟨s, hs, hds⟩ + · exact Or.inl (by + simp only [WTree.written, List.mem_cons] + exact Or.inr (mem_writtens (List.getElem_mem hkl) hw)) + · exact Or.inr ⟨s, by simp only [WTree.shares]; exact mem_sharess (List.getElem_mem hkl) hs, + hds⟩ + | @teleCut x j sides hf hj1 hj hlen hsides hS ih => + intro hx y hd + have hside : ∀ m, m < j → Desc p.dag (sideAt p x m) y → + y ∈ (WTree.tele x j sides (.share (spineAt p x j))).written p ∨ + ∃ s ∈ (WTree.tele x j sides (.share (spineAt p x j))).shares, Desc p.dag s y := by + intro m hm hd' + have hsl := hp.sideAt_lt hx hf (k := m) (by omega) + rcases ih m (by omega) (by omega) y hd' with hw | ⟨s, hs, hds⟩ + · exact Or.inl (by + simp only [WTree.written, List.mem_append] + exact Or.inl (Or.inr (mem_writtens (List.getElem_mem (by omega)) hw))) + · exact Or.inr ⟨s, by + simp only [WTree.shares, List.mem_append] + exact Or.inl (mem_sharess (List.getElem_mem (by omega)) hs), hds⟩ + have key : ∀ i m, m + i = j - 1 → Desc p.dag (spineAt p x m) y → + y ∈ (WTree.tele x j sides (.share (spineAt p x j))).written p ∨ + ∃ s ∈ (WTree.tele x j sides (.share (spineAt p x j))).shares, Desc p.dag s y := by + intro i + induction i with + | zero => + intro m hm hd' + obtain ⟨hms, hmf, _⟩ := hp.spine_shift hx hf (k := m) (by omega) + have hmf' : p.family[spineAt p x m]! ≠ .none := by rw [hmf]; exact hf + cases hd' with + | refl => + exact Or.inl (by + simp only [WTree.written, List.mem_append] + exact Or.inl (Or.inl (List.mem_map.mpr ⟨m, List.mem_range.mpr (by omega), rfl⟩))) + | @child _ _ k hk hd'' => + rcases hp.tele_child hms hmf' hk with hc | hc + · rw [hc] at hd''; exact hside m (by omega) hd'' + · rw [hc, snext_spineAt, show m + 1 = j by omega] at hd'' + exact Or.inr ⟨spineAt p x j, by simp [WTree.shares], hd''⟩ + | succ i ihi => + intro m hm hd' + obtain ⟨hms, hmf, _⟩ := hp.spine_shift hx hf (k := m) (by omega) + have hmf' : p.family[spineAt p x m]! ≠ .none := by rw [hmf]; exact hf + cases hd' with + | refl => + exact Or.inl (by + simp only [WTree.written, List.mem_append] + exact Or.inl (Or.inl (List.mem_map.mpr ⟨m, List.mem_range.mpr (by omega), rfl⟩))) + | @child _ _ k hk hd'' => + rcases hp.tele_child hms hmf' hk with hc | hc + · rw [hc] at hd''; exact hside m (by omega) hd'' + · rw [hc, snext_spineAt] at hd'' + exact ihi (m + 1) (by omega) hd'' + exact key (j - 1) 0 (by omega) hd + | @teleFull x sides tail hf hlen hsides htail ih iht => + intro hx y hd + obtain ⟨hl1, _, hend, htl, _⟩ := hp.spine x hx hf + have hside : ∀ m, m < p.spineLen[x]! → Desc p.dag (sideAt p x m) y → + y ∈ (WTree.tele x p.spineLen[x]! sides tail).written p ∨ + ∃ s ∈ (WTree.tele x p.spineLen[x]! sides tail).shares, Desc p.dag s y := by + intro m hm hd' + have hsl := hp.sideAt_lt hx hf (k := m) (by omega) + rcases ih m (by omega) (by omega) y hd' with hw | ⟨s, hs, hds⟩ + · exact Or.inl (by + simp only [WTree.written, List.mem_append] + exact Or.inl (Or.inr (mem_writtens (List.getElem_mem (by omega)) hw))) + · exact Or.inr ⟨s, by + simp only [WTree.shares, List.mem_append] + exact Or.inl (mem_sharess (List.getElem_mem (by omega)) hs), hds⟩ + have key : ∀ i m, m + i = p.spineLen[x]! - 1 → Desc p.dag (spineAt p x m) y → + y ∈ (WTree.tele x p.spineLen[x]! sides tail).written p ∨ + ∃ s ∈ (WTree.tele x p.spineLen[x]! sides tail).shares, Desc p.dag s y := by + intro i + induction i with + | zero => + intro m hm hd' + obtain ⟨hms, hmf, _⟩ := hp.spine_shift hx hf (k := m) (by omega) + have hmf' : p.family[spineAt p x m]! ≠ .none := by rw [hmf]; exact hf + cases hd' with + | refl => + exact Or.inl (by + simp only [WTree.written, List.mem_append] + exact Or.inl (Or.inl (List.mem_map.mpr ⟨m, List.mem_range.mpr (by omega), rfl⟩))) + | @child _ _ k hk hd'' => + rcases hp.tele_child hms hmf' hk with hc | hc + · rw [hc] at hd''; exact hside m (by omega) hd'' + · rw [hc, snext_spineAt, show m + 1 = p.spineLen[x]! by omega, hend] at hd'' + rcases iht (by omega) y hd'' with hw | ⟨s, hs, hds⟩ + · exact Or.inl (by simp only [WTree.written, List.mem_append]; exact Or.inr hw) + · exact Or.inr ⟨s, by simp only [WTree.shares, List.mem_append]; exact Or.inr hs, hds⟩ + | succ i ihi => + intro m hm hd' + obtain ⟨hms, hmf, _⟩ := hp.spine_shift hx hf (k := m) (by omega) + have hmf' : p.family[spineAt p x m]! ≠ .none := by rw [hmf]; exact hf + cases hd' with + | refl => + exact Or.inl (by + simp only [WTree.written, List.mem_append] + exact Or.inl (Or.inl (List.mem_map.mpr ⟨m, List.mem_range.mpr (by omega), rfl⟩))) + | @child _ _ k hk hd'' => + rcases hp.tele_child hms hmf' hk with hc | hc + · rw [hc] at hd''; exact hside m (by omega) hd'' + · rw [hc, snext_spineAt] at hd'' + exact ihi (m + 1) (by omega) hd'' + exact key (p.spineLen[x]! - 1) 0 (by omega) hd + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformFinal.lean b/Ix/Compile/Verify/UniformFinal.lean new file mode 100644 index 000000000..9d9274fb9 --- /dev/null +++ b/Ix/Compile/Verify/UniformFinal.lean @@ -0,0 +1,65 @@ +import Ix.Compile.Verify.UniformDecomp +import Ix.Compile.Verify.UniformOptimizer + +/-! +# Stage 4: every term of an optimized DAG is reachable from a root + +Facts about the run of `optimizeUniformExpanded` that the optimality theorem +(`UniformOptimality`) needs, discharged from its runtime checks: every term is +reachable from a root (`optimizeUniform_reach`). +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (Desc Reach reach_lt reachMarks_spec reachMarks_eq + marksFrom_size child_eq_getElem) + +/-! ## Every term is reachable from a root -/ + +/-- A path extended by one edge. -/ +theorem desc_snoc {dag : Dag} {r t : Nat} (h : Desc dag r t) {k : Nat} + (hk : k < (dag.node t).children.size) : Desc dag r ((dag.node t).child k) := by + induction h with + | refl t => exact .child k hk (.refl _) + | child k' hk' _ ih => exact .child k' hk' (ih hk) + +theorem desc_of_reach {dag : Dag} {roots : Array Nat} (hin : ∀ r ∈ roots, r < dag.size) + (hcp : Ix.Compile.Verify.SharingExact.CP dag.nodes) {t : Nat} + (h : Reach dag.nodes roots t) : ∃ r ∈ roots.toList, Desc dag r t := by + induction h with + | root hr => exact ⟨_, Array.mem_toList_iff.mpr hr, .refl _⟩ + | @child t c ht hc ih => + obtain ⟨r, hr, hd⟩ := ih + have htn : t < dag.size := reach_lt hcp hin ht + rw [← dag_node_eq htn] at hc + obtain ⟨k, hk, rfl⟩ := Array.mem_iff_getElem.mp hc + refine ⟨r, hr, ?_⟩ + rw [← child_eq_getElem _ k hk] + exact desc_snoc hd hk + +/-- **Reachability from the optimizer's check.** -/ +theorem reach_of_marks {dag : Dag} (hwf : DagWF dag) {roots : Array Nat} + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hm : (reachMarks dag.nodes roots).all id = true) : + ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y := by + intro y hy + have hin : ∀ r ∈ roots, r < dag.nodes.size := fun r hr => hroots r (Array.mem_toList_iff.mpr hr) + have hsz : (reachMarks dag.nodes roots).size = dag.nodes.size := by + rw [reachMarks_eq, marksFrom_size] + rw [Array.all_eq_true] at hm + have hy' : y < (reachMarks dag.nodes roots).size := by rw [hsz]; exact hy + have hmark : (reachMarks dag.nodes roots)[y]! = true := by + have := hm y hy' + simp only [id] at this + simpa [getElem!_def, Array.getElem?_eq_getElem hy'] using this + exact desc_of_reach hin hwf.precede ((reachMarks_spec hwf.precede hin y hy).mp hmark) + +/-- **The optimizer only succeeds on a DAG whose roots reach every term.** -/ +theorem optimizeUniform_reach {w : Nat} {limits : Limits} {ex : Expanded} + {res : UniformSharingResult} (h : optimizeUniformExpanded w limits ex = .ok res) : + ∀ y, y < ex.dag.size → ∃ r ∈ ex.roots.toList, Desc ex.dag r y := by + obtain ⟨_, hwf, hroots, hm, _⟩ := optimizeUniform_parts h + exact reach_of_marks hwf hroots hm + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformGain.lean b/Ix/Compile/Verify/UniformGain.lean new file mode 100644 index 000000000..b1a70bf3f --- /dev/null +++ b/Ix/Compile/Verify/UniformGain.lean @@ -0,0 +1,806 @@ +import Ix.Compile.Verify.UniformExchange + +/-! +# The certain-stored gain bound + +The executable facts behind `storedGain`: `graphFacts` counts in-degrees and +head in-degrees exactly as the edges `edgeMult` (`edgeCounts_spec`), and +`uniformBounds` gives lower bounds of the model values for every stored set +within the candidates (`bounds_sound`). With the exchange of +`UniformExchange` this gives the stage-2 inequality +`uniformCost (S ∪ {t}) ≤ uniformCost S - storedGain t + 1`. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact + +/-! ## In-degrees -/ + +theorem modify_add_getElem! (acc : Array Nat) (c t : Nat) : + (acc.modify c (· + 1))[t]! = acc[t]! + (if c = t ∧ c < acc.size then 1 else 0) := by + simp only [getElem!_def, Array.getElem?_modify] + by_cases hct : c = t + · subst hct + by_cases hc : c < acc.size + · simp [hc] + · simp [hc] + · simp [hct] + +theorem foldl_modify_count : + ∀ (l : List Nat) (acc : Array Nat) (t : Nat), (∀ c ∈ l, c < acc.size) → + (l.foldl (fun acc c => acc.modify c (· + 1)) acc)[t]! = acc[t]! + l.count t ∧ + (l.foldl (fun acc c => acc.modify c (· + 1)) acc).size = acc.size := by + intro l + induction l with + | nil => intro acc t _; simp + | cons c cs ih => + intro acc t hl + rw [List.foldl_cons] + have hc := hl c List.mem_cons_self + obtain ⟨h1, h2⟩ := ih (acc.modify c (· + 1)) t (fun c' hc' => by + simpa using hl c' (List.mem_cons_of_mem _ hc')) + refine ⟨?_, by rw [h2]; simp⟩ + rw [h1, modify_add_getElem!, List.count_cons] + by_cases hct : c = t + · subst hct; simp [hc]; omega + · simp [hct] + +theorem foldl_if_modify {α : Type} (P : α → Bool) (g : α → Nat) : + ∀ (l : List α) (acc : Array Nat), + l.foldl (fun acc i => if P i then acc else acc.modify (g i) (· + 1)) acc = + ((l.filter fun i => !P i).map g).foldl (fun acc c => acc.modify c (· + 1)) acc := by + intro l + induction l with + | nil => intro _; rfl + | cons x xs ih => + intro acc + rw [List.foldl_cons, List.filter_cons] + cases hP : P x <;> simp [ih] + +theorem count_map_filter (g : Nat → Nat) (Q : Nat → Bool) (l : List Nat) (t : Nat) : + ((l.filter Q).map g).count t = (l.filter fun i => Q i && g i == t).length := by + induction l with + | nil => rfl + | cons x xs ih => + simp only [List.filter_cons] + cases hQ : Q x <;> by_cases hg : g x = t <;> simp [hg, ih] + +theorem filter_length_split {α : Type} (a b : α → Bool) (l : List α) : + (l.filter a).length = (l.filter fun i => a i && b i == false).length + + (l.filter fun i => a i && b i == true).length := by + induction l with + | nil => rfl + | cons x xs ih => + simp only [List.filter_cons] + cases ha : a x <;> cases hb : b x <;> simp [ih] <;> omega + +/-- **In-degrees.** `edgeCounts` (`graphFacts.deg` / `.headDeg`) counts the +root occurrences plus every edge (every non-continuation edge) into `t`. -/ +theorem edgeCounts_spec {dag : Dag} (h : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (headOnly : Bool) (t : Nat) : + (edgeCounts dag roots headOnly)[t]! = roots.toList.count t + + ((List.range dag.size).map fun y => + if headOnly then edgeMult (Prep.ofDag dag) y t false + else edgeMult (Prep.ofDag dag) y t false + edgeMult (Prep.ofDag dag) y t true).sum := by + let step := fun (acc : Array Nat) (y : Nat) => + (List.range (dag.node y).children.size).foldl (fun acc i => + if headOnly && continuationEdge (dag.node y) i (dag.node ((dag.node y).child i)) then acc + else acc.modify ((dag.node y).child i) (· + 1)) acc + have hstep : ∀ (acc : Array Nat) (y : Nat), acc.size = dag.size → y < dag.size → + (step acc y)[t]! = acc[t]! + (if headOnly then edgeMult (Prep.ofDag dag) y t false + else edgeMult (Prep.ofDag dag) y t false + edgeMult (Prep.ofDag dag) y t true) ∧ + (step acc y).size = dag.size := by + intro acc y hs hy + simp only [step] + rw [foldl_if_modify (fun i => headOnly && + continuationEdge (dag.node y) i (dag.node ((dag.node y).child i))) (dag.node y).child] + have hlt : ∀ c ∈ ((List.range (dag.node y).children.size).filter fun i => + !(headOnly && continuationEdge (dag.node y) i (dag.node ((dag.node y).child i)))).map + (dag.node y).child, c < acc.size := by + intro c hc + obtain ⟨i, hi, rfl⟩ := List.mem_map.mp hc + have hi' := List.mem_range.mp (List.mem_filter.mp hi).1 + rw [Ix.Compile.Verify.SharingExact.child_eq_getElem _ i hi'] + have := h.child_lt hy (Array.getElem_mem hi') + omega + obtain ⟨h1, h2⟩ := foldl_modify_count _ acc t hlt + refine ⟨?_, by rw [h2, hs]⟩ + rw [h1, count_map_filter] + congr 1 + have har := h.arity y hy + rw [← dag_node_eq hy] at har + unfold edgeMult + rw [ofDag_dag, ← har] + cases headOnly with + | true => + simp only [if_true] + congr 1 + apply List.filter_congr + intro i _ + cases hc : continuationEdge (dag.node y) i (dag.node ((dag.node y).child i)) <;> + by_cases hct : (dag.node y).child i = t <;> simp_all + | false => + simp only [Bool.false_eq_true, if_false, Bool.false_and, Bool.not_false, Bool.true_and] + rw [filter_length_split (fun i => (dag.node y).child i == t) + (fun i => continuationEdge (dag.node y) i (dag.node t))] + have hinv : ∀ m, m ≤ dag.size → + ((List.range m).foldl step + (roots.foldl (fun acc r => acc.modify r (· + 1)) (Array.replicate dag.size 0)))[t]! = + roots.toList.count t + ((List.range m).map fun y => + if headOnly then edgeMult (Prep.ofDag dag) y t false + else edgeMult (Prep.ofDag dag) y t false + edgeMult (Prep.ofDag dag) y t true).sum ∧ + ((List.range m).foldl step + (roots.foldl (fun acc r => acc.modify r (· + 1)) (Array.replicate dag.size 0))).size = + dag.size := by + intro m + induction m with + | zero => + intro _ + simp only [List.range_zero, List.foldl_nil, List.map_nil, List.sum_nil, Nat.add_zero] + rw [← Array.foldl_toList] + obtain ⟨h1, h2⟩ := foldl_modify_count roots.toList (Array.replicate dag.size 0) t + (fun c hc => by simpa using hroots c hc) + refine ⟨?_, by rw [h2]; simp⟩ + rw [h1] + have : (Array.replicate dag.size (0 : Nat))[t]! = 0 := by + simp only [getElem!_def, Array.getElem?_replicate] + by_cases ht : t < dag.size <;> simp [ht] + rw [this] + omega + | succ m ih => + intro hm + obtain ⟨h1, h2⟩ := ih (by omega) + rw [foldl_range_succ, sum_range_succ'] + obtain ⟨h3, h4⟩ := hstep _ m h2 (by omega) + exact ⟨by rw [h3, h1]; omega, h4⟩ + unfold edgeCounts + rw [foldRange_zero] + exact (hinv dag.size (Nat.le_refl _)).1 + +/-! ## The bounds -/ + +/-- The recurrence of `uniformBounds` at `t`. -/ +def BoundsRow (p : Prep) (w : Nat) (ms : Array Bool) (b : UBounds) (t : Nat) : Prop := + (p.family[t]! = .none → + b.inlineLB[t]! = (p.dag.node t).children.foldl (fun acc c => acc + b.headLB[c]!) + (p.dag.node t).head.ownBytes ∧ b.mergedLB[t]! = b.inlineLB[t]!) ∧ + (p.family[t]! ≠ .none → + b.mergedLB[t]! = (p.dag.node t).sideExtra + b.headLB[(p.dag.node t).sideChild]! + + (if p.family[snext p t]! = p.family[t]! then b.contLB[snext p t]! else b.headLB[snext p t]!) ∧ + b.inlineLB[t]! = 1 + b.mergedLB[t]!) ∧ + b.headLB[t]! = (if ms[t]! then min w b.inlineLB[t]! else b.inlineLB[t]!) ∧ + b.contLB[t]! = (if ms[t]! then min w b.mergedLB[t]! else b.mergedLB[t]!) + +theorem BoundsRow.congr {p : Prep} (hp : PrepWF p) {w : Nat} {ms : Array Bool} {b b' : UBounds} + {t : Nat} (ht : t < p.dag.size) + (hi : b'.inlineLB[t]! = b.inlineLB[t]!) (hm : b'.mergedLB[t]! = b.mergedLB[t]!) + (hh : ∀ c, c ≤ t → b'.headLB[c]! = b.headLB[c]!) (hc : ∀ c, c ≤ t → b'.contLB[c]! = b.contLB[c]!) + (hrow : BoundsRow p w ms b t) : BoundsRow p w ms b' t := by + obtain ⟨h1, h2, h3, h4⟩ := hrow + refine ⟨fun hf => ?_, fun hf => ?_, by rw [hh t (Nat.le_refl _), hi, h3], + by rw [hc t (Nat.le_refl _), hm, h4]⟩ + · obtain ⟨a, b⟩ := h1 hf + refine ⟨?_, by rw [hm, hi, b]⟩ + rw [hi, a] + exact foldl_add_congr _ _ fun c hc' => (hh c (by + have := hp.dag.child_lt ht hc'; omega)).symm + · obtain ⟨a, b⟩ := h2 hf + have hs := hp.sideChild_lt ht hf + have hn := hp.snext_lt ht hf + refine ⟨?_, by rw [hi, hm, b]⟩ + rw [hm, a, hh _ (by omega), hh _ (by omega), hc _ (by omega)] + +theorem setBang_getElem!_ne {α : Type} [Inhabited α] (a : Array α) {i j : Nat} (v : α) + (h : j ≠ i) : (a.set! i v)[j]! = a[j]! := by + rw [Ix.Compile.Verify.SharingExact.setBang_getElem!, if_neg (fun h' => h h'.1.symm)] + +theorem setBang_getElem!_self {α : Type} [Inhabited α] (a : Array α) {i : Nat} (v : α) + (h : i < a.size) : (a.set! i v)[i]! = v := by + rw [Ix.Compile.Verify.SharingExact.setBang_getElem!, if_pos ⟨rfl, h⟩] + +/-- `uniformBounds` satisfies its recurrence at every term. -/ +theorem PrepWF.uniformBounds_spec {p : Prep} (hp : PrepWF p) (w : Nat) (ms : Array Bool) (t : Nat) + (ht : t < p.dag.size) : BoundsRow p w ms (uniformBounds p w ms) t := by + let init : UBounds := + { inlineLB := Array.replicate p.dag.size 0, mergedLB := Array.replicate p.dag.size 0, + headLB := Array.replicate p.dag.size 0, contLB := Array.replicate p.dag.size 0 } + have hinv : ∀ m, m ≤ p.dag.size → + let b := (List.range m).foldl (boundsStep p w ms) init + (b.inlineLB.size = p.dag.size ∧ b.mergedLB.size = p.dag.size ∧ + b.headLB.size = p.dag.size ∧ b.contLB.size = p.dag.size) ∧ + ∀ t, t < m → BoundsRow p w ms b t := by + intro m + induction m with + | zero => intro _; exact ⟨by simp [init], fun _ h => absurd h (Nat.not_lt_zero _)⟩ + | succ m ih => + intro hm + obtain ⟨⟨s1, s2, s3, s4⟩, hrows⟩ := ih (by omega) + simp only at s1 s2 s3 s4 hrows ⊢ + rw [foldl_range_succ] + generalize (List.range m).foldl (boundsStep p w ms) init = b at s1 s2 s3 s4 hrows + have hmn : m < p.dag.size := by omega + -- the new arrays agree with the old ones below `m` + have keep : ∀ c, c < m → + (boundsStep p w ms b m).inlineLB[c]! = b.inlineLB[c]! ∧ + (boundsStep p w ms b m).mergedLB[c]! = b.mergedLB[c]! ∧ + (boundsStep p w ms b m).headLB[c]! = b.headLB[c]! ∧ + (boundsStep p w ms b m).contLB[c]! = b.contLB[c]! := by + intro c hc + unfold boundsStep + simp only + split <;> exact ⟨setBang_getElem!_ne _ _ (by omega), setBang_getElem!_ne _ _ (by omega), + setBang_getElem!_ne _ _ (by omega), setBang_getElem!_ne _ _ (by omega)⟩ + refine ⟨by unfold boundsStep; simp only; split <;> simp [s1, s2, s3, s4], fun t ht' => ?_⟩ + by_cases htm : t = m + · subst htm + unfold boundsStep + simp only + by_cases hf : p.family[t]! = .none + · have hfb : (p.family[t]! == Family.none) = true := by simp [hf] + simp only [hfb, if_true] + refine ⟨fun _ => ⟨?_, ?_⟩, fun h => absurd hf h, ?_, ?_⟩ + · rw [setBang_getElem!_self _ _ (by omega)] + exact foldl_add_congr _ _ fun c hc => (setBang_getElem!_ne _ _ (by + have := hp.dag.child_lt hmn hc; omega)).symm + · rw [setBang_getElem!_self _ _ (by omega), setBang_getElem!_self _ _ (by omega)] + · rw [setBang_getElem!_self _ _ (by omega), setBang_getElem!_self _ _ (by omega)] + · rw [setBang_getElem!_self _ _ (by omega), setBang_getElem!_self _ _ (by omega)] + · have hfb : (p.family[t]! == Family.none) = false := by simpa using hf + simp only [hfb, Bool.false_eq_true, if_false] + have hs := hp.sideChild_lt hmn hf + have hn := hp.snext_lt hmn hf + refine ⟨fun h => absurd h hf, fun _ => ⟨?_, ?_⟩, ?_, ?_⟩ + · rw [setBang_getElem!_self _ _ (by omega), setBang_getElem!_ne _ _ (by omega), + setBang_getElem!_ne (i := t) _ _ (show snext p t ≠ t by omega), + setBang_getElem!_ne (i := t) _ _ (show snext p t ≠ t by omega)] + unfold snext + simp only [beq_iff_eq] + · rw [setBang_getElem!_self _ _ (by omega), setBang_getElem!_self _ _ (by omega)] + · rw [setBang_getElem!_self _ _ (by omega), setBang_getElem!_self _ _ (by omega)] + · rw [setBang_getElem!_self _ _ (by omega), setBang_getElem!_self _ _ (by omega)] + · obtain ⟨k1, k2, _, _⟩ := keep t (by omega) + exact BoundsRow.congr hp (by omega) k1 k2 + (fun c hc => (keep c (by omega)).2.2.1) (fun c hc => (keep c (by omega)).2.2.2) + (hrows t (by omega)) + unfold uniformBounds + rw [foldRange_zero] + exact (hinv p.dag.size (Nat.le_refl _)).2 t ht + +/-- The bytes of `t` as a continuation: `min w M` if `t` is stored, else `M`. -/ +def contVal (p : Prep) (w : Nat) (S : Nat → Bool) (t : Nat) : Nat := + if S t then min w (mergedOf p w S (uCost p w S) t) else mergedOf p w S (uCost p w S) t + +theorem contVal_le (p : Prep) (w : Nat) (S : Nat → Bool) (t : Nat) : + contVal p w S t ≤ mergedOf p w S (uCost p w S) t := by + unfold contVal; split <;> omega + +/-- `M_S(t)` is at least `t`'s own side bytes plus the continuation from the +next spine node (`contVal` if it continues the spine, its standalone cost +otherwise). -/ +theorem PrepWF.merged_ge {p : Prep} (hp : PrepWF p) (w : Nat) (S : Nat → Bool) {t : Nat} + (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) : + sideCost p (uCost p w S) t + + (if p.family[snext p t]! = p.family[t]! then contVal p w S (snext p t) + else uCost p w S (snext p t)) ≤ mergedOf p w S (uCost p w S) t := by + have hlt := hp.snext_lt ht hf + unfold mergedOf + rcases List.mem_cons.mp (foldl_min_mem (mergedCuts p w S (uCost p w S) t) + (prefixSides p (uCost p w S) t p.spineLen[t]! + uCost p w S p.tail[t]!)) with h | h + · rw [h] + rcases hp.spine_step ht hf with ⟨hs, hl, htl⟩ | ⟨hs, hl, htl⟩ + · rw [if_pos hs, hl, htl] + simp only [prefixSides] + have := contVal_le p w S (snext p t) + have := foldl_min_le (mergedCuts p w S (uCost p w S) (snext p t)) + (prefixSides p (uCost p w S) (snext p t) p.spineLen[snext p t]! + + uCost p w S p.tail[snext p t]!) _ List.mem_cons_self + unfold mergedOf at * + omega + · rw [if_neg hs, hl, htl] + simp [prefixSides] + · obtain ⟨j, hj1, hj, hSj, hc⟩ := mem_mergedCuts h + rw [hc] + rcases hp.spine_step ht hf with ⟨hs, hl, htl⟩ | ⟨hs, hl, htl⟩ + · rw [if_pos hs] + obtain ⟨j', rfl⟩ : ∃ j', j = j' + 1 := ⟨j - 1, by omega⟩ + simp only [prefixSides] + by_cases hj' : j' = 0 + · subst hj' + simp only [prefixSides] + have : contVal p w S (snext p t) ≤ w := by + unfold contVal + simp only [spineAt] at hSj + rw [if_pos hSj]; omega + omega + · have hmem := merged_mem_mergedCuts p w S (uCost p w S) (x := snext p t) (j := j') + (by omega) (by omega) (by simpa [spineAt] using hSj) + have := foldl_min_le (mergedCuts p w S (uCost p w S) (snext p t)) + (prefixSides p (uCost p w S) (snext p t) p.spineLen[snext p t]! + + uCost p w S p.tail[snext p t]!) _ (List.mem_cons_of_mem _ hmem) + have := contVal_le p w S (snext p t) + unfold mergedOf at * + omega + · omega + +/-- **Soundness of the bounds.** For every stored set within the +candidates, `uniformBounds` lower-bounds the standalone cost, the inline +cost and the merged continuation of every term. -/ +theorem PrepWF.bounds_sound {p : Prep} (hp : PrepWF p) (w : Nat) (ms : Array Bool) + (S : Nat → Bool) (hS : ∀ y, S y = true → ms[y]! = true) : + ∀ t, t < p.dag.size → + (uniformBounds p w ms).headLB[t]! ≤ uCost p w S t ∧ + (uniformBounds p w ms).inlineLB[t]! ≤ uInl p w S t ∧ + (p.family[t]! ≠ .none → + (uniformBounds p w ms).mergedLB[t]! ≤ mergedOf p w S (uCost p w S) t ∧ + (uniformBounds p w ms).contLB[t]! ≤ contVal p w S t) := by + intro t + induction t using Nat.strongRecOn with + | _ t ih => + intro ht + obtain ⟨r1, r2, r3, r4⟩ := hp.uniformBounds_spec w ms t ht + have hinl : (uniformBounds p w ms).inlineLB[t]! ≤ uInl p w S t ∧ + (p.family[t]! ≠ .none → + (uniformBounds p w ms).mergedLB[t]! ≤ mergedOf p w S (uCost p w S) t) := by + by_cases hf : p.family[t]! = .none + · obtain ⟨a, _⟩ := r1 hf + refine ⟨?_, fun h => absurd hf h⟩ + rw [a] + unfold uInl inlOf + rw [if_pos hf, ← Array.foldl_toList, ← Array.foldl_toList, foldl_add_eq_sum, + foldl_add_eq_sum] + have : ∀ c ∈ (p.dag.node t).children.toList, + (uniformBounds p w ms).headLB[c]! ≤ uCost p w S c := by + intro c hc + have hct := hp.dag.child_lt ht (Array.mem_toList_iff.mp hc) + exact (ih c hct (by omega)).1 + have := sum_le_sum_of_le' this + omega + · obtain ⟨a, b⟩ := r2 hf + have hm : (uniformBounds p w ms).mergedLB[t]! ≤ mergedOf p w S (uCost p w S) t := by + rw [a] + have hge := hp.merged_ge w S ht hf + have hs := hp.sideChild_lt ht hf + have hn := hp.snext_lt ht hf + have hside := (ih _ hs (by omega)).1 + unfold sideCost at hge + by_cases hsame : p.family[snext p t]! = p.family[t]! + · rw [if_pos hsame] at hge ⊢ + have := ((ih _ hn (by omega)).2.2 (by rw [hsame]; exact hf)).2 + omega + · rw [if_neg hsame] at hge ⊢ + have := (ih _ hn (by omega)).1 + omega + refine ⟨?_, fun _ => hm⟩ + rw [b] + have := (inl_merged_bounds p w S (uCost p w S) hf).1 + unfold uInl + omega + refine ⟨?_, hinl.1, fun hf => ⟨hinl.2 hf, ?_⟩⟩ + · rw [r3, hp.uCost_eq w S t ht] + unfold costOf + have := hinl.1 + unfold uInl at this + by_cases hSt : S t = true + · rw [if_pos (hS t hSt), if_pos hSt]; omega + · simp only [hSt, Bool.false_eq_true, if_false] + split <;> omega + · rw [r4] + unfold contVal + have := hinl.2 hf + by_cases hSt : S t = true + · rw [if_pos (hS t hSt), if_pos hSt]; omega + · simp only [hSt, Bool.false_eq_true, if_false] + split <;> omega +where + sum_le_sum_of_le' {f g : Nat → Nat} {l : List Nat} (h : ∀ k ∈ l, f k ≤ g k) : + (l.map f).sum ≤ (l.map g).sum := sum_le_sum_of_le l h + +/-! ## Counting over a whole encoding -/ + +theorem sum_ge_of_covers (f : Nat → Nat) : ∀ (n : Nat) (l : List Nat), (∀ y, y < n → y ∈ l) → + ((List.range n).map f).sum ≤ (l.map f).sum := by + intro n + induction n with + | zero => intro _ _; simp + | succ n ih => + intro l hl + rw [sum_range_succ'] + have hn := hl n (by omega) + have hperm := List.perm_cons_erase hn + rw [(hperm.map f).sum_nat, List.map_cons, List.sum_cons] + have := ih (l.erase n) (fun y hy => (List.mem_erase_of_ne (by omega)).mpr (hl y (by omega))) + omega + +/-- Every term of the DAG is written somewhere in a complete encoding whose +roots reach every term. -/ +theorem PrepWF.encoding_covers {p : Prep} (hp : PrepWF p) {S : List Nat} {entry : Nat → WTree} + {roots : List Nat} {rootsW : List WTree} + (h : EncodingWF p (fun y => decide (y ∈ S)) S entry roots rootsW) + (_hSin : ∀ s ∈ S, s < p.dag.size) (hroots : ∀ r ∈ roots, r < p.dag.size) + (hreach : ∀ y, y < p.dag.size → ∃ r ∈ roots, Ix.Compile.Verify.SharingExact.Desc p.dag r y) : + ∀ y, y < p.dag.size → + y ∈ (rootsW.map (WTree.written p)).flatten ++ (S.map fun s => (entry s).written p).flatten := by + -- terms below a stored term are written by the entries + have hentry : ∀ s, s < p.dag.size → s ∈ S → ∀ y, Ix.Compile.Verify.SharingExact.Desc p.dag s y → + y ∈ (S.map fun s => (entry s).written p).flatten := by + intro s + induction s using Nat.strongRecOn with + | _ s ih => + intro hs hsS y hd + obtain ⟨hv, hns⟩ := h.1 s hsS + rcases hp.cover hv hs y hd with hw | ⟨s', hs', hd'⟩ + · exact List.mem_flatten.mpr ⟨_, List.mem_map.mpr ⟨s, hsS, rfl⟩, hw⟩ + · obtain ⟨hS', hle, hlt⟩ := hp.shares_lt hv hs s' hs' + have hlt' := hlt hns + exact ih s' hlt' (by omega) (by simpa using hS') y hd' + intro y hy + obtain ⟨r, hr, hd⟩ := hreach y hy + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hr + have hlen := (Ix.Compile.Verify.SharingExact.forall₂_getElem h.2).1 + have hv := (Ix.Compile.Verify.SharingExact.forall₂_getElem h.2).2 i hi (by omega) + rcases hp.cover hv (hroots _ hr) y hd with hw | ⟨s, hs, hd'⟩ + · exact List.mem_append_left _ (List.mem_flatten.mpr ⟨_, List.mem_map.mpr + ⟨rootsW[i], List.getElem_mem (by omega), rfl⟩, hw⟩) + · obtain ⟨hS, hle, _⟩ := hp.shares_lt hv (hroots _ hr) s hs + exact List.mem_append_right _ (hentry s (by have := hroots _ hr; omega) (by simpa using hS) y hd') + +theorem subst_isShare {p : Prep} {S : Nat → Bool} {t : Nat} (rh rc : Bool) {x : Nat} {T : WTree} + (h : Valid p S x T) (hs : T.isShare = false) (hxt : x ≠ t) : + (T.subst p t rh rc).isShare = false := by + cases h with + | share => simp [WTree.isShare] at hs + | node => simp [WTree.subst, hxt, WTree.isShare] + | teleCut => + simp only [WTree.subst, hxt, if_false] + split <;> (try split) <;> rfl + | teleFull => + simp only [WTree.subst, hxt, if_false] + split <;> (try split) <;> rfl + +theorem topIs_root {p : Prep} {S : Nat → Bool} {t : Nat} (hSt : S t = false) : + ∀ {roots : List Nat} {rootsW : List WTree}, List.Forall₂ (Valid p S) roots rootsW → + (rootsW.map fun T => if T.topIs t then 1 else 0).sum = roots.count t + | _, _, .nil => rfl + | r :: rs, T :: Ts, .cons hv hs => by + simp only [List.map_cons, List.sum_cons, List.count_cons, topIs_root hSt hs] + by_cases hrt : r = t + · rw [if_pos ((top_iff hSt hv).mpr hrt)]; simp [hrt]; omega + · rw [if_neg (fun h => hrt ((top_iff hSt hv).mp (by simpa using h)))] + simp [hrt] + +theorem forall₂_imp_mem {α β : Type} {R R' : α → β → Prop} : + ∀ {xs : List α} {ys : List β}, List.Forall₂ R xs ys → + (∀ x ∈ xs, ∀ y, R x y → R' x y) → List.Forall₂ R' xs ys + | _, _, .nil, _ => .nil + | _, _, .cons hr hs, h => + .cons (h _ List.mem_cons_self _ hr) + (forall₂_imp_mem hs fun x hx y hxy => h x (List.mem_cons_of_mem _ hx) y hxy) + +theorem forall₂_mem_right' {α β : Type} {R : α → β → Prop} : + ∀ {xs : List α} {ys : List β}, List.Forall₂ R xs ys → ∀ y ∈ ys, ∃ x ∈ xs, R x y + | _, _, .nil => fun _ h => by cases h + | _, _, .cons hr hs => fun y hy => by + rcases List.mem_cons.mp hy with rfl | hy + · exact ⟨_, List.mem_cons_self, hr⟩ + · obtain ⟨x, hx, h'⟩ := forall₂_mem_right' hs y hy + exact ⟨x, List.mem_cons_of_mem _ hx, h'⟩ +/-- **Exchange with the encoding's counts.** For `t ∉ S` and an encoding +`E, R` of `S` that attains its length: adding `t` costs at most its optimal +entry plus the growth of the count's TagN, and saves `inl_S(t) - w` per +head occurrence and `M_S(t) - w` per continuation occurrence of `t` in the +encoding (when positive). -/ +theorem PrepWF.exchange_counts {p : Prep} (hp : PrepWF p) (w : Nat) {S : List Nat} + (hSin : ∀ s ∈ S, s < p.dag.size) (roots : List Nat) (hroots : ∀ r ∈ roots, r < p.dag.size) + {t : Nat} (htn : t < p.dag.size) (htS : t ∉ S) {E : Nat → WTree} {R : List WTree} + (hEnc : EncodingWF p (fun y => decide (y ∈ S)) S E roots R) + (hcost : encodingCost p w S E R = uniformCost p w (fun y => decide (y ∈ S)) S roots) : + let A := fun y => decide (y ∈ S) + let I := uInl p w A t + let M := mergedOf p w A (uCost p w A) t + uniformCost p w (fun y => decide (y ∈ t :: S)) (t :: S) roots + tag0Size S.length + + ((S.map fun s => (E s).occH t).sum + (R.map (WTree.occH t)).sum) * + (if w ≤ I then I - w else 0) + + ((S.map fun s => (E s).occC p t).sum + (R.map (WTree.occC p t)).sum) * + (if w ≤ M then M - w else 0) ≤ + uniformCost p w A S roots + tag0Size (S.length + 1) + I := by + intro A I M + have hSt : A t = false := by simp [A, htS] + have hA' : (fun y => decide (y ∈ t :: S)) = addT A t := by + funext y + simp only [A, addT, List.mem_cons] + by_cases hy : y = t <;> by_cases hyS : y ∈ S <;> simp [hy, hyS] + rw [hA'] + obtain ⟨Tt, hTt, hTts, hTtc⟩ := (hp.exists_opt w A t htn).2 + let rh := decide (w ≤ I) + let rc := decide (w ≤ M) + have hrh : rh = true → w ≤ uInl p w A t := fun h => by simpa [rh] using h + have hrc : rc = true → w ≤ mergedOf p w A (uCost p w A) t := fun h => by simpa [rc] using h + have hAh : (if rh then uInl p w A t - w else 0) = (if w ≤ I then I - w else 0) := by + simp only [rh, decide_eq_true_eq]; rfl + have hAc : (if rc then mergedOf p w A (uCost p w A) t - w else 0) = + (if w ≤ M then M - w else 0) := by + simp only [rc, decide_eq_true_eq]; rfl + generalize (if w ≤ I then I - w else 0) = Ah at hAh ⊢ + generalize (if w ≤ M then M - w else 0) = Ac at hAc ⊢ + let E' : Nat → WTree := fun y => if y = t then Tt else (E y).subst p t rh rc + let R' := R.map (WTree.subst p t rh rc) + -- the substitution facts per writing + have hsubE : ∀ s ∈ S, Valid p (addT A t) s ((E s).subst p t rh rc) ∧ + ((E s).subst p t rh rc).cost p w + (E s).occH t * Ah + (E s).occC p t * Ac ≤ + (E s).cost p w := by + intro s hs + obtain ⟨h1, h2⟩ := hp.subst_spec w hSt htn rh rc hrh hrc (hEnc.1 s hs).1 (hSin s hs) + rw [hAh, hAc] at h2 + exact ⟨h1, h2⟩ + have hsubR : List.Forall₂ (fun r T => Valid p (addT A t) r (T.subst p t rh rc) ∧ + (T.subst p t rh rc).cost p w + T.occH t * Ah + T.occC p t * Ac ≤ T.cost p w) roots R := + forall₂_imp_mem hEnc.2 fun r hr T hv => by + obtain ⟨h1, h2⟩ := hp.subst_spec w hSt htn rh rc hrh hrc hv (hroots r hr) + rw [hAh, hAc] at h2 + exact ⟨h1, h2⟩ + -- the new encoding + have hR' : List.Forall₂ (Valid p (addT A t)) roots R' := by + have : ∀ {xs : List Nat} {ys : List WTree}, List.Forall₂ (fun r T => + Valid p (addT A t) r (T.subst p t rh rc) ∧ + (T.subst p t rh rc).cost p w + T.occH t * Ah + T.occC p t * Ac ≤ T.cost p w) xs ys → + List.Forall₂ (Valid p (addT A t)) xs (ys.map (WTree.subst p t rh rc)) := by + intro xs ys h + induction h with + | nil => exact .nil + | cons h _ ih => exact .cons h.1 ih + exact this hsubR + have hEnc' : EncodingWF p (addT A t) (t :: S) E' roots R' := by + refine ⟨fun y hy => ?_, hR'⟩ + by_cases hyt : y = t + · subst hyt + simp only [E', if_true] + exact ⟨hTt.mono (addT_le A y), hTts⟩ + · have hyS : y ∈ S := by + rcases List.mem_cons.mp hy with h | h + · exact absurd h hyt + · exact h + simp only [E', if_neg hyt] + exact ⟨(hsubE y hyS).1, subst_isShare rh rc (hEnc.1 y hyS).1 (hEnc.1 y hyS).2 hyt⟩ + have hle := hp.uniformCost_le w (addT A t) (fun s hs => by + rcases List.mem_cons.mp hs with rfl | h + · exact htn + · exact hSin s h) hroots hEnc' + unfold encodingCost at hle hcost + -- the new entry costs + have hE' : ((t :: S).map fun s => (E' s).cost p w).sum = + Tt.cost p w + (S.map fun s => ((E s).subst p t rh rc).cost p w).sum := by + simp only [List.map_cons, List.sum_cons, E', if_true] + congr 1 + apply congrArg + apply List.map_congr_left + intro s hs + rw [if_neg (fun h => htS (by rw [← h]; exact hs))] + have hR'c : (R'.map (WTree.cost p w)).sum = (R.map fun T => (T.subst p t rh rc).cost p w).sum := by + simp only [R', List.map_map, Function.comp_def] + -- the savings + have hsumE := sum_ineq (fun s => ((E s).subst p t rh rc).cost p w) (fun s => (E s).occH t) + (fun s => (E s).occC p t) (fun s => (E s).cost p w) Ah Ac S (fun s hs => (hsubE s hs).2) + have hsumR := sum_ineq (fun T => (T.subst p t rh rc).cost p w) (WTree.occH t) (WTree.occC p t) + (WTree.cost p w) Ah Ac R (fun T hT => by + obtain ⟨r, hr⟩ := Ix.Compile.Verify.SharingExact.forall₂_mem_right hsubR T hT + exact hr.2) + have hI : I = uInl p w A t := rfl + have hc' : uniformCost p w (fun y => decide (y ∈ S)) S roots = uniformCost p w A S roots := rfl + rw [hE', hR'c, hTtc] at hle + simp only [List.length_cons] at hle + simp only [Nat.add_mul] + omega + + +/-- **Exchange (lengths).** For `t ∉ S`, adding `t` costs at most its +`S`-optimal entry and the growth of the table count's TagN, and saves `inl_S(t) - w` per head +occurrence and `M_S(t) - w` per continuation occurrence (when positive): the +head occurrences number at least the root occurrences plus the +non-continuation edges into `t`, the continuation occurrences at least the +continuation edges into `t`. -/ +theorem PrepWF.exchange {p : Prep} (hp : PrepWF p) (w : Nat) {S : List Nat} + (hSin : ∀ s ∈ S, s < p.dag.size) (roots : List Nat) (hroots : ∀ r ∈ roots, r < p.dag.size) + (hreach : ∀ y, y < p.dag.size → ∃ r ∈ roots, Ix.Compile.Verify.SharingExact.Desc p.dag r y) + {t : Nat} (htn : t < p.dag.size) (htS : t ∉ S) : + let A := fun y => decide (y ∈ S) + let I := uInl p w A t + let M := mergedOf p w A (uCost p w A) t + uniformCost p w (fun y => decide (y ∈ t :: S)) (t :: S) roots + + (roots.count t + ((List.range p.dag.size).map fun y => edgeMult p y t false).sum) * + (if w ≤ I then I - w else 0) + + ((List.range p.dag.size).map fun y => edgeMult p y t true).sum * + (if w ≤ M then M - w else 0) ≤ + uniformCost p w A S roots + (tag0Size (S.length + 1) - tag0Size S.length) + I := by + intro A I M + have hSt : A t = false := by simp [A, htS] + obtain ⟨E, R, hEnc, hcost⟩ := hp.uniformCost_attained w A S roots hSin hroots + have hx := hp.exchange_counts w hSin roots hroots htn htS hEnc hcost + simp only at hx + -- the occurrence counts + have hocc : ∀ (W : WTree) (x : Nat), Valid p A x W → x < p.dag.size → + W.occH t = (if W.topIs t then 1 else 0) + + ((W.written p).map fun y => edgeMult p y t false).sum ∧ + W.occC p t = ((W.written p).map fun y => edgeMult p y t true).sum := + fun W x hv hx => ⟨(hp.occ_edges hSt htn hv hx).1, (hp.occ_edges hSt htn hv hx).2.1⟩ + have hcov := hp.encoding_covers hEnc hSin hroots hreach + have hflat : ∀ (f : Nat → Nat) (L : List (List Nat)), + (L.flatten.map f).sum = (L.map fun l => (l.map f).sum).sum := by + intro f L + induction L with + | nil => rfl + | cons l ls ih => simp only [List.flatten_cons, List.map_append, List.sum_append, ih, List.map_cons, List.sum_cons] + have hcount : ∀ c : Bool, + ((List.range p.dag.size).map fun y => edgeMult p y t c).sum ≤ + (R.map fun T => ((T.written p).map fun y => edgeMult p y t c).sum).sum + + (S.map fun s => (((E s).written p).map fun y => edgeMult p y t c).sum).sum := by + intro c + have := sum_ge_of_covers (fun y => edgeMult p y t c) p.dag.size _ hcov + rw [List.map_append, List.sum_append, hflat, hflat, List.map_map, List.map_map] at this + simpa [Function.comp_def] using this + have hH : roots.count t + ((List.range p.dag.size).map fun y => edgeMult p y t false).sum ≤ + (S.map fun s => (E s).occH t).sum + (R.map (WTree.occH t)).sum := by + have hRH : (R.map (WTree.occH t)).sum = roots.count t + + (R.map fun T => ((T.written p).map fun y => edgeMult p y t false).sum).sum := by + rw [List.map_congr_left (fun T hT => by + obtain ⟨r, hrm, hr⟩ := forall₂_mem_right' hEnc.2 T hT + exact (hocc T r hr (hroots r hrm)).1), sum_map_add', topIs_root hSt hEnc.2] + have hSH : (S.map fun s => (((E s).written p).map fun y => edgeMult p y t false).sum).sum ≤ + (S.map fun s => (E s).occH t).sum := by + apply sum_le_sum_of_le + intro s hs + rw [(hocc (E s) s (hEnc.1 s hs).1 (hSin s hs)).1] + omega + have := hcount false + omega + have hC : ((List.range p.dag.size).map fun y => edgeMult p y t true).sum ≤ + (S.map fun s => (E s).occC p t).sum + (R.map (WTree.occC p t)).sum := by + have hRC : (R.map (WTree.occC p t)).sum = + (R.map fun T => ((T.written p).map fun y => edgeMult p y t true).sum).sum := by + apply congrArg + apply List.map_congr_left + intro T hT + obtain ⟨r, hrm, hr⟩ := forall₂_mem_right' hEnc.2 T hT + exact (hocc T r hr (hroots r hrm)).2 + have hSC : (S.map fun s => (((E s).written p).map fun y => edgeMult p y t true).sum).sum = + (S.map fun s => (E s).occC p t).sum := by + apply congrArg + apply List.map_congr_left + intro s hs + exact ((hocc (E s) s (hEnc.1 s hs).1 (hSin s hs)).2).symm + have := hcount true + omega + have h0 : tag0Size S.length ≤ tag0Size (S.length + 1) := tag0Size_mono (Nat.le_succ _) + have hHm := Nat.mul_le_mul_right (if w ≤ I then I - w else 0) hH + have hCm := Nat.mul_le_mul_right (if w ≤ M then M - w else 0) hC + simp only [A, I, M] at hHm hCm ⊢ + simp only [Nat.add_mul] at hHm hCm hx ⊢ + omega + +/-! ## The stage-2 inequality -/ + +theorem prod_nonneg_expand (a b c d : _root_.Int) (h1 : b ≤ a) (h2 : d ≤ c) : + a * d + b * c ≤ a * c + b * d := by + have h := _root_.Int.mul_nonneg (_root_.Int.sub_nonneg.mpr h1) (_root_.Int.sub_nonneg.mpr h2) + simp only [_root_.Int.sub_mul, _root_.Int.mul_sub] at h + omega + +theorem mul_pos_part (h a b : Nat) : + (h : _root_.Int) * (a : _root_.Int) - (h : _root_.Int) * (b : _root_.Int) ≤ (h : _root_.Int) * ((if b ≤ a then a - b else 0 : Nat) : _root_.Int) := by + split + · rename_i hle + rw [_root_.Int.ofNat_sub hle, _root_.Int.mul_sub] + exact _root_.Int.le_refl _ + · rename_i hlt + have : (h : _root_.Int) * (a : _root_.Int) ≤ (h : _root_.Int) * (b : _root_.Int) := + _root_.Int.mul_le_mul_of_nonneg_left (by omega) (by omega) + simp only [_root_.Int.ofNat_zero, _root_.Int.mul_zero] + omega + +theorem edgeMult_cont_zero {p : Prep} (hp : PrepWF p) {t : Nat} (ht : t < p.dag.size) + (hf : p.family[t]! = .none) (y : Nat) : edgeMult p y t true = 0 := by + have hft : (p.dag.node t).head.family = .none := by rw [← hp.family t ht]; exact hf + unfold edgeMult + rw [List.length_eq_zero_iff, List.filter_eq_nil_iff] + intro i _ + have : continuationEdge (p.dag.node y) i (p.dag.node t) = false := by + unfold continuationEdge + cases hy : (p.dag.node y).head <;> cases htt : (p.dag.node t).head <;> + simp_all [Head.family] + simp [this] + +/-- **Stage 2: the monotone exchange.** On a well-formed DAG whose roots +reach every term, for a stored set `S` within the candidates `ms` and a +candidate `t ∉ S` with in-degree at least one, +`uniformCost (t :: S) ≤ uniformCost S - storedGain t + (tag0Size (|S| + 1) - tag0Size |S|)` +(the growth of the table count's TagN). -/ +theorem uniformCost_insert_le {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → + ∃ r ∈ roots.toList, Ix.Compile.Verify.SharingExact.Desc dag r y) + (w : Nat) (ms : Array Bool) {S : List Nat} (hSin : ∀ s ∈ S, s < dag.size) + (hSms : ∀ s ∈ S, ms[s]! = true) {t : Nat} (htn : t < dag.size) (htS : t ∉ S) + (hdeg : 1 ≤ (graphFacts dag roots).deg[t]!) : + ((uniformCost (Prep.ofDag dag) w (fun y => decide (y ∈ t :: S)) (t :: S) roots.toList : Nat) : + _root_.Int) ≤ + (uniformCost (Prep.ofDag dag) w (fun y => decide (y ∈ S)) S roots.toList : _root_.Int) - + storedGain (Prep.ofDag dag) (graphFacts dag roots) + (uniformBounds (Prep.ofDag dag) w ms) w t + + ((tag0Size (S.length + 1) : _root_.Int) - tag0Size S.length) := by + have hp := prepWF_ofDag hwf + have h0 : tag0Size S.length ≤ tag0Size (S.length + 1) := tag0Size_mono (Nat.le_succ _) + have hex := hp.exchange w hSin roots.toList hroots hreach htn htS + simp only at hex + -- in-degrees + have hdegE := edgeCounts_spec hwf roots hroots false t + have hheadE := edgeCounts_spec hwf roots hroots true t + simp only [Bool.false_eq_true, if_false, if_true] at hdegE hheadE + rw [sum_map_add'] at hdegE + rw [ofDag_dag] at hex + generalize hHc : roots.toList.count t + + ((List.range dag.size).map fun y => edgeMult (Prep.ofDag dag) y t false).sum = Hc at hex + generalize hCc : ((List.range dag.size).map fun y => edgeMult (Prep.ofDag dag) y t true).sum = Cc + at hex + have hdeg' : (graphFacts dag roots).deg[t]! = Hc + Cc := by + simp only [graphFacts]; rw [hdegE, ← hHc, ← hCc, Nat.add_assoc] + have hhead' : (graphFacts dag roots).headDeg[t]! = Hc := by + simp only [graphFacts]; rw [hheadE, ← hHc] + -- bounds + have hb := hp.bounds_sound w ms (fun y => decide (y ∈ S)) + (fun y hy => hSms y (by simpa using hy)) t (by rw [ofDag_dag]; exact htn) + have hIMb : (Prep.ofDag dag).family[t]! ≠ .none → + 1 + mergedOf (Prep.ofDag dag) w (fun y => decide (y ∈ S)) + (uCost (Prep.ofDag dag) w fun y => decide (y ∈ S)) t ≤ + uInl (Prep.ofDag dag) w (fun y => decide (y ∈ S)) t ∧ + uInl (Prep.ofDag dag) w (fun y => decide (y ∈ S)) t ≤ + tag4Size (Prep.ofDag dag).spineLen[t]! + mergedOf (Prep.ofDag dag) w + (fun y => decide (y ∈ S)) (uCost (Prep.ofDag dag) w fun y => decide (y ∈ S)) t := + fun hf => inl_merged_bounds _ w _ _ hf + generalize uInl (Prep.ofDag dag) w (fun y => decide (y ∈ S)) t = I at hex hb hIMb + generalize mergedOf (Prep.ofDag dag) w (fun y => decide (y ∈ S)) + (uCost (Prep.ofDag dag) w fun y => decide (y ∈ S)) t = M at hex hb hIMb + have hAh := mul_pos_part Hc I w + have hAc := mul_pos_part Cc M w + have hexI := _root_.Int.ofNat_le.mpr hex + simp only [_root_.Int.natCast_add, _root_.Int.natCast_mul] at hexI + unfold storedGain storedGainWith + rw [hdeg', hhead'] + rw [hdeg'] at hdeg + simp only [_root_.Int.ofNat_eq_natCast] + by_cases hf : (Prep.ofDag dag).family[t]! = .none + · -- a non-telescope has no continuation edges into it + have hCc0 : Cc = 0 := by + rw [← hCc] + exact sum_map_eq_zero fun y _ => edgeMult_cont_zero hp (by rw [ofDag_dag]; exact htn) hf y + subst hCc0 + have hfb : ((Prep.ofDag dag).family[t]! == Family.none) = true := by simp [hf] + simp only [hfb, if_true] + have hiLB := hb.2.1 + have e2 := prod_nonneg_expand (Hc : _root_.Int) 1 I + (uniformBounds (Prep.ofDag dag) w ms).inlineLB[t]! (by omega) (by omega) + simp only [_root_.Int.one_mul] at e2 + simp only [Nat.add_zero, _root_.Int.natCast_zero, _root_.Int.zero_mul, _root_.Int.add_zero, + _root_.Int.sub_mul, _root_.Int.one_mul] at hexI hAc hdeg ⊢ + omega + · have hfb : ((Prep.ofDag dag).family[t]! == Family.none) = false := by simpa using hf + simp only [hfb, Bool.false_eq_true, if_false] + have hmLB := (hb.2.2 hf).1 + obtain ⟨hIM1, hIM2⟩ := hIMb hf + by_cases hH : Hc ≥ 1 + · rw [if_pos (by omega)] + have f3 := prod_nonneg_expand (Hc : _root_.Int) 1 I (1 + M) (by omega) (by omega) + have f4 := prod_nonneg_expand ((Hc + Cc : Nat) : _root_.Int) 1 M + (uniformBounds (Prep.ofDag dag) w ms).mergedLB[t]! (by omega) (by omega) + simp only [_root_.Int.one_mul, _root_.Int.mul_add, _root_.Int.mul_one, + _root_.Int.natCast_add, _root_.Int.add_mul, _root_.Int.sub_mul] at f3 f4 ⊢ + omega + · rw [if_neg (by omega)] + have hH0 : Hc = 0 := by omega + subst hH0 + have f5 := prod_nonneg_expand (Cc : _root_.Int) 1 M + (uniformBounds (Prep.ofDag dag) w ms).mergedLB[t]! (by omega) (by omega) + simp only [_root_.Int.one_mul, _root_.Int.natCast_zero, _root_.Int.zero_mul, + Nat.zero_add, _root_.Int.sub_mul] at f5 hAh hexI hdeg ⊢ + omega + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformKnapsack.lean b/Ix/Compile/Verify/UniformKnapsack.lean new file mode 100644 index 000000000..317c64c9f --- /dev/null +++ b/Ix/Compile/Verify/UniformKnapsack.lean @@ -0,0 +1,728 @@ +import Ix.Compile.Verify.UniformSearchSpec + +/-! +# Stage 4: the count knapsack of the uniform optimizer + +The knapsack over the component tables (`knapStep`) and the choice among +its counts (`knapChoose`): every choice of one entry per table within the +count cap is matched by a no-worse combination, and the chosen total is at +most every candidate's. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (setBang_getElem!) + +/-- `foldl_hasAt` under an invariant of the accumulator. -/ +theorem foldl_hasAt_inv {α : Type} (f : CTable → α → CTable) (Inv : CTable → Prop) + (hinv : ∀ acc x, Inv acc → Inv (f acc x)) (hf : ∀ acc x, Improves acc (f acc x)) + {l : List α} {x : α} (hx : x ∈ l) (k : Nat) (v : _root_.Int) (acc : CTable) (hacc : Inv acc) + (hstep : ∀ acc, Inv acc → HasAt (f acc x) k v) : HasAt (l.foldl f acc) k v := by + induction l generalizing acc with + | nil => exact absurd hx List.not_mem_nil + | cons y ys ih => + rw [List.foldl_cons] + rcases List.mem_cons.mp hx with rfl | hx + · exact (hstep acc hacc).mono (foldl_improves f hf ys _) + · exact ih hx _ (hinv acc y hacc) + +/-! ## One knapsack step -/ + +/-- The inner step of `knapStep` for one count `c` with entry `(d, s)`. -/ +def knapIn (cap c : Nat) (d : _root_.Int) (s : Array Nat) (bySize : CTable) (ndp : CTable) (k : Nat) : + CTable := + match bySize[k]! with + | none => ndp + | some (dk, sk) => + if c + k > cap then ndp + else if betterEntry (d + dk, mergeSorted s sk) ndp[c + k]! then + ndp.set! (c + k) (some (d + dk, mergeSorted s sk)) + else ndp + +/-- The outer step of `knapStep` for count `c`. -/ +def knapOut (cap : Nat) (dp : CTable) (bySize : CTable) (ndp : CTable) (c : Nat) : CTable := + match dp[c]! with + | none => ndp + | some (d, s) => (List.range bySize.size).foldl (knapIn cap c d s bySize) ndp + +theorem knapStep_eq (cap : Nat) (dp bySize : CTable) : + knapStep cap dp bySize = + (List.range dp.size).foldl (knapOut cap dp bySize) (Array.replicate (cap + 1) none) := rfl + +theorem knapIn_eq (cap c : Nat) (d : _root_.Int) (s : Array Nat) (bySize ndp : CTable) (k : Nat) : + knapIn cap c d s bySize ndp k = match bySize[k]! with + | none => ndp + | some (dk, sk) => + if c + k > cap then ndp + else if betterEntry (d + dk, mergeSorted s sk) ndp[c + k]! then + ndp.set! (c + k) (some (d + dk, mergeSorted s sk)) + else ndp := rfl + +theorem knapIn_size (cap c : Nat) (d : _root_.Int) (s : Array Nat) (bySize ndp : CTable) (k : Nat) : + (knapIn cap c d s bySize ndp k).size = ndp.size := by + rw [knapIn_eq] + cases bySize[k]! with + | none => rfl + | some e => + obtain ⟨dk, sk⟩ := e + simp only + split + · rfl + · split + · simp [Array.set!] + · rfl + +theorem setBang_improves {ndp : CTable} {j : Nat} {e : Entry} (hb : betterEntry e ndp[j]! = true) : + Improves ndp (ndp.set! j (some e)) := by + intro i x hx + by_cases hij : j = i ∧ j < ndp.size + · obtain ⟨rfl, hj⟩ := hij + refine ⟨e, by rw [setBang_getElem!, if_pos ⟨rfl, hj⟩], ?_⟩ + rw [hx] at hb + simp only [betterEntry, Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq] at hb + omega + · exact ⟨x, by rw [setBang_getElem!, if_neg hij, hx], Int.le_refl _⟩ + +theorem knapIn_improves (cap c : Nat) (d : _root_.Int) (s : Array Nat) (bySize ndp : CTable) (k : Nat) : + Improves ndp (knapIn cap c d s bySize ndp k) := by + rw [knapIn_eq] + cases bySize[k]! with + | none => exact improves_refl _ + | some e => + obtain ⟨dk, sk⟩ := e + simp only + split + · exact improves_refl _ + · split + · rename_i hbet; exact setBang_improves hbet + · exact improves_refl _ + +theorem knapIn_hasAt (cap c : Nat) (d : _root_.Int) (s : Array Nat) (bySize ndp : CTable) (k : Nat) + {dk : _root_.Int} {sk : Array Nat} (hk : bySize[k]! = some (dk, sk)) (hck : c + k ≤ cap) + (hsz : cap < ndp.size) : HasAt (knapIn cap c d s bySize ndp k) (c + k) (d + dk) := by + rw [knapIn_eq, hk] + simp only + rw [if_neg (by omega)] + split + · exact ⟨_, by rw [setBang_getElem!, if_pos ⟨rfl, by omega⟩], Int.le_refl _⟩ + · rename_i hbet + cases ho : ndp[c + k]! with + | none => rw [ho] at hbet; simp [betterEntry] at hbet + | some x => + rw [ho] at hbet + obtain ⟨d0, s0⟩ := x + simp only [betterEntry, Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq, + not_or, not_and] at hbet + exact ⟨(d0, s0), ho, by simp only; omega⟩ + +theorem knapOut_size (cap : Nat) (dp bySize ndp : CTable) (c : Nat) : + (knapOut cap dp bySize ndp c).size = ndp.size := by + unfold knapOut + cases dp[c]! with + | none => rfl + | some e => + obtain ⟨d, s⟩ := e + simp only + generalize List.range bySize.size = l + induction l generalizing ndp with + | nil => rfl + | cons k l ih => rw [List.foldl_cons, ih, knapIn_size] + +theorem knapOut_improves (cap : Nat) (dp bySize ndp : CTable) (c : Nat) : + Improves ndp (knapOut cap dp bySize ndp c) := by + unfold knapOut + cases dp[c]! with + | none => exact improves_refl _ + | some e => + obtain ⟨d, s⟩ := e + exact foldl_improves _ (knapIn_improves cap c d s bySize) _ _ + +theorem knapStep_size (cap : Nat) (dp bySize : CTable) : (knapStep cap dp bySize).size = cap + 1 := by + rw [knapStep_eq] + generalize List.range dp.size = l + suffices h : ∀ (ndp : CTable), (l.foldl (knapOut cap dp bySize) ndp).size = ndp.size by + rw [h]; simp + induction l with + | nil => intro _; rfl + | cons c l ih => intro ndp; rw [List.foldl_cons, ih, knapOut_size] + +/-- **A knapsack step covers every pair** of a count entry and a table entry +within the cap. -/ +theorem knapStep_hasAt {cap : Nat} {dp bySize : CTable} {c k : Nat} {e ek : Entry} + (hc : dp[c]! = some e) (hk : bySize[k]! = some ek) (hck : c + k ≤ cap) : + HasAt (knapStep cap dp bySize) (c + k) (e.1 + ek.1) := by + rw [knapStep_eq] + have hcl : c < dp.size := Classical.byContradiction fun h => by + simp [show ¬ c < dp.size from h] at hc + have hkl : k < bySize.size := Classical.byContradiction fun h => by + simp [show ¬ k < bySize.size from h] at hk + have hsizes : ∀ (l : List Nat) (ndp : CTable), (l.foldl (knapOut cap dp bySize) ndp).size = ndp.size := by + intro l; induction l with + | nil => intro _; rfl + | cons c l ih => intro ndp; rw [List.foldl_cons, ih, knapOut_size] + refine foldl_hasAt_inv _ (fun t => cap < t.size) + (fun acc c' h => by rw [knapOut_size]; exact h) (knapOut_improves cap dp bySize) + (List.mem_range.mpr hcl) (c + k) (e.1 + ek.1) _ (by simp) ?_ + intro acc hacc + unfold knapOut + rw [hc] + obtain ⟨d, s⟩ := e + obtain ⟨dk, sk⟩ := ek + simp only + refine foldl_hasAt_inv _ (fun t => cap < t.size) + (fun acc k' h => by rw [knapIn_size]; exact h) (knapIn_improves cap c d s bySize) + (List.mem_range.mpr hkl) (c + k) (d + dk) _ hacc ?_ + intro acc' hacc' + exact knapIn_hasAt cap c d s bySize acc' k hk hck hacc' + +/-- Entries at their counts (the sets have the count's size). -/ +def Indexed (tb : CTable) : Prop := ∀ (k : Nat) (e : Entry), tb[k]! = some e → e.2.size = k + +theorem knapIn_indexed {cap c : Nat} {d : _root_.Int} {s : Array Nat} {bySize ndp : CTable} + (hs : s.size = c) (hb : Indexed bySize) (hn : Indexed ndp) (k : Nat) : + Indexed (knapIn cap c d s bySize ndp k) := by + rw [knapIn_eq] + cases hbk : bySize[k]! with + | none => exact hn + | some ek => + obtain ⟨dk, sk⟩ := ek + have hsk := hb k _ hbk + simp only + split + · exact hn + · split + · intro j x hx + rw [setBang_getElem!] at hx + split at hx + · rename_i hj + cases hx + rw [← hj.1, mergeSorted_size, hs] + simp only at hsk + omega + · exact hn j x hx + · exact hn + +theorem knapStep_indexed {cap : Nat} {dp bySize : CTable} (hd : Indexed dp) (hb : Indexed bySize) : + Indexed (knapStep cap dp bySize) := by + rw [knapStep_eq] + suffices h : ∀ (l : List Nat) (ndp : CTable), Indexed ndp → + Indexed (l.foldl (knapOut cap dp bySize) ndp) from h _ _ (fun k e he => by + by_cases hk : k < cap + 1 + · rw [getElem!_pos _ k (by simpa using hk)] at he; simp at he + · simp [hk] at he) + intro l + induction l with + | nil => intro _ h; exact h + | cons c l ih => + intro ndp hn + rw [List.foldl_cons] + apply ih + unfold knapOut + cases hdc : dp[c]! with + | none => exact hn + | some e => + obtain ⟨d, s⟩ := e + have hs := hd c _ hdc + simp only at hs ⊢ + generalize List.range bySize.size = l' + induction l' generalizing ndp with + | nil => exact hn + | cons k l' ih' => + rw [List.foldl_cons] + exact ih' _ (knapIn_indexed hs hb hn k) +/-- **The knapsack covers every choice** of one entry per table within the +cap. -/ +theorem knapFold_hasAt {cap : Nat} (ts : List CTable) : + ∀ (ks : List Nat) (vs : List _root_.Int) (dp : CTable) (c0 : Nat) (v0 : _root_.Int), + ks.length = ts.length → vs.length = ts.length → + (∀ j, j < ts.length → HasAt ts[j]! ks[j]! vs[j]!) → + HasAt dp c0 v0 → c0 + ks.sum ≤ cap → + HasAt (ts.foldl (knapStep cap) dp) (c0 + ks.sum) (v0 + vs.sum) := by + induction ts with + | nil => + intro ks vs dp c0 v0 hk hv _ hdp _ + have h1 : ks = [] := List.eq_nil_of_length_eq_zero (by simpa using hk) + have h2 : vs = [] := List.eq_nil_of_length_eq_zero (by simpa using hv) + subst h1; subst h2 + simpa using hdp + | cons t ts ih => + intro ks vs dp c0 v0 hk hv hall hdp hcap + cases ks with + | nil => simp at hk + | cons k ks => + cases vs with + | nil => simp at hv + | cons v vs => + simp only [List.length_cons, Nat.add_right_cancel_iff] at hk hv + simp only [List.sum_cons] at hcap ⊢ + rw [List.foldl_cons] + obtain ⟨e, he, hev⟩ := hdp + obtain ⟨ek, hek, hekv⟩ := hall 0 (by simp) + simp only [List.getElem!_cons_zero] at hek hekv + have hstep := knapStep_hasAt (cap := cap) he hek (by omega) + have := ih ks vs (knapStep cap dp t) (c0 + k) (v0 + v) hk hv + (fun j hj => by simpa using hall (j + 1) (by simp; omega)) + (hstep.weaken (by omega)) (by omega) + rw [show c0 + (k + ks.sum) = c0 + k + ks.sum by omega, + show v0 + (v + vs.sum) = v0 + v + vs.sum by omega] + exact this + +/-! ## The choice among the counts -/ + +/-- The length a choice stands for: its `Δ` and its count's TagN. -/ +def knapTotal (kCS : Nat) (acc : _root_.Int × Array Nat × Bool) : _root_.Int := + acc.1 + (tag0Size (kCS + acc.2.1.size) : _root_.Int) + +/-- **The chosen total is at most every candidate's.** -/ +theorem knapChoose_le (kCS : Nat) {dp : CTable} (hd : Indexed dp) (init : _root_.Int × Array Nat × Bool) : + knapTotal kCS (knapChoose kCS dp init) ≤ knapTotal kCS init ∧ + ∀ c e, dp[c]! = some e → knapTotal kCS (knapChoose kCS dp init) ≤ + e.1 + (tag0Size (kCS + c) : _root_.Int) := by + unfold knapChoose + have key : ∀ (l : List Nat) (acc : _root_.Int × Array Nat × Bool), + let r := l.foldl (fun (acc : _root_.Int × Array Nat × Bool) c => + match dp[c]! with + | none => acc + | some (d, s) => + let l : _root_.Int := d + (tag0Size (kCS + c) : _root_.Int) + let l0 : _root_.Int := acc.1 + (tag0Size (kCS + acc.2.1.size) : _root_.Int) + if l < l0 || (l == l0 && setPrec s acc.2.1) then (d, s, true) else acc) acc + knapTotal kCS r ≤ knapTotal kCS acc ∧ + ∀ c ∈ l, ∀ e, dp[c]! = some e → knapTotal kCS r ≤ e.1 + (tag0Size (kCS + c) : _root_.Int) := by + intro l + induction l with + | nil => intro acc; exact ⟨Int.le_refl _, fun c hc => absurd hc List.not_mem_nil⟩ + | cons c l ih => + intro acc + simp only [List.foldl_cons] + generalize hstep : (match dp[c]! with + | none => acc + | some (d, s) => + if d + (tag0Size (kCS + c) : _root_.Int) < acc.1 + (tag0Size (kCS + acc.2.1.size) : _root_.Int) || + (d + (tag0Size (kCS + c) : _root_.Int) == acc.1 + (tag0Size (kCS + acc.2.1.size) : _root_.Int) && + setPrec s acc.2.1) then (d, s, true) else acc) = acc' + obtain ⟨h1, h2⟩ := ih acc' + have hle : knapTotal kCS acc' ≤ knapTotal kCS acc ∧ + ∀ e, dp[c]! = some e → knapTotal kCS acc' ≤ e.1 + (tag0Size (kCS + c) : _root_.Int) := by + rw [← hstep] + cases hdc : dp[c]! with + | none => exact ⟨Int.le_refl _, fun e he => by cases he⟩ + | some e => + obtain ⟨d, s⟩ := e + have hs := hd c _ hdc + simp only at hs ⊢ + split + · rename_i hlt + simp only [Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq] at hlt + refine ⟨?_, fun e he => ?_⟩ + · unfold knapTotal; simp only; rw [hs]; unfold knapTotal at *; omega + · cases he; unfold knapTotal; simp only; rw [hs]; exact Int.le_refl _ + · rename_i hlt + simp only [Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq, not_or, + not_and] at hlt + refine ⟨Int.le_refl _, fun e he => ?_⟩ + cases he + unfold knapTotal; simp only; omega + refine ⟨Int.le_trans h1 hle.1, fun c' hc' e he => ?_⟩ + rcases List.mem_cons.mp hc' with rfl | hc' + · exact Int.le_trans h1 (hle.2 e he) + · exact h2 c' hc' e he + obtain ⟨h1, h2⟩ := key (List.range dp.size) init + refine ⟨h1, fun c e he => ?_⟩ + have hc : c < dp.size := Classical.byContradiction fun h => by + simp [show ¬ c < dp.size from h] at he + exact h2 c (List.mem_range.mpr hc) e he + +/-! ## The knapsack with the tie order -/ + +/-- Every entry's set lies in `U`. -/ +def SetsIn (tb : CTable) (U : Nat → Prop) : Prop := ∀ (k : Nat) (e : Entry), tb[k]! = some e → ∀ x ∈ e.2.toList, U x + +theorem knapIn_tie {cap c : Nat} {d : _root_.Int} {s : Array Nat} {bySize ndp : CTable} (k : Nat) + (hs : s.toList.Pairwise (· < ·)) (hb : SortedT bySize) + (hd : ∀ (k' : Nat) (e : Entry), bySize[k']! = some e → ∀ x ∈ s.toList, x ∉ e.2.toList) + (hn : SortedT ndp) : + SortedT (knapIn cap c d s bySize ndp k) ∧ ImprovesT ndp (knapIn cap c d s bySize ndp k) := by + rw [knapIn_eq] + cases hbk : bySize[k]! with + | none => exact ⟨hn, improvesT_refl _⟩ + | some ek => + obtain ⟨dk, sk⟩ := ek + have hm := mergeSorted_strict hs (hb k _ hbk) (hd k _ hbk) + simp only + split + · exact ⟨hn, improvesT_refl _⟩ + · split + · rename_i hbet + refine ⟨fun j x hx => ?_, ?_⟩ + · rw [setBang_getElem!] at hx + split at hx + · cases hx; exact hm + · exact hn j x hx + · intro j x hx + by_cases hij : c + k = j ∧ c + k < ndp.size + · obtain ⟨rfl, hj⟩ := hij + refine ⟨_, by rw [setBang_getElem!, if_pos ⟨rfl, hj⟩], ?_⟩ + rw [hx] at hbet + exact (better_tle hm (hn _ x hx)).1 hbet + · exact ⟨x, by rw [setBang_getElem!, if_neg hij, hx], tle_refl x⟩ + · exact ⟨hn, improvesT_refl _⟩ + +theorem knapIn_hasAtT {cap c : Nat} {d : _root_.Int} {s : Array Nat} {bySize ndp : CTable} {k : Nat} + {dk : _root_.Int} {sk : Array Nat} (hk : bySize[k]! = some (dk, sk)) (hck : c + k ≤ cap) + (hsz : cap < ndp.size) (hn : SortedT ndp) (hm : (mergeSorted s sk).toList.Pairwise (· < ·)) : + HasAtT (knapIn cap c d s bySize ndp k) (c + k) (d + dk) (mergeSorted s sk).toList := by + rw [knapIn_eq, hk] + simp only + rw [if_neg (by omega)] + split + · exact ⟨_, by rw [setBang_getElem!, if_pos ⟨rfl, by omega⟩], Or.inr ⟨rfl, leL_refl _⟩⟩ + · rename_i hbet + cases ho : ndp[c + k]! with + | none => rw [ho] at hbet; simp [betterEntry] at hbet + | some x => + rw [ho] at hbet + have := (better_tle hm (hn _ x ho)).2 (by simpa using hbet) + exact ⟨x, ho, tle_good this (Or.inr ⟨rfl, leL_refl _⟩)⟩ + +/-- **A knapsack step with the tie order.** -/ +theorem knapStep_tie {cap : Nat} {dp bySize : CTable} (hdp : SortedT dp) (hb : SortedT bySize) + (hd : ∀ (c : Nat) (e : Entry), dp[c]! = some e → ∀ (k : Nat) (ek : Entry), bySize[k]! = some ek → + ∀ x ∈ e.2.toList, x ∉ ek.2.toList) : + SortedT (knapStep cap dp bySize) ∧ + ∀ {c k : Nat} {e ek : Entry}, dp[c]! = some e → bySize[k]! = some ek → c + k ≤ cap → + HasAtT (knapStep cap dp bySize) (c + k) (e.1 + ek.1) (mergeSorted e.2 ek.2).toList := by + rw [knapStep_eq] + have hsorted0 : SortedT (Array.replicate (cap + 1) (none : Option Entry)) := fun k e he => by + by_cases hk : k < cap + 1 + · rw [getElem!_pos _ k (by simpa using hk)] at he; simp at he + · simp [hk] at he + -- the outer step + have hout : ∀ acc (c : Nat), SortedT acc → SortedT (knapOut cap dp bySize acc c) ∧ + ImprovesT acc (knapOut cap dp bySize acc c) := by + intro acc c hacc + unfold knapOut + cases hdc : dp[c]! with + | none => exact ⟨hacc, improvesT_refl _⟩ + | some e => + obtain ⟨d, s⟩ := e + simp only + have hs := hdp c _ hdc + have key : ∀ (l : List Nat) acc, SortedT acc → + SortedT (l.foldl (knapIn cap c d s bySize) acc) ∧ + ImprovesT acc (l.foldl (knapIn cap c d s bySize) acc) := by + intro l + induction l with + | nil => intro acc h; exact ⟨h, improvesT_refl _⟩ + | cons k l ih => + intro acc h + rw [List.foldl_cons] + obtain ⟨h1, h2⟩ := knapIn_tie k hs hb (fun k' e he x hx => hd c _ hdc k' e he x hx) h + obtain ⟨h3, h4⟩ := ih _ h1 + exact ⟨h3, improvesT_trans h2 h4⟩ + exact key _ acc hacc + have houter : ∀ (l : List Nat) acc, SortedT acc → + SortedT (l.foldl (knapOut cap dp bySize) acc) ∧ ImprovesT acc (l.foldl (knapOut cap dp bySize) acc) := by + intro l + induction l with + | nil => intro acc h; exact ⟨h, improvesT_refl _⟩ + | cons c l ih => + intro acc h + rw [List.foldl_cons] + obtain ⟨h1, h2⟩ := hout acc c h + obtain ⟨h3, h4⟩ := ih _ h1 + exact ⟨h3, improvesT_trans h2 h4⟩ + refine ⟨(houter _ _ hsorted0).1, fun {c k e ek} hc hk hck => ?_⟩ + have hcl : c < dp.size := Classical.byContradiction fun h => by + simp [show ¬ c < dp.size from h] at hc + have hkl : k < bySize.size := Classical.byContradiction fun h => by + simp [show ¬ k < bySize.size from h] at hk + refine foldl_hasAtT_inv _ (fun t => cap < t.size ∧ SortedT t) + (fun acc c' h => ⟨by rw [knapOut_size]; exact h.1, (hout acc c' h.2).1⟩) + (fun acc c' h => (hout acc c' h.2).2) (List.mem_range.mpr hcl) (c + k) (e.1 + ek.1) _ _ + ⟨by simp, hsorted0⟩ ?_ + intro acc hacc + unfold knapOut + rw [hc] + obtain ⟨d, s⟩ := e + obtain ⟨dk, sk⟩ := ek + simp only + have hs := hdp c _ hc + refine foldl_hasAtT_inv _ (fun t => cap < t.size ∧ SortedT t) + (fun acc k' h => ⟨by rw [knapIn_size]; exact h.1, + (knapIn_tie k' hs hb (fun k'' e he x hx => hd c _ hc k'' e he x hx) h.2).1⟩) + (fun acc k' h => (knapIn_tie k' hs hb (fun k'' e he x hx => hd c _ hc k'' e he x hx) h.2).2) + (List.mem_range.mpr hkl) (c + k) (d + dk) _ _ hacc ?_ + intro acc' hacc' + exact knapIn_hasAtT hk hck hacc'.1 hacc'.2 + (mergeSorted_strict hs (hb k _ hk) (hd c _ hc k _ hk)) + +/-- Every entry of a knapsack step merges an entry of each side. -/ +theorem knapStep_origin {cap : Nat} {dp bySize : CTable} : + ∀ (j : Nat) (e : Entry), (knapStep cap dp bySize)[j]! = some e → + ∃ (c k : Nat) (ec ek : Entry), dp[c]! = some ec ∧ bySize[k]! = some ek ∧ + e.2 = mergeSorted ec.2 ek.2 := by + rw [knapStep_eq] + let P : CTable → Prop := fun t => ∀ (j : Nat) (e : Entry), t[j]! = some e → + ∃ (c k : Nat) (ec ek : Entry), dp[c]! = some ec ∧ bySize[k]! = some ek ∧ e.2 = mergeSorted ec.2 ek.2 + have h0 : P (Array.replicate (cap + 1) none) := fun j e he => by + by_cases hk : j < cap + 1 + · rw [getElem!_pos _ j (by simpa using hk)] at he; simp at he + · simp [hk] at he + have hin : ∀ (c : Nat) (d : _root_.Int) (s : Array Nat), dp[c]! = some (d, s) → ∀ acc k, + P acc → P (knapIn cap c d s bySize acc k) := by + intro c d s hdc acc k hacc + rw [knapIn_eq] + cases hbk : bySize[k]! with + | none => exact hacc + | some ek => + obtain ⟨dk, sk⟩ := ek + simp only + split + · exact hacc + · split + · intro j x hx + rw [setBang_getElem!] at hx + split at hx + · cases hx; exact ⟨c, k, _, _, hdc, hbk, rfl⟩ + · exact hacc j x hx + · exact hacc + have hout : ∀ acc c, P acc → P (knapOut cap dp bySize acc c) := by + intro acc c hacc + unfold knapOut + cases hdc : dp[c]! with + | none => exact hacc + | some e => + obtain ⟨d, s⟩ := e + simp only + generalize List.range bySize.size = l + induction l generalizing acc with + | nil => exact hacc + | cons k l ih => rw [List.foldl_cons]; exact ih _ (hin c d s hdc acc k hacc) + generalize List.range dp.size = l + suffices h : ∀ acc, P acc → P (l.foldl (knapOut cap dp bySize) acc) from h _ h0 + induction l with + | nil => intro acc h; exact h + | cons c l ih => intro acc h; rw [List.foldl_cons]; exact ih _ (hout acc c h) + +/-- **The knapsack covers every choice with the tie order**, for tables on +disjoint universes. -/ +theorem knapFold_tie {cap : Nat} (Uf : Nat → Nat → Prop) + (hU : ∀ i i' x, i ≠ i' → Uf i x → ¬ Uf i' x) (ts : List CTable) : + ∀ (j0 : Nat) (ks : List Nat) (vs : List _root_.Int) (Ss : List (List Nat)) (dp : CTable) + (c0 : Nat) (v0 : _root_.Int) (S0 : List Nat), + ks.length = ts.length → vs.length = ts.length → Ss.length = ts.length → + (∀ j, j < ts.length → SortedT ts[j]! ∧ SetsIn ts[j]! (Uf (j0 + j)) ∧ + HasAtT ts[j]! ks[j]! vs[j]! Ss[j]! ∧ ∀ x ∈ Ss[j]!, Uf (j0 + j) x) → + SortedT dp → SetsIn dp (fun x => ∃ i, i < j0 ∧ Uf i x) → HasAtT dp c0 v0 S0 → + (∀ x ∈ S0, ∃ i, i < j0 ∧ Uf i x) → c0 + ks.sum ≤ cap → cap < dp.size → + HasAtT (ts.foldl (knapStep cap) dp) (c0 + ks.sum) (v0 + vs.sum) (S0 ++ Ss.flatten) := by + induction ts with + | nil => + intro j0 ks vs Ss dp c0 v0 S0 hk hv hS _ _ _ hdp _ _ _ + have h1 : ks = [] := List.eq_nil_of_length_eq_zero (by simpa using hk) + have h2 : vs = [] := List.eq_nil_of_length_eq_zero (by simpa using hv) + have h3 : Ss = [] := List.eq_nil_of_length_eq_zero (by simpa using hS) + subst h1; subst h2; subst h3 + simpa using hdp + | cons t ts ih => + intro j0 ks vs Ss dp c0 v0 S0 hk hv hS hall hdps hdpU hdp hS0 hcap hsz + cases ks with + | nil => simp at hk + | cons k ks => + cases vs with + | nil => simp at hv + | cons v vs => + cases Ss with + | nil => simp at hS + | cons S Ss => + simp only [List.length_cons, Nat.add_right_cancel_iff] at hk hv hS + simp only [List.sum_cons, List.flatten_cons] at hcap ⊢ + rw [List.foldl_cons] + obtain ⟨hts, htU, htH, hSU⟩ := hall 0 (by simp) + simp only [List.getElem!_cons_zero, Nat.add_zero] at hts htU htH hSU + -- disjointness of the two sides + have hdisj : ∀ (c : Nat) (e : Entry), dp[c]! = some e → ∀ (k' : Nat) (ek : Entry), + t[k']! = some ek → ∀ x ∈ e.2.toList, x ∉ ek.2.toList := by + intro c e he k' ek hek x hx hx' + obtain ⟨i, hi, hxi⟩ := hdpU c e he x hx + exact hU i j0 x (by omega) hxi (htU k' ek hek x hx') + obtain ⟨hstepS, hstepH⟩ := knapStep_tie (cap := cap) hdps hts hdisj + obtain ⟨e, he, hev⟩ := hdp + obtain ⟨ek, hek, hekv⟩ := htH + have hnew := hstepH he hek (by omega) + -- compose the two tie conditions + have hcomp : (e.1 + ek.1 < v0 + v) ∨ (e.1 + ek.1 = v0 + v ∧ + LeL (mergeSorted e.2 ek.2).toList (S0 ++ S)) := by + rcases hev with h1 | ⟨h1, h1'⟩ <;> rcases hekv with h2 | ⟨h2, h2'⟩ + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · refine Or.inr ⟨by omega, ?_⟩ + apply precL_union (X1 := e.2.toList) (Y1 := S0) (X2 := ek.2.toList) (Y2 := S) + · intro a ha hb + have ha' : ∃ i, i < j0 ∧ Uf i a := by + rcases ha with ha | ha + · exact hdpU _ e he a ha + · exact hS0 a ha + have hb' : Uf j0 a := by + rcases hb with hb | hb + · exact htU _ ek hek a hb + · exact hSU a hb + obtain ⟨i, hi, hia⟩ := ha' + exact hU i j0 a (by omega) hia hb' + · intro u; rw [(mergeSorted_perm e.2 ek.2).mem_iff, List.mem_append] + · intro u; rw [List.mem_append] + · exact h1' + · exact h2' + have := ih (j0 + 1) ks vs Ss (knapStep cap dp t) (c0 + k) (v0 + v) (S0 ++ S) hk hv hS + (fun j hj => by + have := hall (j + 1) (by simp; omega) + simp only [List.getElem!_cons_succ] at this + rw [show j0 + 1 + j = j0 + (j + 1) by omega] + exact this) + hstepS + (fun c e' he' x hx => by + obtain ⟨c1, k1, ec, ek', hec, hek', hset⟩ := knapStep_origin c e' he' + rw [hset] at hx + rcases List.mem_append.mp ((mergeSorted_perm ec.2 ek'.2).mem_iff.mp hx) with h | h + · obtain ⟨i, hi, hxi⟩ := hdpU c1 ec hec x h + exact ⟨i, by omega, hxi⟩ + · exact ⟨j0, by omega, htU k1 ek' hek' x h⟩) + (hnew.weakenT hcomp) + (fun x hx => by + rcases List.mem_append.mp hx with h | h + · obtain ⟨i, hi, hxi⟩ := hS0 x h + exact ⟨i, by omega, hxi⟩ + · exact ⟨j0, by omega, hSU x h⟩) + (by omega) (by rw [knapStep_size]; omega) + rw [show c0 + (k + ks.sum) = c0 + k + ks.sum by omega, + show v0 + (v + vs.sum) = v0 + v + vs.sum by omega, ← List.append_assoc] + exact this + +/-- A total and set at least as good as another. -/ +def CLe (t1 : _root_.Int) (s1 : List Nat) (t2 : _root_.Int) (s2 : List Nat) : Prop := + t1 < t2 ∨ (t1 = t2 ∧ LeL s1 s2) + +theorem cle_trans {t1 t2 t3 : _root_.Int} {s1 s2 s3 : List Nat} (h1 : CLe t1 s1 t2 s2) + (h2 : CLe t2 s2 t3 s3) : CLe t1 s1 t3 s3 := by + rcases h1 with h1 | ⟨h1, h1'⟩ <;> rcases h2 with h2 | ⟨h2, h2'⟩ + · exact Or.inl (Int.lt_trans h1 h2) + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inr ⟨by omega, leL_trans h1' h2'⟩ + +theorem cle_refl (t : _root_.Int) (s : List Nat) : CLe t s t s := Or.inr ⟨rfl, leL_refl _⟩ + +/-- **The chosen total and set are at least as good as every candidate's.** -/ +theorem knapChoose_tie (kCS : Nat) {dp : CTable} (hd : Indexed dp) (hs : SortedT dp) + (init : _root_.Int × Array Nat × Bool) (hinit : init.2.1.toList.Pairwise (· < ·)) : + CLe (knapTotal kCS (knapChoose kCS dp init)) (knapChoose kCS dp init).2.1.toList + (knapTotal kCS init) init.2.1.toList ∧ + ∀ c e, dp[c]! = some e → CLe (knapTotal kCS (knapChoose kCS dp init)) + (knapChoose kCS dp init).2.1.toList (e.1 + (tag0Size (kCS + c) : _root_.Int)) e.2.toList := by + unfold knapChoose + have key : ∀ (l : List Nat) (acc : _root_.Int × Array Nat × Bool), acc.2.1.toList.Pairwise (· < ·) → + let r := l.foldl (fun (acc : _root_.Int × Array Nat × Bool) c => + match dp[c]! with + | none => acc + | some (d, s) => + let l : _root_.Int := d + (tag0Size (kCS + c) : _root_.Int) + let l0 : _root_.Int := acc.1 + (tag0Size (kCS + acc.2.1.size) : _root_.Int) + if l < l0 || (l == l0 && setPrec s acc.2.1) then (d, s, true) else acc) acc + CLe (knapTotal kCS r) r.2.1.toList (knapTotal kCS acc) acc.2.1.toList ∧ + ∀ c ∈ l, ∀ e, dp[c]! = some e → CLe (knapTotal kCS r) r.2.1.toList + (e.1 + (tag0Size (kCS + c) : _root_.Int)) e.2.toList := by + intro l + induction l with + | nil => intro acc _; exact ⟨cle_refl _ _, fun c hc => absurd hc List.not_mem_nil⟩ + | cons c l ih => + intro acc hacc + simp only [List.foldl_cons] + generalize hstep : (match dp[c]! with + | none => acc + | some (d, s) => + if d + (tag0Size (kCS + c) : _root_.Int) < acc.1 + (tag0Size (kCS + acc.2.1.size) : _root_.Int) || + (d + (tag0Size (kCS + c) : _root_.Int) == acc.1 + (tag0Size (kCS + acc.2.1.size) : _root_.Int) && + setPrec s acc.2.1) then (d, s, true) else acc) = acc' + have hstepP : acc'.2.1.toList.Pairwise (· < ·) ∧ + CLe (knapTotal kCS acc') acc'.2.1.toList (knapTotal kCS acc) acc.2.1.toList ∧ + ∀ e, dp[c]! = some e → CLe (knapTotal kCS acc') acc'.2.1.toList + (e.1 + (tag0Size (kCS + c) : _root_.Int)) e.2.toList := by + rw [← hstep] + cases hdc : dp[c]! with + | none => exact ⟨hacc, cle_refl _ _, fun e he => by cases he⟩ + | some e => + obtain ⟨d, s⟩ := e + have hsz := hd c _ hdc + have hss := hs c _ hdc + simp only at hsz hss ⊢ + split + · rename_i hlt + simp only [Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq] at hlt + refine ⟨hss, ?_, fun e he => ?_⟩ + · unfold knapTotal; simp only; rw [hsz] + rcases hlt with h | ⟨h, h'⟩ + · exact Or.inl (by unfold knapTotal at *; omega) + · exact Or.inr ⟨by unfold knapTotal at *; omega, Or.inr ((setPrec_iff hss hacc).mp h')⟩ + · cases he; unfold knapTotal; simp only; rw [hsz]; exact cle_refl _ _ + · rename_i hlt + simp only [Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq, not_or, + not_and] at hlt + refine ⟨hacc, cle_refl _ _, fun e he => ?_⟩ + cases he + unfold knapTotal; simp only + by_cases heq : d + (tag0Size (kCS + c) : _root_.Int) = + acc.1 + (tag0Size (kCS + acc.2.1.size) : _root_.Int) + · have hns := hlt.2 heq + refine Or.inr ⟨by omega, ?_⟩ + rcases leL_total hacc hss with h | h + · exact h + · exact absurd ((setPrec_iff hss hacc).mpr h) (by simp [hns]) + · exact Or.inl (by omega) + obtain ⟨hP, h1, h2⟩ := hstepP + obtain ⟨r1, r2⟩ := ih acc' hP + refine ⟨cle_trans r1 h1, fun c' hc' e he => ?_⟩ + rcases List.mem_cons.mp hc' with rfl | hc' + · exact cle_trans r1 (h2 e he) + · exact r2 c' hc' e he + obtain ⟨h1, h2⟩ := key (List.range dp.size) init hinit + refine ⟨h1, fun c e he => ?_⟩ + have hc : c < dp.size := Classical.byContradiction fun h => by + simp [show ¬ c < dp.size from h] at he + exact h2 c (List.mem_range.mpr hc) e he + +/-- The knapsack keeps strictly increasing sets in the processed universes. -/ +theorem knapFold_sorted {cap : Nat} (Uf : Nat → Nat → Prop) + (hU : ∀ i i' x, i ≠ i' → Uf i x → ¬ Uf i' x) (ts : List CTable) : + ∀ (j0 : Nat) (dp : CTable), + (∀ j, j < ts.length → SortedT ts[j]! ∧ SetsIn ts[j]! (Uf (j0 + j))) → + SortedT dp → SetsIn dp (fun x => ∃ i, i < j0 ∧ Uf i x) → + SortedT (ts.foldl (knapStep cap) dp) := by + induction ts with + | nil => intro _ dp _ h _; exact h + | cons t ts ih => + intro j0 dp hall hdps hdpU + rw [List.foldl_cons] + obtain ⟨hts, htU⟩ := hall 0 (by simp) + simp only [List.getElem!_cons_zero, Nat.add_zero] at hts htU + have hdisj : ∀ (c : Nat) (e : Entry), dp[c]! = some e → ∀ (k' : Nat) (ek : Entry), + t[k']! = some ek → ∀ x ∈ e.2.toList, x ∉ ek.2.toList := by + intro c e he k' ek hek x hx hx' + obtain ⟨i, hi, hxi⟩ := hdpU c e he x hx + exact hU i j0 x (by omega) hxi (htU k' ek hek x hx') + apply ih (j0 + 1) _ (fun j hj => by + have := hall (j + 1) (by simp; omega) + simp only [List.getElem!_cons_succ] at this + rw [show j0 + 1 + j = j0 + (j + 1) by omega] + exact this) (knapStep_tie hdps hts hdisj).1 + intro c e' he' x hx + obtain ⟨c1, k1, ec, ek', hec, hek', hset⟩ := knapStep_origin c e' he' + rw [hset] at hx + rcases List.mem_append.mp ((mergeSorted_perm ec.2 ek'.2).mem_iff.mp hx) with h | h + · obtain ⟨i, hi, hxi⟩ := hdpU c1 ec hec x h + exact ⟨i, by omega, hxi⟩ + · exact ⟨j0, by omega, htU k1 ek' hek' x h⟩ + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformLength.lean b/Ix/Compile/Verify/UniformLength.lean new file mode 100644 index 000000000..e9b7b4314 --- /dev/null +++ b/Ix/Compile/Verify/UniformLength.lean @@ -0,0 +1,590 @@ +import Ix.Compile.Verify.UniformOptimizer + +/-! +# Materialized length + +Every expression `Prep.build` emits has the length of the option it chose +(Share priced by the dictionary width, telescopes by the merged-header +rule). Consequently, when every table index has Share width `w`, the +serialized length of the uniform optimizer's output (`variableBytes`) is its +model length (`modelBytes = uniformCost`). +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (bind_eq_ok sizeInfoWith_app_full sizeInfoWith_app_appCont + sizeInfoWith_lam_full sizeInfoWith_lam_lamCont sizeInfoWith_all_full sizeInfoWith_all_allCont + toNat_toUInt64_of_lt mapM_ok_forall₂ forall₂_getElem array_mapM_forall₂ materializeDependent_parts + pickOption_mem pickOption_filter_ne_share child_eq_getElem indexOfTable_spec) + +/-- The continuation of a telescope family in size facts (`(0, full)` for +non-telescopes). -/ +def famCont (F : Family) (si : SizeInfo) : Nat × Nat := + match F with + | .app => si.appCont + | .lam => si.lamCont + | .all => si.allCont + | .none => (0, si.full) + +/-- A size-fact record that continues no telescope except possibly `F`. -/ +def OnlyCont (F : Family) (si : SizeInfo) : Prop := + ∀ F', F' ≠ F → famCont F' si = (0, si.full) + +theorem rebuild_size (sc : Nat → Nat) {n : Node} {inner side e : Ixon.Expr} {F : Family} + (hF : n.head.family = F) (hre : rebuildSpineNode n inner side = .ok e) : + famCont F (sizeInfoWith sc e) = + ((famCont F (sizeInfoWith sc inner)).1 + 1, + n.sideExtra + (sizeInfoWith sc side).full + (famCont F (sizeInfoWith sc inner)).2) ∧ + (sizeInfoWith sc e).full = tag4Size ((famCont F (sizeInfoWith sc inner)).1 + 1) + + (n.sideExtra + (sizeInfoWith sc side).full + (famCont F (sizeInfoWith sc inner)).2) ∧ + OnlyCont F (sizeInfoWith sc e) := by + unfold rebuildSpineNode at hre + cases hh : n.head <;> simp only [hh] at hre <;> try cases hre + all_goals simp only [hh, Head.family] at hF + all_goals subst hF + · refine ⟨?_, ?_, ?_⟩ + · simp only [famCont, sizeInfoWith_app_appCont, Node.sideExtra, hh]; congr 1; omega + · simp only [famCont, sizeInfoWith_app_full, Node.sideExtra, hh]; omega + · intro F' hF'; cases F' <;> first | exact absurd rfl hF' | rfl + · refine ⟨?_, ?_, ?_⟩ + · simp only [famCont, sizeInfoWith_lam_lamCont, Node.sideExtra, hh] + · simp only [famCont, sizeInfoWith_lam_full, Node.sideExtra, hh] + · intro F' hF'; cases F' <;> first | exact absurd rfl hF' | rfl + · refine ⟨?_, ?_, ?_⟩ + · simp only [famCont, sizeInfoWith_all_allCont, Node.sideExtra, hh] + · simp only [famCont, sizeInfoWith_all_full, Node.sideExtra, hh] + · intro F' hF'; cases F' <;> first | exact absurd rfl hF' | rfl + +/-- A telescope rebuilt by `build` around a tail of another family: its +continuation counts the spine nodes and sums their side bytes and the +tail. -/ +theorem spineFold_size (sc : Nat → Nat) (F : Family) + (buildSide : Node → Except SharingError Ixon.Expr) (sz : Node → Nat) : + ∀ (ns : List Node) (tail e : Ixon.Expr), + (∀ n ∈ ns, n.head.family = F) → + (∀ n ∈ ns, ∀ e', buildSide n = .ok e' → (sizeInfoWith sc e').full = sz n) → + famCont F (sizeInfoWith sc tail) = (0, (sizeInfoWith sc tail).full) → + ns.foldrM (fun n acc => do let side ← buildSide n; rebuildSpineNode n acc side) tail = + .ok e → + famCont F (sizeInfoWith sc e) = + (ns.length, (ns.map fun n => n.sideExtra + sz n).sum + (sizeInfoWith sc tail).full) ∧ + (ns ≠ [] → (sizeInfoWith sc e).full = tag4Size ns.length + + ((ns.map fun n => n.sideExtra + sz n).sum + (sizeInfoWith sc tail).full)) ∧ + (ns ≠ [] → OnlyCont F (sizeInfoWith sc e)) := by + intro ns + induction ns with + | nil => + intro tail e _ _ htail h + simp only [List.foldrM_nil] at h + cases h + exact ⟨by simp [htail], fun h => absurd rfl h, fun h => absurd rfl h⟩ + | cons n ns ih => + intro tail e hfam hsz htail h + rw [List.foldrM_cons] at h + obtain ⟨acc, hacc, hstep⟩ := bind_eq_ok h + obtain ⟨side, hs, hre⟩ := bind_eq_ok hstep + obtain ⟨hc, _, _⟩ := ih tail acc (fun m hm => hfam m (List.mem_cons_of_mem _ hm)) + (fun m hm => hsz m (List.mem_cons_of_mem _ hm)) htail hacc + obtain ⟨hc', hfull', honly'⟩ := rebuild_size sc (hfam n List.mem_cons_self) hre + have hside := hsz n List.mem_cons_self side hs + rw [hc] at hc' hfull' + simp only at hc' hfull' + refine ⟨?_, fun _ => ?_, fun _ => honly'⟩ + · rw [hc', hside] + simp only [List.length_cons, List.map_cons, List.sum_cons] + congr 1 + omega + · rw [hfull', hside] + simp only [List.length_cons, List.map_cons, List.sum_cons] + omega + +/-! ## Spine walks and option lists -/ + +theorem spineWalk_eq (p : Prep) : ∀ (j t : Nat), + p.spineWalk j t = ((List.range j).map fun k => p.dag.node (spineAt p t k), spineAt p t j) := by + intro j + induction j with + | zero => intro t; rfl + | succ j ih => + intro t + simp only [Prep.spineWalk, ih] + congr 1 + rw [List.range_succ_eq_map] + simp only [List.map_cons, List.map_map] + rfl + +theorem prefixSides_eq_sum (p : Prep) (cost : Nat → Nat) : ∀ (j t : Nat), + prefixSides p cost t j = ((List.range j).map fun k => sideCost p cost (spineAt p t k)).sum := by + intro j + induction j with + | zero => intro t; rfl + | succ j ih => + intro t + simp only [prefixSides, ih, List.range_succ_eq_map, List.map_cons, List.map_map, List.sum_cons] + rfl + +/-- The internal cuts with their choices. -/ +def cutsFromC (p : Prep) (w : Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j : Nat) : + List (Choice × Nat) := + (List.range' j (p.spineLen[t]! - j)).filterMap fun j' => + if avail (spineAt p t j') then some (.cut j', cutCost p w cost t j') else none + +theorem mem_cutsFromC {p : Prep} {w : Nat} {avail : Nat → Bool} {cost : Nat → Nat} {t j : Nat} + {ch : Choice} {c : Nat} (h : (ch, c) ∈ cutsFromC p w avail cost t j) : + ∃ k, j ≤ k ∧ k < p.spineLen[t]! ∧ avail (spineAt p t k) = true ∧ ch = .cut k ∧ + c = cutCost p w cost t k := by + unfold cutsFromC at h + obtain ⟨k, hk, hkv⟩ := List.mem_filterMap.mp h + rw [List.mem_range'_1] at hk + split at hkv + · rename_i hav + simp only [Option.some.injEq, Prod.mk.injEq] at hkv + exact ⟨k, hk.1, by omega, hav, hkv.1.symm, hkv.2.symm⟩ + · cases hkv + +theorem cutsFromC_split (p : Prep) (w : Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j k : Nat) + (hjk : j ≤ k) (hk : k < p.spineLen[t]!) (hav : avail (spineAt p t k) = true) + (hnone : ∀ k', j ≤ k' → k' < k → avail (spineAt p t k') = false) : + cutsFromC p w avail cost t j = + (Choice.cut k, cutCost p w cost t k) :: cutsFromC p w avail cost t (k + 1) := by + unfold cutsFromC + rw [show p.spineLen[t]! - j = (k - j) + (1 + (p.spineLen[t]! - (k + 1))) by omega, + ← List.range'_append_1, ← List.range'_append_1, List.filterMap_append, + List.filterMap_append] + have hpre : (List.range' j (k - j)).filterMap (fun j' => + if avail (spineAt p t j') then some (Choice.cut j', cutCost p w cost t j') else none) = [] := by + rw [List.filterMap_eq_nil_iff] + intro a ha + rw [List.mem_range'_1] at ha + rw [hnone a ha.1 (by omega)] + rfl + rw [hpre, show j + (k - j) = k by omega] + simp [hav] + +theorem cutsFromC_nil (p : Prep) (w : Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j : Nat) + (hnone : ∀ k, j ≤ k → k < p.spineLen[t]! → avail (spineAt p t k) = false) : + cutsFromC p w avail cost t j = [] := by + unfold cutsFromC + rw [List.filterMap_eq_nil_iff] + intro a ha + rw [List.mem_range'_1] at ha + rw [hnone a ha.1 (by omega)] + rfl + +/-- The internal-cut options found by `Prep.cutOptions`, with their choices. -/ +theorem PrepWF.cutOptions_pairs {p : Prep} (hp : PrepWF p) {w : Nat} {avail : Nat → Bool} + (ev : DictEval) (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some w else none) + (hindex : ∀ u, (index[u]?.getD none).isSome = avail u) + {t : Nat} (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) (flag : UInt8) + (hsides : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + ev.sides[spineAt p t k]! = + prefixSides p (uCost p w avail) (spineAt p t k) (p.spineLen[t]! - k)) + (hbelow : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + FirstAvail p avail (spineAt p t k) 1 ev.below[spineAt p t k]!) : + ∀ (fuel j : Nat) (cur : Option Nat) (opts : Array (Choice × Nat × ByteArray)), + 1 ≤ j → j ≤ p.spineLen[t]! → p.spineLen[t]! - j ≤ fuel → FirstAvail p avail t j cur → + ∃ L : List (Choice × Nat × ByteArray), + (p.cutOptions ev index width flag p.spineLen[t]! + (prefixSides p (uCost p w avail) t p.spineLen[t]!) fuel cur opts).toList = + opts.toList ++ L ∧ + L.map (fun o => (o.1, o.2.1)) = cutsFromC p w avail (uCost p w avail) t j := by + obtain ⟨_, hk, _, _, _⟩ := hp.spine t ht hf + intro fuel + induction fuel with + | zero => + intro j cur opts _ hj hfuel _ + refine ⟨[], by simp [Prep.cutOptions], ?_⟩ + unfold cutsFromC + rw [show p.spineLen[t]! - j = 0 by omega] + rfl + | succ fuel ih => + intro j cur opts hj1 hj hfuel hcur + cases cur with + | none => + exact ⟨[], by simp [Prep.cutOptions], by rw [cutsFromC_nil p w avail _ t j hcur]; rfl⟩ + | some u => + obtain ⟨k, hjk, hkl, rfl, hav, hnone⟩ := hcur + obtain ⟨_, _, hlenk, _⟩ := hk k hkl + have hcand : tag4Size (p.spineLen[t]! - p.spineLen[spineAt p t k]!) + + (prefixSides p (uCost p w avail) t p.spineLen[t]! - ev.sides[spineAt p t k]!) + + (widthOf width (spineAt p t k)).getD 0 = cutCost p w (uCost p w avail) t k := by + rw [hlenk, hsides k (by omega) hkl, hwidth, if_pos hav] + have hsplit := prefixSides_add p (uCost p w avail) k (p.spineLen[t]! - k) t + rw [show k + (p.spineLen[t]! - k) = p.spineLen[t]! by omega] at hsplit + unfold cutCost + rw [show p.spineLen[t]! - (p.spineLen[t]! - k) = k by omega, hsplit] + simp + have hidx : (index[spineAt p t k]?.getD none).isSome = true := by rw [hindex]; exact hav + simp only [Prep.cutOptions, hidx, if_true] + obtain ⟨L, hL, hcost⟩ := ih (k + 1) _ _ (by omega) (by omega) (by omega) + (FirstAvail.shift hlenk (hbelow k (by omega) hkl)) + refine ⟨(Choice.cut (p.spineLen[t]! - p.spineLen[spineAt p t k]!), + tag4Size (p.spineLen[t]! - p.spineLen[spineAt p t k]!) + + (prefixSides p (uCost p w avail) t p.spineLen[t]! - ev.sides[spineAt p t k]!) + + (widthOf width (spineAt p t k)).getD 0, + tag4Bytes flag (p.spineLen[t]! - p.spineLen[spineAt p t k]!)) :: L, ?_, ?_⟩ + · rw [hL]; simp + · rw [List.map_cons, hcost, cutsFromC_split p w avail _ t j k hjk hkl hav hnone] + simp only + rw [hcand, hlenk, show p.spineLen[t]! - (p.spineLen[t]! - k) = k by omega] + +/-- The options of a term: its Share (if stored), its inline node, or a +telescope cut of `j` spine nodes, with the model costs. -/ +theorem PrepWF.options_mem {p : Prep} (hp : PrepWF p) + (hempty : p.empty.cost.size = p.dag.size ∧ p.empty.sides.size = p.dag.size ∧ + p.empty.below.size = p.dag.size) + {w : Nat} {avail : Nat → Bool} (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some w else none) + (hindex : ∀ u, (index[u]?.getD none).isSome = avail u) {t : Nat} (ht : t < p.dag.size) + {ch : Choice} {c : Nat} {b : ByteArray} + (h : (ch, c, b) ∈ (p.options (p.evalAll width) index width t).toList) : + (ch = .share ∧ c = w ∧ avail t = true) ∨ + (ch = .inline ∧ p.family[t]! = .none ∧ c = uInl p w avail t) ∨ + (∃ j, ch = .cut j ∧ p.family[t]! ≠ .none ∧ 1 ≤ j ∧ j ≤ p.spineLen[t]! ∧ + ((j = p.spineLen[t]! ∧ c = naturalCost p (uCost p w avail) t) ∨ + (j < p.spineLen[t]! ∧ avail (spineAt p t j) = true ∧ + c = cutCost p w (uCost p w avail) t j))) := by + have hrow : ∀ t', t' < p.dag.size → EvalRow p w avail (p.evalAll width) t' := + hp.evalFrom_spec width hwidth p.empty hempty _ (fun t ht => by simp [ht]) + have hcost : ∀ c, (p.evalAll width).cost[c]! = uCost p w avail c := + fun c => hp.evalAll_cost hempty width hwidth c + -- the base: the Share option, if any + have hbase : ∀ x ∈ (match index[t]?.getD none with + | some i => #[(Choice.share, (widthOf width t).getD 0, tag4Bytes Ixon.Expr.FLAG_SHARE i)] + | none => (#[] : Array (Choice × Nat × ByteArray))).toList, + x.1 = .share ∧ x.2.1 = w ∧ avail t = true := by + intro x hx + split at hx + · rename_i i hi + simp only [List.mem_singleton] at hx + have hav : avail t = true := by rw [← hindex, hi]; rfl + subst hx + exact ⟨rfl, by simp [hwidth, hav], hav⟩ + · simp at hx + unfold Prep.options at h + by_cases hf : p.family[t]! = .none + · have hfb : (p.family[t]! == Family.none) = true := by simp [hf] + simp only [hfb, if_true, Array.toList_push, List.mem_append, List.mem_singleton] at h + rcases h with h | h + · obtain ⟨h1, h2, h3⟩ := hbase _ h + exact Or.inl ⟨h1, h2, h3⟩ + · simp only [Prod.mk.injEq] at h + obtain ⟨rfl, rfl, _⟩ := h + refine Or.inr (Or.inl ⟨rfl, hf, ?_⟩) + unfold uInl inlOf + rw [if_pos hf] + exact foldl_add_congr _ _ fun c _ => hcost c + · have hfb : (p.family[t]! == Family.none) = false := by simpa using hf + simp only [hfb, Bool.false_eq_true, if_false] at h + obtain ⟨hs, hb⟩ := (hrow t ht).2 hf + obtain ⟨hl1, hk, _, htl, _⟩ := hp.spine t ht hf + have hspine : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + EvalRow p w avail (p.evalAll width) (spineAt p t k) ∧ + p.family[spineAt p t k]! ≠ .none ∧ + p.spineLen[spineAt p t k]! = p.spineLen[t]! - k := by + intro k h1 h2 + have hlt' := hp.spineAt_lt ht hf h1 h2 + obtain ⟨_, hkf, hklen, _⟩ := hk k h2 + exact ⟨hrow _ (by omega), by rw [hkf]; exact hf, hklen⟩ + obtain ⟨L, hL, hLc⟩ := hp.cutOptions_pairs (p.evalAll width) index width hwidth + hindex ht hf (p.dag.node t).head.flag + (fun k h1 h2 => by + obtain ⟨hr, hfk, hlenk⟩ := hspine k h1 h2 + rw [(hr.2 hfk).1, hlenk]) + (fun k h1 h2 => by + obtain ⟨hr, hfk, _⟩ := hspine k h1 h2 + exact (hr.2 hfk).2) + p.spineLen[t]! 1 _ ((match index[t]?.getD none with + | some i => #[(Choice.share, (widthOf width t).getD 0, tag4Bytes Ixon.Expr.FLAG_SHARE i)] + | none => #[]).push (Choice.cut p.spineLen[t]!, + tag4Size p.spineLen[t]! + (p.evalAll width).sides[t]! + + (p.evalAll width).cost[p.tail[t]!]!, + tag4Bytes (p.dag.node t).head.flag p.spineLen[t]!)) (Nat.le_refl _) (by omega) + (by omega) hb + rw [← hs] at hL + have h' := hL ▸ h + simp only [List.mem_append, Array.toList_push, List.mem_singleton] at h' + rcases h' with (h' | h') | h' + · obtain ⟨h1, h2, h3⟩ := hbase _ h' + exact Or.inl ⟨h1, h2, h3⟩ + · simp only [Prod.mk.injEq] at h' + obtain ⟨rfl, rfl, _⟩ := h' + refine Or.inr (Or.inr ⟨_, rfl, hf, hl1, Nat.le_refl _, Or.inl ⟨rfl, ?_⟩⟩) + rw [hs, hcost] + rfl + · have hm : (ch, c) ∈ cutsFromC p w avail (uCost p w avail) t 1 := by + rw [← hLc] + exact List.mem_map.mpr ⟨_, h', rfl⟩ + obtain ⟨k, hk1, hkl, hav, rfl, rfl⟩ := mem_cutsFromC hm + exact Or.inr (Or.inr ⟨k, rfl, hf, hk1, by omega, Or.inr ⟨hkl, hav, rfl⟩⟩) + +theorem share_onlyCont (sc : Nat → Nat) (x : UInt64) (F : Family) : + OnlyCont F (sizeInfoWith sc (.share x)) := by + intro F' _; cases F' <;> rfl + +theorem children_toList {n : Node} {m : Nat} (h : n.children.size = m) : + n.children.toList = (List.range m).map n.child := by + apply List.ext_getElem (by simp [h]) + intro k h1 h2 + simp only [List.getElem_map, List.getElem_range, Array.getElem_toList] + rw [child_eq_getElem n k (by simp at h1; omega)] + +/-- Every expression `build` emits has the length of the model: its entry +cost for an entry body, its standalone cost otherwise (Shares priced `w`), +and it continues no telescope of another family. -/ +theorem PrepWF.build_size {p : Prep} (hp : PrepWF p) + (hempty : p.empty.cost.size = p.dag.size ∧ p.empty.sides.size = p.dag.size ∧ + p.empty.below.size = p.dag.size) + {w : Nat} {avail : Nat → Bool} (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some w else none) + (hindex : ∀ u, (index[u]?.getD none).isSome = avail u) + (sc : Nat → Nat) + (hsc : ∀ (u i : Nat), index[u]?.getD none = some i → i < UInt64.size ∧ sc i = w) : + ∀ (fuel : Nat) (entry : Bool) (t : Nat) (e : Ixon.Expr), t < p.dag.size → + p.build (p.evalAll width) index width entry fuel t = .ok e → + (sizeInfoWith sc e).full = (if entry then uInl p w avail t else uCost p w avail t) ∧ + OnlyCont p.family[t]! (sizeInfoWith sc e) := by + have hcost : ∀ c, (p.evalAll width).cost[c]! = uCost p w avail c := + fun c => hp.evalAll_cost hempty width hwidth c + have hshare : ∀ (u i : Nat), index[u]?.getD none = some i → + (sizeInfoWith sc (.share i.toUInt64)).full = w := by + intro u i hi + obtain ⟨hlt, hw⟩ := hsc u i hi + simp only [sizeInfoWith, SizeInfo.plain, toNat_toUInt64_of_lt hlt, hw] + intro fuel + induction fuel with + | zero => intro entry t e _ h; simp [Prep.build] at h + | succ fuel ih => + intro entry t e ht h + simp only [Prep.build] at h + split at h + · rename_i choice c hpick + split at h + · rename_i hcheck + -- the chosen option and its cost + obtain ⟨b, hb⟩ := pickOption_mem _ hpick + have hmem : (choice, c, b) ∈ (p.options (p.evalAll width) index width t).toList := by + split at hb + · rw [Array.toList_filter] at hb; exact (List.mem_filter.mp hb).1 + · exact hb + have hc : (if entry then uInl p w avail t else uCost p w avail t) = c := by + cases entry with + | false => + simp only [Bool.false_or, beq_iff_eq] at hcheck + simp only [Bool.false_eq_true, if_false] + rw [← hcost, hcheck] + | true => + simp only [if_true] + rw [← hp.inlineCost_eq hempty index width hwidth hindex t ht] + unfold Prep.inlineCost + simp only [if_true] at hpick + rw [hpick] + rfl + rw [hc] + have hopt := hp.options_mem hempty index width hwidth hindex ht hmem + split at h + · -- Share + obtain ⟨_, rfl, _⟩ | ⟨h1, _⟩ | ⟨j, h1, _⟩ := hopt + · split at h + · rename_i i hi + cases h + exact ⟨hshare t i hi, share_onlyCont sc _ _⟩ + · cases h + · cases h1 + · cases h1 + · -- inline node + obtain ⟨h1, _⟩ | ⟨_, hf, hcv⟩ | ⟨j, h1, _⟩ := hopt + · cases h1 + · rw [hcv] + unfold uInl inlOf + rw [if_pos hf] + have har := hp.dag.arity t ht + rw [← dag_node_eq ht] at har + cases hh : (p.dag.node t).head <;> simp only [hh] at h har + case prj ti f => + obtain ⟨v, hv, hpure⟩ := bind_eq_ok h + cases hpure + have hc0 : (p.dag.node t).child 0 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + obtain ⟨hvs, _⟩ := ih false _ v (by omega) hv + simp only [Bool.false_eq_true, if_false] at hvs + refine ⟨?_, fun F' _ => by cases F' <;> rfl⟩ + rw [← Array.foldl_toList, children_toList (m := 1) (by simpa [Head.arity] using har)] + simp [sizeInfoWith, SizeInfo.plain, hvs, Head.ownBytes] <;> omega + case letE lc => + obtain ⟨ty, hty, h2⟩ := bind_eq_ok h + obtain ⟨v, hv, h3⟩ := bind_eq_ok h2 + obtain ⟨bd, hbd, hpure⟩ := bind_eq_ok h3 + cases hpure + have hc0 : (p.dag.node t).child 0 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + have hc1 : (p.dag.node t).child 1 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + have hc2 : (p.dag.node t).child 2 < t := + hp.dag.childAt_lt ht (by simp [hh, Head.arity]) + obtain ⟨hs0, _⟩ := ih false _ ty (by omega) hty + obtain ⟨hs1, _⟩ := ih false _ v (by omega) hv + obtain ⟨hs2, _⟩ := ih false _ bd (by omega) hbd + simp only [Bool.false_eq_true, if_false] at hs0 hs1 hs2 + refine ⟨?_, fun F' _ => by cases F' <;> rfl⟩ + rw [← Array.foldl_toList, children_toList (m := 3) (by simpa [Head.arity] using har)] + simp [sizeInfoWith, SizeInfo.plain, hs0, hs1, hs2, Head.ownBytes, + List.range_succ] <;> omega + all_goals first + | (cases h; done) + | (cases h + simp only [Node.toExpr, hh] + refine ⟨?_, fun F' _ => by cases F' <;> rfl⟩ + rw [← Array.foldl_toList, + children_toList (m := 0) (by simpa [Head.arity] using har)] + simp [sizeInfoWith, SizeInfo.plain, Head.ownBytes]) + · cases h1 + · -- telescope cut + rename_i j + obtain ⟨h1, _⟩ | ⟨h1, _⟩ | ⟨j', hj', hf, hj1, hjl, hcase⟩ := hopt + · cases h1 + · cases h1 + cases hj' + obtain ⟨_, hk, hend, htl, htf⟩ := hp.spine t ht hf + have hfam : ∀ n ∈ (List.range j).map (fun k => p.dag.node (spineAt p t k)), + n.head.family = p.family[t]! := by + intro n hn + obtain ⟨k, hk', rfl⟩ := List.mem_map.mp hn + rw [List.mem_range] at hk' + obtain ⟨hle, hkf, _, _⟩ := hk k (by omega) + rw [← hp.family _ (by omega), hkf] + have hsz : ∀ n ∈ (List.range j).map (fun k => p.dag.node (spineAt p t k)), ∀ e', + p.build (p.evalAll width) index width false fuel n.sideChild = .ok e' → + (sizeInfoWith sc e').full = uCost p w avail n.sideChild := by + intro n hn e' he' + obtain ⟨k, hk', rfl⟩ := List.mem_map.mp hn + rw [List.mem_range] at hk' + obtain ⟨hle, hkf, _, _⟩ := hk k (by omega) + have hs := hp.sideChild_lt (t := spineAt p t k) (by omega) (by rw [hkf]; exact hf) + have := (ih false _ e' (by omega) he').1 + simpa using this + have hsum : (((List.range j).map (fun k => p.dag.node (spineAt p t k))).map + (fun n => n.sideExtra + uCost p w avail n.sideChild)).sum = + prefixSides p (uCost p w avail) t j := by + rw [prefixSides_eq_sum, List.map_map] + rfl + have hlen : ((List.range j).map (fun k => p.dag.node (spineAt p t k))).length = j := by + simp + have hne : (List.range j).map (fun k => p.dag.node (spineAt p t k)) ≠ [] := by + intro h0 + have := congrArg List.length h0 + simp at this + omega + rw [spineWalk_eq] at h + split at h + · cases h + split at h + · -- the prefix ends in a Share + rename_i _ hjlt + split at h + · rename_i i hi + obtain ⟨tl, htl', hfold⟩ := bind_eq_ok h + cases htl' + obtain ⟨_, hfull, honly⟩ := spineFold_size sc p.family[t]! _ + (fun n => uCost p w avail n.sideChild) _ _ _ hfam hsz + (by cases p.family[t]! <;> rfl) hfold + refine ⟨?_, honly hne⟩ + rw [hfull hne, hlen, hsum, hshare _ i hi] + rcases hcase with ⟨hjl', _⟩ | ⟨_, _, hcv⟩ + · omega + · rw [hcv] + unfold cutCost + omega + · obtain ⟨tl, htl', _⟩ := bind_eq_ok h + cases htl' + · -- the full spine ends in the natural tail + rename_i _ hjlt + have hjeq : j = p.spineLen[t]! := by omega + obtain ⟨tl, htl', hfold⟩ := bind_eq_ok h + simp only at htl' + rw [hjeq, hend] at htl' + obtain ⟨htfull, htonly⟩ := ih false _ tl (by omega) htl' + simp only [Bool.false_eq_true, if_false] at htfull + obtain ⟨_, hfull, honly⟩ := spineFold_size sc p.family[t]! _ + (fun n => uCost p w avail n.sideChild) _ _ _ hfam hsz + (htonly _ (Ne.symm htf)) hfold + refine ⟨?_, honly hne⟩ + rw [hfull hne, hlen, hsum, htfull] + rcases hcase with ⟨_, hcv⟩ | ⟨hjl', _, _⟩ + · rw [hcv, hjeq] + unfold naturalCost + omega + · omega + · cases h + · cases h +theorem forall₂_sum {α β : Type} {R : α → β → Prop} {f : α → Nat} {g : β → Nat} : + ∀ {xs : List α} {ys : List β}, List.Forall₂ R xs ys → + (∀ a ∈ xs, ∀ b, R a b → g b = f a) → (ys.map g).sum = (xs.map f).sum + | _, _, .nil, _ => rfl + | _, _, .cons hr hs, hfg => by + simp only [List.map_cons, List.sum_cons, hfg _ List.mem_cons_self _ hr, + forall₂_sum hs (fun a ha b h => hfg a (List.mem_cons_of_mem _ ha) b h)] + +theorem exprsSize_eq_sum (es : Array Ixon.Expr) : + exprsSize es = (es.toList.map exprSize).sum := by + unfold exprsSize + exact array_foldl_add_sum exprSize es + +/-- **Serialized length = model length.** When every table index of the +output has Share width `w`, the serialized variable length of the uniform +optimizer's output equals its model length `uniformCost` of the stored set. -/ +theorem optimizeUniform_variableBytes {w : Nat} {limits : Limits} {ex : Expanded} + {res : UniformSharingResult} (h : optimizeUniformExpanded w limits ex = .ok res) + (hwidth : ∀ i, i < res.result.sharing.size → shareWidth i = w) : + res.result.variableBytes = res.result.modelBytes := by + obtain ⟨_, hwf, hroots, _, _, c, _, hfin⟩ := optimizeUniform_parts h + obtain ⟨hin, _, hstored, _, hmodel, work, hmat, hvar⟩ := uniformFinish_spec hfin + obtain ⟨hperm, hmodelEq⟩ := optimizeUniform_modelBytes h + have hp := prepWF_ofDag hwf + have hempty := ofDag_empty_size ex.dag + let p := Prep.ofDag ex.dag + let order := pinnedOrder ex.dag c.facts.deg c.stored + have hperm' : order.toList.Perm c.stored.toList := pinnedOrder_perm _ _ _ + have hin' : ∀ t ∈ order.toList, t < p.dag.size := fun t ht => hin t (hperm'.subset ht) + let avail := fun t => decide (t ∈ c.stored.toList) + have hw : ∀ u, widthOf (c.stored.foldl (fun acc t => acc.set! t (some w)) + (Array.replicate ex.dag.size none)) u = if avail u then some w else none := by + intro u + rw [← Array.foldl_toList] + exact widthOfStored ex.dag.size w c.stored.toList hin u + have hindex : ∀ u, ((indexOfPairs p.dag.size order.toList.zipIdx)[u]?.getD none).isSome = + avail u := by + intro u + rw [indexOfTable_isSome _ order hin' u] + simp only [avail, decide_eq_decide] + exact hperm'.mem_iff + obtain ⟨hsize, hes, hrs⟩ := materializeDependent_parts p order ex.roots _ limits hmat + have hlen : res.result.sharing.size = order.size := by + have := (forall₂_getElem hes).1 + simp only [Array.length_toList] at this + exact this.symm + have hsc : ∀ (u i : Nat), (indexOfPairs p.dag.size order.toList.zipIdx)[u]?.getD none = some i → + i < UInt64.size ∧ tag4Size i = w := by + intro u i hi + have hi' := indexOfTable_spec p.dag.size order u i hi + have hlt := (Array.getElem?_eq_some_iff.mp hi').1 + exact ⟨by omega, hwidth i (by omega)⟩ + have hentries : (res.result.sharing.toList.map exprSize).sum = + (order.toList.map (uInl p w avail)).sum := + forall₂_sum hes (fun t ht e he => by + have := (hp.build_size hempty _ _ hw hindex tag4Size hsc _ true t e (hin' t ht) he).1 + simpa [exprSize, sizeInfo] using this) + have hrootsum : (res.result.roots.toList.map exprSize).sum = + (ex.roots.toList.map (uCost p w avail)).sum := + forall₂_sum hrs (fun r hr e he => by + have := (hp.build_size hempty _ _ hw hindex tag4Size hsc _ false r e (hroots r hr) he).1 + simpa [exprSize, sizeInfo] using this) + rw [hvar, hmodelEq, exprsSize_eq_sum, exprsSize_eq_sum, hentries, hrootsum, hlen, hstored] + unfold uniformCost + have hl : order.size = c.stored.toList.length := by + rw [← Array.length_toList]; exact hperm'.length_eq + rw [hl, List.Perm.sum_nat (hperm'.map _)] + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformModel.lean b/Ix/Compile/Verify/UniformModel.lean new file mode 100644 index 000000000..25f22d739 --- /dev/null +++ b/Ix/Compile/Verify/UniformModel.lean @@ -0,0 +1,1248 @@ +import Ix.Compile.Verify.SharingExactCanon + +/-! +# The uniform-width cost model + +A pure model of the length the uniform-width optimizer minimises, over the +canonical DAG `p.dag` (with its telescope tables `Prep.ofDag`), a Share +width `w` and a set `avail` of stored terms (every stored term costs `w` at +every reference): + +* `uCost t`: the cheapest standalone writing of `t` — a Share (`w`) if `t` is + stored and that is shorter, otherwise inline; +* `uInl t`: the cheapest inline writing of `t` (the body of its entry): + for a non-telescope head its own bytes plus its children's `uCost`; for a + telescope `t = t₀, t₁, …, t_{l-1}` with natural tail `t_l`, the minimum + over the inline prefix lengths `j`: the full spine ending in the tail + (`tag4Size l + Σ side bytes + uCost t_l`), or, for `1 ≤ j < l` with `t_j` + stored, the prefix ending in `Share(t_j)` (`tag4Size j + Σ_{k intro k st; rfl + | succ i ih => + intro k st + rw [foldRange, ih, List.range'_succ, List.foldl_cons] + +theorem foldRange_zero {σ : Type} (f : σ → Nat → σ) (n : Nat) (st : σ) : + foldRange f 0 n st = (List.range n).foldl f st := by + rw [foldRange_eq, List.range_eq_range'] + +theorem foldl_range_succ {σ : Type} (f : σ → Nat → σ) (m : Nat) (st : σ) : + (List.range (m + 1)).foldl f st = f ((List.range m).foldl f st) m := by + rw [List.range_succ, List.foldl_append] + rfl + + +/-! ## Well-formed DAGs -/ + +/-- The DAG checks of `optimizeUniformExpanded`: children precede their +parents and every node has its head's arity. -/ +structure DagWF (dag : Dag) : Prop where + precede : CP dag.nodes + arity : NodeArity dag.nodes + +theorem dag_node_eq {dag : Dag} {t : Nat} (ht : t < dag.size) : dag.node t = dag.nodes[t]! := by + simp [Dag.node, Dag.size] at ht ⊢ + simp [ht] + +theorem DagWF.child_lt {dag : Dag} (h : DagWF dag) {t c : Nat} (ht : t < dag.size) + (hc : c ∈ (dag.node t).children) : c < t := by + rw [dag_node_eq ht] at hc + exact h.precede t ht c hc + +theorem DagWF.childAt_lt {dag : Dag} (h : DagWF dag) {t k : Nat} (ht : t < dag.size) + (hk : k < (dag.node t).head.arity) : (dag.node t).child k < t := by + have ha := h.arity t ht + rw [← dag_node_eq ht] at ha + rw [child_eq_getElem _ k (by omega)] + exact h.child_lt ht (Array.getElem_mem _) + +/-! ## Telescope tables -/ + +theorem ofDag_family {dag : Dag} {t : Nat} (ht : t < dag.size) : + (Prep.ofDag dag).family[t]! = (dag.node t).head.family := by + simp only [Prep.ofDag, dag_node_eq ht] + simp only [Dag.size] at ht + simp [ht] + +theorem ofDag_dag (dag : Dag) : (Prep.ofDag dag).dag = dag := rfl + +/-- A telescope node continues its spine past itself. -/ +def continues (p : Prep) (t : Nat) : Bool := + p.family[(p.dag.node t).spineNext]! == p.family[t]! + +theorem spineNext_lt {dag : Dag} (h : DagWF dag) {t : Nat} (ht : t < dag.size) + (hf : (dag.node t).head.family ≠ .none) : (dag.node t).spineNext < t := by + unfold Node.spineNext + cases hh : (dag.node t).head <;> simp only [hh, Head.family] at hf ⊢ <;> + first | exact absurd rfl hf | exact h.childAt_lt ht (by simp [hh, Head.arity]) + +theorem sideChild_lt {dag : Dag} (h : DagWF dag) {t : Nat} (ht : t < dag.size) + (hf : (dag.node t).head.family ≠ .none) : (dag.node t).sideChild < t := by + unfold Node.sideChild + cases hh : (dag.node t).head <;> simp only [hh, Head.family] at hf ⊢ <;> + first | exact absurd rfl hf | exact h.childAt_lt ht (by simp [hh, Head.arity]) + +instance : LawfulBEq Family where + eq_of_beq {a b} h := by + cases a <;> cases b <;> first | rfl | exact absurd h (by decide) + rfl {a} := by cases a <;> decide + +instance : DecidableEq Family := fun a b => + if h : (a == b) = true then isTrue (eq_of_beq h) + else isFalse (fun e => h (e ▸ beq_self_eq_true a)) + +theorem ofDag_spineLen (dag : Dag) : + (Prep.ofDag dag).spineLen = (spineTables dag (Prep.ofDag dag).family).1 := rfl + +theorem ofDag_tail (dag : Dag) : + (Prep.ofDag dag).tail = (spineTables dag (Prep.ofDag dag).family).2 := rfl + +/-- The recurrence of the telescope tables at `t`. -/ +def SpineRow (dag : Dag) (family : Array Family) (len tail : Array Nat) (t : Nat) : Prop := + (family[t]! ≠ .none → + len[t]! = (if family[(dag.node t).spineNext]! = family[t]! then + len[(dag.node t).spineNext]! + 1 else 1) ∧ + tail[t]! = (if family[(dag.node t).spineNext]! = family[t]! then + tail[(dag.node t).spineNext]! else (dag.node t).spineNext)) ∧ + (family[t]! = .none → len[t]! = 0 ∧ tail[t]! = 0) + +theorem SpineRow.congr {dag : Dag} (h : DagWF dag) {family : Array Family} + (hfam : ∀ t, t < dag.size → family[t]! = (dag.node t).head.family) + {len tail len' tail' : Array Nat} {t : Nat} (ht : t < dag.size) + (hlen : ∀ i, i ≤ t → len'[i]! = len[i]!) (htail : ∀ i, i ≤ t → tail'[i]! = tail[i]!) + (hrow : SpineRow dag family len tail t) : SpineRow dag family len' tail' t := by + obtain ⟨h1, h2⟩ := hrow + refine ⟨fun hf => ?_, fun hf => ?_⟩ + · have hfm : (dag.node t).head.family ≠ .none := by rw [← hfam t ht]; exact hf + have hn := spineNext_lt h ht hfm + rw [hlen t (Nat.le_refl _), htail t (Nat.le_refl _), hlen (dag.node t).spineNext (by omega), + htail (dag.node t).spineNext (by omega)] + exact h1 hf + · rw [hlen t (Nat.le_refl _), htail t (Nat.le_refl _)] + exact h2 hf + +theorem spineTables_spec {dag : Dag} (h : DagWF dag) {family : Array Family} + (hfam : ∀ t, t < dag.size → family[t]! = (dag.node t).head.family) (t : Nat) + (ht : t < dag.size) : + SpineRow dag family (spineTables dag family).1 (spineTables dag family).2 t := by + have z : ∀ i : Nat, (Array.replicate dag.size (0 : Nat))[i]! = 0 := by + intro i; simp only [getElem!_def, Array.getElem?_replicate] + by_cases hi : i < dag.size <;> simp [hi] + have hinv : ∀ m, m ≤ dag.size → + let st := (List.range m).foldl (spineStep dag family) + (Array.replicate dag.size 0, Array.replicate dag.size 0) + st.1.size = dag.size ∧ st.2.size = dag.size ∧ + (∀ t, t < m → SpineRow dag family st.1 st.2 t) ∧ + (∀ t, m ≤ t → st.1[t]! = 0 ∧ st.2[t]! = 0) := by + intro m + induction m with + | zero => + intro _ + exact ⟨by simp, by simp, fun _ h => absurd h (Nat.not_lt_zero _), fun t _ => ⟨z t, z t⟩⟩ + | succ m ih => + intro hm + obtain ⟨hs1, hs2, hrow, hzero⟩ := ih (by omega) + simp only at hs1 hs2 hrow hzero ⊢ + rw [foldl_range_succ] + generalize (List.range m).foldl (spineStep dag family) + (Array.replicate dag.size 0, Array.replicate dag.size 0) = st at hs1 hs2 hrow hzero + obtain ⟨len, tl⟩ := st + simp only at hs1 hs2 hrow hzero + have hmn : m < dag.size := by omega + by_cases hf : family[m]! = .none + · have hstep : spineStep dag family (len, tl) m = (len, tl) := by + unfold spineStep; simp [hf] + rw [hstep] + refine ⟨hs1, hs2, fun t ht => ?_, fun t ht => hzero t (by omega)⟩ + by_cases htm : t = m + · subst htm + exact ⟨fun h' => absurd hf h', fun _ => hzero _ (Nat.le_refl _)⟩ + · exact hrow t (by omega) + · have hfm : (dag.node m).head.family ≠ .none := by rw [← hfam m hmn]; exact hf + have hnxt := spineNext_lt h hmn hfm + generalize hnx : (dag.node m).spineNext = nxt at hnxt + let vlen := if family[nxt]! = family[m]! then len[nxt]! + 1 else 1 + let vtl := if family[nxt]! = family[m]! then tl[nxt]! else nxt + have hstep : spineStep dag family (len, tl) m = (len.set! m vlen, tl.set! m vtl) := by + unfold spineStep + simp only [hf, hnx, vlen, vtl, bne_iff_ne, ne_eq, not_false_eq_true, if_true, + beq_iff_eq] + split <;> rfl + rw [hstep] + have keep : ∀ (v : Nat) (arr : Array Nat) (i : Nat), i ≠ m → + (arr.set! m v)[i]! = arr[i]! := by + intro v arr i hi + rw [setBang_getElem!, if_neg (by intro h; exact hi h.1.symm)] + have hat : ∀ (v : Nat) (arr : Array Nat), arr.size = dag.size → + (arr.set! m v)[m]! = v := by + intro v arr hs + rw [setBang_getElem!, if_pos ⟨rfl, by omega⟩] + refine ⟨by simp [hs1], by simp [hs2], fun t ht => ?_, fun t ht => ?_⟩ + · by_cases htm : t = m + · subst htm + refine ⟨fun _ => ?_, fun h' => absurd h' hf⟩ + rw [hnx, hat _ _ hs1, hat _ _ hs2, keep _ _ _ (by omega), keep _ _ _ (by omega)] + exact ⟨rfl, rfl⟩ + · exact SpineRow.congr h hfam (by omega) + (fun i hi => keep _ _ _ (by omega)) (fun i hi => keep _ _ _ (by omega)) + (hrow t (by omega)) + · rw [keep _ _ _ (by omega), keep _ _ _ (by omega)] + exact hzero t (by omega) + have := (hinv dag.size (Nat.le_refl _)).2.2.1 t ht + unfold spineTables + rw [foldRange_zero] + exact this + +/-! ## Well-formed telescope tables -/ + +/-- The facts about `Prep.ofDag dag` that the model uses. -/ +structure PrepWF (p : Prep) : Prop where + dag : DagWF p.dag + family : ∀ t, t < p.dag.size → p.family[t]! = (p.dag.node t).head.family + row : ∀ t, t < p.dag.size → SpineRow p.dag p.family p.spineLen p.tail t + +theorem prepWF_ofDag {dag : Dag} (h : DagWF dag) : PrepWF (Prep.ofDag dag) where + dag := h + family := fun t ht => ofDag_family ht + row := fun t ht => by + rw [ofDag_spineLen, ofDag_tail] + exact spineTables_spec h (fun t ht => ofDag_family ht) t ht + +/-- The next node on the spine. -/ +def snext (p : Prep) (t : Nat) : Nat := (p.dag.node t).spineNext + +/-- `t` after `k` spine steps. -/ +def spineAt (p : Prep) : Nat → Nat → Nat + | t, 0 => t + | t, k + 1 => spineAt p (snext p t) k + +section Spine + +variable {p : Prep} (hp : PrepWF p) +include hp + +theorem PrepWF.snext_lt {t : Nat} (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) : + snext p t < t := + spineNext_lt hp.dag ht (by rw [← hp.family t ht]; exact hf) + +theorem PrepWF.sideChild_lt {t : Nat} (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) : + (p.dag.node t).sideChild < t := + UniformModel.sideChild_lt hp.dag ht (by rw [← hp.family t ht]; exact hf) + +/-- One step of the spine recurrence: either the spine continues into a node +of the same family, one shorter, with the same tail, or it ends with +`snext p t` as the tail. -/ +theorem PrepWF.spine_step {t : Nat} (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) : + (p.family[snext p t]! = p.family[t]! ∧ p.spineLen[t]! = p.spineLen[snext p t]! + 1 ∧ + p.tail[t]! = p.tail[snext p t]!) ∨ + (p.family[snext p t]! ≠ p.family[t]! ∧ p.spineLen[t]! = 1 ∧ p.tail[t]! = snext p t) := by + obtain ⟨hrow, _⟩ := hp.row t ht + obtain ⟨hl, htl⟩ := hrow hf + unfold snext + by_cases hs : p.family[(p.dag.node t).spineNext]! = p.family[t]! + · rw [if_pos hs] at hl htl + exact Or.inl ⟨hs, hl, htl⟩ + · rw [if_neg hs] at hl htl + exact Or.inr ⟨hs, hl, htl⟩ + +/-- The spine of a telescope node: every node before the tail is a +telescope node of the same family, at or below `t`, with the remaining spine +length and the same tail; the tail is below `t` and of another family. -/ +theorem PrepWF.spine : + ∀ t, t < p.dag.size → p.family[t]! ≠ .none → + 1 ≤ p.spineLen[t]! ∧ + (∀ k, k < p.spineLen[t]! → spineAt p t k ≤ t ∧ + p.family[spineAt p t k]! = p.family[t]! ∧ + p.spineLen[spineAt p t k]! = p.spineLen[t]! - k ∧ + p.tail[spineAt p t k]! = p.tail[t]!) ∧ + spineAt p t p.spineLen[t]! = p.tail[t]! ∧ p.tail[t]! < t ∧ + p.family[p.tail[t]!]! ≠ p.family[t]! := by + intro t + induction t using Nat.strongRecOn with + | _ t ih => + intro ht hf + have hlt := hp.snext_lt ht hf + rcases hp.spine_step ht hf with ⟨hs, hl, htl⟩ | ⟨hs, hl, htl⟩ + · have hf' : p.family[snext p t]! ≠ .none := by rw [hs]; exact hf + obtain ⟨h1, hk, hend, htlt, htf⟩ := ih _ hlt (by omega) hf' + refine ⟨by omega, fun k hk' => ?_, ?_, by rw [htl]; omega, by rw [htl, ← hs]; exact htf⟩ + · cases k with + | zero => exact ⟨Nat.le_refl _, rfl, by simp [spineAt], rfl⟩ + | succ k => + obtain ⟨a, b, c, d⟩ := hk k (by omega) + refine ⟨by simp only [spineAt]; omega, by simp only [spineAt]; rw [b, hs], ?_, ?_⟩ + · simp only [spineAt]; rw [c]; omega + · simp only [spineAt]; rw [d, htl] + · rw [hl, htl] + exact hend + · refine ⟨by omega, fun k hk => ?_, ?_, by rw [htl]; exact hlt, by rw [htl]; exact hs⟩ + · have : k = 0 := by omega + subst this + exact ⟨Nat.le_refl _, rfl, by simp [spineAt], rfl⟩ + · rw [hl, htl] + rfl + +end Spine + +/-! ## The model -/ + +/-- Contract byte plus the cost of the side child of telescope node `y`. -/ +def sideCost (p : Prep) (cost : Nat → Nat) (y : Nat) : Nat := + (p.dag.node y).sideExtra + cost (p.dag.node y).sideChild + +/-- Side bytes of the first `j` spine nodes from `t`. -/ +def prefixSides (p : Prep) (cost : Nat → Nat) : Nat → Nat → Nat + | _, 0 => 0 + | t, j + 1 => sideCost p cost t + prefixSides p cost (snext p t) j + +/-- The full spine of `t` written inline, ending in its natural tail. -/ +def naturalCost (p : Prep) (cost : Nat → Nat) (t : Nat) : Nat := + tag4Size p.spineLen[t]! + prefixSides p cost t p.spineLen[t]! + cost p.tail[t]! + +/-- The internal cuts of telescope `t`: for `1 ≤ j < spineLen t` with the +`j`-th spine node stored, the prefix of `j` nodes ending in its Share. -/ +def cutCosts (p : Prep) (w : Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t : Nat) : + List Nat := + (List.range' 1 (p.spineLen[t]! - 1)).filterMap fun j => + if avail (spineAt p t j) then some (tag4Size j + prefixSides p cost t j + w) else none + +/-- Cheapest inline writing of `t` given the costs of the terms below it. -/ +def inlOf (p : Prep) (w : Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t : Nat) : Nat := + if p.family[t]! = .none then + (p.dag.node t).children.foldl (fun acc c => acc + cost c) (p.dag.node t).head.ownBytes + else + (cutCosts p w avail cost t).foldl min (naturalCost p cost t) + +/-- Cheapest standalone writing of `t`: its Share if stored and shorter. -/ +def costOf (p : Prep) (w : Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t : Nat) : Nat := + if avail t then min (inlOf p w avail cost t) w else inlOf p w avail cost t + +/-- The model values of every term, children first. -/ +def uVals (p : Prep) (w : Nat) (avail : Nat → Bool) : Array Nat := + foldRange (fun arr t => arr.set! t (costOf p w avail (arr[·]!) t)) 0 p.dag.size + (Array.replicate p.dag.size 0) + +/-- `C_S(t)`: the cheapest standalone writing of `t` with the stored terms +`avail` at width `w`. -/ +def uCost (p : Prep) (w : Nat) (avail : Nat → Bool) (t : Nat) : Nat := + (uVals p w avail)[t]! + +/-- `inl_S(t)`: the cheapest inline writing of `t` (its entry body). -/ +def uInl (p : Prep) (w : Nat) (avail : Nat → Bool) (t : Nat) : Nat := + inlOf p w avail (uCost p w avail) t + +/-- The uniform-model length of a table and roots: the table count, every +entry body and every root. -/ +def uniformCost (p : Prep) (w : Nat) (avail : Nat → Bool) (table roots : List Nat) : Nat := + tag0Size table.length + (table.map (uInl p w avail)).sum + (roots.map (uCost p w avail)).sum + +theorem filterMap_congr' {α β : Type} {f g : α → Option β} : + ∀ {l : List α}, (∀ a ∈ l, f a = g a) → l.filterMap f = l.filterMap g + | [], _ => rfl + | a :: l, h => by + simp only [List.filterMap_cons, h a List.mem_cons_self, + filterMap_congr' (fun b hb => h b (List.mem_cons_of_mem _ hb))] + +section Model + + +variable {p : Prep} (hp : PrepWF p) +include hp + +theorem PrepWF.prefixSides_congr {f g : Nat → Nat} : + ∀ (j t : Nat), t < p.dag.size → p.family[t]! ≠ .none → j ≤ p.spineLen[t]! → + (∀ c, c < t → f c = g c) → prefixSides p f t j = prefixSides p g t j := by + intro j + induction j with + | zero => intro _ _ _ _ _; rfl + | succ j ih => + intro t ht hf hj hfg + simp only [prefixSides, sideCost] + rw [hfg _ (hp.sideChild_lt ht hf)] + congr 1 + cases j with + | zero => rfl + | succ j => + have hlt := hp.snext_lt ht hf + rcases hp.spine_step ht hf with ⟨hs, hl, _⟩ | ⟨_, hl, _⟩ + · exact ih _ (by omega) (by rw [hs]; exact hf) (by omega) + (fun c hc => hfg c (by omega)) + · omega + +theorem PrepWF.inlOf_congr {w : Nat} {avail : Nat → Bool} {f g : Nat → Nat} {t : Nat} + (ht : t < p.dag.size) (hfg : ∀ c, c < t → f c = g c) : + inlOf p w avail f t = inlOf p w avail g t := by + unfold inlOf + split + · rw [← Array.foldl_toList, ← Array.foldl_toList] + have hch : ∀ c ∈ (p.dag.node t).children.toList, f c = g c := + fun c hc => hfg c (hp.dag.child_lt ht (Array.mem_toList_iff.mp hc)) + generalize (p.dag.node t).children.toList = l at hch + generalize (p.dag.node t).head.ownBytes = acc + induction l generalizing acc with + | nil => rfl + | cons c l ih => + simp only [List.foldl_cons] + rw [hch c List.mem_cons_self] + exact ih (fun c hc => hch c (List.mem_cons_of_mem _ hc)) _ + · rename_i hf + obtain ⟨_, _, _, htl, _⟩ := hp.spine t ht hf + have hcuts : cutCosts p w avail f t = cutCosts p w avail g t := by + unfold cutCosts + apply filterMap_congr' + intro j hj + rw [List.mem_range'_1] at hj + rw [hp.prefixSides_congr j t ht hf (by omega) hfg] + unfold naturalCost + rw [hcuts, hp.prefixSides_congr _ t ht hf (Nat.le_refl _) hfg, hfg _ htl] + +theorem PrepWF.costOf_congr {w : Nat} {avail : Nat → Bool} {f g : Nat → Nat} {t : Nat} + (ht : t < p.dag.size) (hfg : ∀ c, c < t → f c = g c) : + costOf p w avail f t = costOf p w avail g t := by + unfold costOf + rw [hp.inlOf_congr ht hfg] + +/-- The model recurrence: `C_S(t)` from the costs of the terms below `t`. -/ +theorem PrepWF.uCost_eq (w : Nat) (avail : Nat → Bool) (t : Nat) (ht : t < p.dag.size) : + uCost p w avail t = costOf p w avail (uCost p w avail) t := by + let step := fun (arr : Array Nat) (t : Nat) => arr.set! t (costOf p w avail (arr[·]!) t) + have hinv : ∀ m, m ≤ p.dag.size → + ((List.range m).foldl step (Array.replicate p.dag.size 0)).size = p.dag.size ∧ + ∀ t, t < m → ((List.range m).foldl step (Array.replicate p.dag.size 0))[t]! = + costOf p w avail (((List.range m).foldl step (Array.replicate p.dag.size 0))[·]!) t := by + intro m + induction m with + | zero => simp + | succ m ih => + intro hm + obtain ⟨hsize, hprev⟩ := ih (by omega) + rw [foldl_range_succ] + generalize hA : (List.range m).foldl step (Array.replicate p.dag.size 0) = A at hsize hprev + have hsame : ∀ c, c < m → (step A m)[c]! = A[c]! := by + intro c hc + simp only [step, setBang_getElem!] + rw [if_neg (by omega)] + refine ⟨by simp [step, hsize], fun t' ht' => ?_⟩ + have hcongr : costOf p w avail ((step A m)[·]!) t' = costOf p w avail (A[·]!) t' := + hp.costOf_congr (by omega) fun c hc => hsame c (by omega) + rw [hcongr] + by_cases htm : t' = m + · subst htm + simp only [step, setBang_getElem!, hsize] + rw [if_pos (by simp; omega)] + · rw [hsame t' (by omega)] + exact hprev t' (by omega) + have := (hinv p.dag.size (Nat.le_refl _)).2 t ht + unfold uCost uVals + rw [foldRange_zero] + exact this + +end Model + +/-! ## The executable evaluation computes the model -/ + +theorem spineAt_add (p : Prep) : ∀ (a b t : Nat), spineAt p t (a + b) = spineAt p (spineAt p t a) b := by + intro a + induction a with + | zero => intro b t; simp [spineAt] + | succ a ih => + intro b t + rw [show a + 1 + b = (a + b) + 1 by omega] + simp only [spineAt] + rw [ih] + +theorem prefixSides_add (p : Prep) (cost : Nat → Nat) : + ∀ (a b t : Nat), prefixSides p cost t (a + b) = + prefixSides p cost t a + prefixSides p cost (spineAt p t a) b := by + intro a + induction a with + | zero => intro b t; simp [prefixSides, spineAt] + | succ a ih => + intro b t + rw [show a + 1 + b = (a + b) + 1 by omega] + simp only [prefixSides, spineAt] + rw [ih] + omega + +/-- The cost of the cut after `j` spine nodes of `t`. -/ +def cutCost (p : Prep) (w : Nat) (cost : Nat → Nat) (t j : Nat) : Nat := + tag4Size j + prefixSides p cost t j + w + +/-- The available cuts of `t` at spine positions `j, …, spineLen t - 1`. -/ +def cutsFrom (p : Prep) (w : Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j : Nat) : + List Nat := + (List.range' j (p.spineLen[t]! - j)).filterMap fun j' => + if avail (spineAt p t j') then some (cutCost p w cost t j') else none + +theorem cutCosts_eq (p : Prep) (w : Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t : Nat) : + cutCosts p w avail cost t = cutsFrom p w avail cost t 1 := rfl + +/-- `b` is the first stored spine node of `t` at a position in `[j, spineLen t)`. -/ +def FirstAvail (p : Prep) (avail : Nat → Bool) (t j : Nat) : Option Nat → Prop + | none => ∀ k, j ≤ k → k < p.spineLen[t]! → avail (spineAt p t k) = false + | some u => ∃ k, j ≤ k ∧ k < p.spineLen[t]! ∧ u = spineAt p t k ∧ avail u = true ∧ + ∀ k', j ≤ k' → k' < k → avail (spineAt p t k') = false + +theorem ite_lt_eq_min (a b : Nat) : (if a < b then a else b) = min b a := by + rw [Nat.min_def] + split <;> split <;> omega + +theorem cutsFrom_split (p : Prep) (w : Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j k : Nat) + (hjk : j ≤ k) (hk : k < p.spineLen[t]!) (hav : avail (spineAt p t k) = true) + (hnone : ∀ k', j ≤ k' → k' < k → avail (spineAt p t k') = false) : + cutsFrom p w avail cost t j = cutCost p w cost t k :: cutsFrom p w avail cost t (k + 1) := by + unfold cutsFrom + rw [show p.spineLen[t]! - j = (k - j) + (1 + (p.spineLen[t]! - (k + 1))) by omega, + ← List.range'_append_1, ← List.range'_append_1, List.filterMap_append, + List.filterMap_append] + have hpre : (List.range' j (k - j)).filterMap (fun j' => + if avail (spineAt p t j') then some (cutCost p w cost t j') else none) = [] := by + rw [List.filterMap_eq_nil_iff] + intro a ha + rw [List.mem_range'_1] at ha + rw [hnone a ha.1 (by omega)] + rfl + rw [hpre, show j + (k - j) = k by omega] + simp [hav] + +theorem cutsFrom_nil (p : Prep) (w : Nat) (avail : Nat → Bool) (cost : Nat → Nat) (t j : Nat) + (hnone : ∀ k, j ≤ k → k < p.spineLen[t]! → avail (spineAt p t k) = false) : + cutsFrom p w avail cost t j = [] := by + unfold cutsFrom + rw [List.filterMap_eq_nil_iff] + intro a ha + rw [List.mem_range'_1] at ha + rw [hnone a ha.1 (by omega)] + rfl + +theorem FirstAvail.shift {p : Prep} {avail : Nat → Bool} {t k : Nat} {b : Option Nat} + (hlen : p.spineLen[spineAt p t k]! = p.spineLen[t]! - k) + (h : FirstAvail p avail (spineAt p t k) 1 b) : FirstAvail p avail t (k + 1) b := by + cases b with + | none => + intro k' hk1 hk2 + have := h (k' - k) (by omega) (by omega) + rwa [← spineAt_add, show k + (k' - k) = k' by omega] at this + | some u => + obtain ⟨i, hi1, hi2, rfl, hav, hnone⟩ := h + refine ⟨k + i, by omega, by omega, by rw [spineAt_add], hav, fun k' hk1 hk2 => ?_⟩ + have := hnone (k' - k) (by omega) (by omega) + rwa [← spineAt_add, show k + (k' - k) = k' by omega] at this + +/-- The internal-cut scan finds the cheapest available cut. -/ +theorem PrepWF.cutScan_spec {p : Prep} (hp : PrepWF p) {w : Nat} {avail : Nat → Bool} + {cost : Nat → Nat} (sides : Array Nat) (below : Array (Option Nat)) + (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some w else none) + {t : Nat} (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) + (hsides : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + sides[spineAt p t k]! = prefixSides p cost (spineAt p t k) (p.spineLen[t]! - k)) + (hbelow : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + FirstAvail p avail (spineAt p t k) 1 below[spineAt p t k]!) : + ∀ (fuel j : Nat) (cur : Option Nat) (best work : Nat), 1 ≤ j → j ≤ p.spineLen[t]! → + p.spineLen[t]! - j ≤ fuel → FirstAvail p avail t j cur → + (cutScan p.spineLen sides below width p.spineLen[t]! + (prefixSides p cost t p.spineLen[t]!) fuel cur best work).1 = + (cutsFrom p w avail cost t j).foldl min best := by + obtain ⟨_, hk, _, _, _⟩ := hp.spine t ht hf + intro fuel + induction fuel with + | zero => + intro j cur best work _ hj hfuel _ + have : cutsFrom p w avail cost t j = [] := by + unfold cutsFrom + rw [show p.spineLen[t]! - j = 0 by omega] + rfl + rw [this] + rfl + | succ fuel ih => + intro j cur best work hj1 hj hfuel hcur + cases cur with + | none => + rw [cutsFrom_nil p w avail cost t j hcur] + rfl + | some u => + obtain ⟨k, hjk, hkl, rfl, hav, hnone⟩ := hcur + obtain ⟨_, _, hlenk, _⟩ := hk k hkl + simp only [cutScan] + rw [cutsFrom_split p w avail cost t j k hjk hkl hav hnone, List.foldl_cons, + ite_lt_eq_min] + have hcand : tag4Size (p.spineLen[t]! - p.spineLen[spineAt p t k]!) + + (prefixSides p cost t p.spineLen[t]! - sides[spineAt p t k]!) + + (widthOf width (spineAt p t k)).getD 0 = cutCost p w cost t k := by + rw [hlenk, hsides k (by omega) hkl, hwidth, if_pos hav] + have hsplit := prefixSides_add p cost k (p.spineLen[t]! - k) t + rw [show k + (p.spineLen[t]! - k) = p.spineLen[t]! by omega] at hsplit + unfold cutCost + rw [show p.spineLen[t]! - (p.spineLen[t]! - k) = k by omega, hsplit] + simp + rw [hcand] + exact ih (k + 1) _ _ _ (by omega) (by omega) (by omega) + (FirstAvail.shift hlenk (hbelow k (by omega) hkl)) + +theorem foldl_add_congr {f g : Nat → Nat} (a : Nat) (arr : Array Nat) + (h : ∀ c ∈ arr, f c = g c) : + arr.foldl (fun acc c => acc + f c) a = arr.foldl (fun acc c => acc + g c) a := by + rw [← Array.foldl_toList, ← Array.foldl_toList] + have h' : ∀ c ∈ arr.toList, f c = g c := fun c hc => h c (Array.mem_toList_iff.mp hc) + generalize arr.toList = l at h' + induction l generalizing a with + | nil => rfl + | cons c l ih => + simp only [List.foldl_cons] + rw [h' c List.mem_cons_self] + exact ih _ (fun c hc => h' c (List.mem_cons_of_mem _ hc)) + +/-- The evaluation entries of term `t` agree with the model. -/ +def EvalRow (p : Prep) (w : Nat) (avail : Nat → Bool) (st : DictEval) (t : Nat) : Prop := + st.cost[t]! = uCost p w avail t ∧ + (p.family[t]! ≠ .none → + st.sides[t]! = prefixSides p (uCost p w avail) t p.spineLen[t]! ∧ + FirstAvail p avail t 1 st.below[t]!) + +theorem FirstAvail.unshift {p : Prep} {avail : Nat → Bool} {t j : Nat} {b : Option Nat} + (hj : j < p.spineLen[t]!) (hav : avail (spineAt p t j) = false) + (h : FirstAvail p avail t (j + 1) b) : FirstAvail p avail t j b := by + cases b with + | none => + intro k hk1 hk2 + by_cases hkj : k = j + · subst hkj; exact hav + · exact h k (by omega) hk2 + | some u => + obtain ⟨k, hk1, hk2, rfl, hu, hnone⟩ := h + refine ⟨k, by omega, hk2, rfl, hu, fun k' hk'1 hk'2 => ?_⟩ + by_cases hkj : k' = j + · subst hkj; exact hav + · exact hnone k' (by omega) hk'2 + +theorem ite_beq_family (a b : Family) {α : Type} (x y : α) : + (if (a == b) = true then x else y) = if a = b then x else y := by + by_cases h : a = b + · subst h; simp + · have : (a == b) = false := by simpa using h + simp [this, h] + +theorem PrepWF.spineAt_lt {p : Prep} (hp : PrepWF p) {t k : Nat} (ht : t < p.dag.size) + (hf : p.family[t]! ≠ .none) (hk1 : 1 ≤ k) (hk : k < p.spineLen[t]!) : spineAt p t k < t := by + have hlt := hp.snext_lt ht hf + rcases hp.spine_step ht hf with ⟨hs, hl, _⟩ | ⟨_, hl, _⟩ + · obtain ⟨_, hk', _, _, _⟩ := hp.spine (snext p t) (by omega) (by rw [hs]; exact hf) + obtain ⟨hle, _⟩ := hk' (k - 1) (by omega) + rw [show k = (k - 1) + 1 by omega] + simp only [spineAt] + omega + · omega + +/-- One evaluation step establishes the model row of the new term and keeps +the rows of the earlier ones. -/ +theorem PrepWF.evalStep_spec {p : Prep} (hp : PrepWF p) {w : Nat} {avail : Nat → Bool} + (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some w else none) + (affected : Array Bool) (st : DictEval) (m : Nat) (hm : m < p.dag.size) + (haff : affected[m]! = true) + (hsz : st.cost.size = p.dag.size ∧ st.sides.size = p.dag.size ∧ + st.below.size = p.dag.size) + (hrows : ∀ t, t < m → EvalRow p w avail st t) : + let st' := evalStep p.dag p.family p.spineLen p.tail width affected st m + (st'.cost.size = p.dag.size ∧ st'.sides.size = p.dag.size ∧ + st'.below.size = p.dag.size) ∧ ∀ t, t < m + 1 → EvalRow p w avail st' t := by + intro st' + obtain ⟨hcs, hss, hbs⟩ := hsz + have keepN : ∀ (v : Nat) (arr : Array Nat) (i : Nat), i ≠ m → (arr.set! m v)[i]! = arr[i]! := by + intro v arr i hi + rw [setBang_getElem!, if_neg (by intro h; exact hi h.1.symm)] + have keepO : ∀ (v : Option Nat) (arr : Array (Option Nat)) (i : Nat), i ≠ m → + (arr.set! m v)[i]! = arr[i]! := by + intro v arr i hi + rw [setBang_getElem!, if_neg (by intro h; exact hi h.1.symm)] + have atN : ∀ (v : Nat) (arr : Array Nat), arr.size = p.dag.size → (arr.set! m v)[m]! = v := by + intro v arr hs + rw [setBang_getElem!, if_pos ⟨rfl, by omega⟩] + have atO : ∀ (v : Option Nat) (arr : Array (Option Nat)), arr.size = p.dag.size → + (arr.set! m v)[m]! = v := by + intro v arr hs + rw [setBang_getElem!, if_pos ⟨rfl, by omega⟩] + have hcostLt : ∀ c, c < m → st.cost[c]! = uCost p w avail c := fun c hc => (hrows c hc).1 + have hcm := hp.uCost_eq w avail m hm + have hcostOf : ∀ inl, inlOf p w avail (uCost p w avail) m = inl → + (match widthOf width m with + | some w => min inl w + | none => inl) = uCost p w avail m := by + intro inl hinl + rw [hcm] + unfold costOf + rw [hinl, hwidth] + by_cases ha : avail m = true <;> simp [ha] + by_cases hf : p.family[m]! = .none + · -- non-telescope + have hfold : (p.dag.node m).children.foldl (fun acc c => acc + st.cost[c]!) + (p.dag.node m).head.ownBytes = inlOf p w avail (uCost p w avail) m := by + unfold inlOf + rw [if_pos hf] + exact foldl_add_congr _ _ fun c hc => hcostLt c (hp.dag.child_lt hm hc) + have hst' : st'.cost = st.cost.set! m (uCost p w avail m) ∧ st'.sides = st.sides ∧ + st'.below = st.below := by + simp only [st', evalStep, haff, if_true, hf, beq_self_eq_true] + refine ⟨?_, trivial, trivial⟩ + congr 1 + exact hcostOf _ hfold.symm + obtain ⟨hc', hs', hb'⟩ := hst' + refine ⟨⟨by simp [hc', hcs], by rw [hs']; exact hss, by rw [hb']; exact hbs⟩, + fun t ht => ?_⟩ + by_cases htm : t = m + · subst htm + exact ⟨by rw [hc', atN _ _ hcs], fun h => absurd hf h⟩ + · obtain ⟨h1, h2⟩ := hrows t (by omega) + refine ⟨by rw [hc', keepN _ _ _ htm, h1], ?_⟩ + rw [hs', hb'] + exact h2 + · -- telescope + obtain ⟨hl1, hk, hend, htl, _⟩ := hp.spine m hm hf + have hlt := hp.snext_lt hm hf + have hside := hp.sideChild_lt hm hf + have hS : (p.dag.node m).sideExtra + st.cost[(p.dag.node m).sideChild]! + + (if p.family[snext p m]! = p.family[m]! then st.sides[snext p m]! else 0) = + prefixSides p (uCost p w avail) m p.spineLen[m]! := by + rw [hcostLt _ hside] + rcases hp.spine_step hm hf with ⟨hs, hl, _⟩ | ⟨hs, hl, _⟩ + · rw [if_pos hs, ((hrows _ hlt).2 (by rw [hs]; exact hf)).1, hl] + rfl + · rw [if_neg hs, hl] + simp [prefixSides, sideCost] + have hB : FirstAvail p avail m 1 + (if p.family[snext p m]! = p.family[m]! then + (if (widthOf width (snext p m)).isSome then some (snext p m) + else st.below[snext p m]!) else none) := by + rcases hp.spine_step hm hf with ⟨hs, hl, _⟩ | ⟨hs, hl, _⟩ + · rw [if_pos hs, hwidth] + have hn1 := (hp.spine (snext p m) (by omega) (by rw [hs]; exact hf)).1 + by_cases hav : avail (snext p m) = true + · rw [if_pos hav] + exact ⟨1, Nat.le_refl _, by omega, rfl, hav, fun k' h1 h2 => by omega⟩ + · rw [if_neg hav] + simp only [Option.isSome_none, Bool.false_eq_true, if_false] + have hrow := ((hrows _ hlt).2 (by rw [hs]; exact hf)).2 + have hlen1 : p.spineLen[spineAt p m 1]! = p.spineLen[m]! - 1 := by + simp only [spineAt]; omega + exact FirstAvail.unshift (by omega) (by simpa [spineAt] using hav) + (FirstAvail.shift hlen1 hrow) + · rw [if_neg hs] + intro k h1 h2 + omega + generalize hBdef : (if p.family[snext p m]! = p.family[m]! then + (if (widthOf width (snext p m)).isSome then some (snext p m) + else st.below[snext p m]!) else none) = B at hB + generalize hSdef : prefixSides p (uCost p w avail) m p.spineLen[m]! = S at hS + -- rows of the spine nodes below `m` + have hspine : ∀ k, 1 ≤ k → k < p.spineLen[m]! → + spineAt p m k ≠ m ∧ EvalRow p w avail st (spineAt p m k) ∧ + p.family[spineAt p m k]! ≠ .none ∧ + p.spineLen[spineAt p m k]! = p.spineLen[m]! - k := by + intro k h1 h2 + have hlt' := hp.spineAt_lt hm hf h1 h2 + obtain ⟨_, hkf, hklen, _⟩ := hk k h2 + exact ⟨by omega, hrows _ hlt', by rw [hkf]; exact hf, hklen⟩ + have hsides : ∀ k, 1 ≤ k → k < p.spineLen[m]! → + (st.sides.set! m S)[spineAt p m k]! = + prefixSides p (uCost p w avail) (spineAt p m k) (p.spineLen[m]! - k) := by + intro k h1 h2 + obtain ⟨hne, hrow, hfk, hlenk⟩ := hspine k h1 h2 + rw [keepN _ _ _ hne, (hrow.2 hfk).1, hlenk] + have hbelow : ∀ k, 1 ≤ k → k < p.spineLen[m]! → + FirstAvail p avail (spineAt p m k) 1 (st.below.set! m B)[spineAt p m k]! := by + intro k h1 h2 + obtain ⟨hne, hrow, hfk, _⟩ := hspine k h1 h2 + rw [keepO _ _ _ hne] + exact (hrow.2 hfk).2 + have hscan := hp.cutScan_spec (cost := uCost p w avail) (st.sides.set! m S) + (st.below.set! m B) width hwidth hm hf hsides hbelow p.spineLen[m]! 1 B + (tag4Size p.spineLen[m]! + S + st.cost[p.tail[m]!]!) st.work (Nat.le_refl _) + (by omega) (by omega) hB + rw [hSdef] at hscan + have hinl : inlOf p w avail (uCost p w avail) m = + (cutScan p.spineLen (st.sides.set! m S) (st.below.set! m B) width p.spineLen[m]! S + p.spineLen[m]! B (tag4Size p.spineLen[m]! + S + st.cost[p.tail[m]!]!) st.work).1 := by + rw [hscan, hcostLt _ htl] + unfold inlOf + rw [if_neg hf, cutCosts_eq, naturalCost, hSdef] + have hst' : st'.cost = st.cost.set! m (uCost p w avail m) ∧ + st'.sides = st.sides.set! m S ∧ st'.below = st.below.set! m B := by + simp only [st', evalStep, haff, if_true] + have hfb : (p.family[m]! == Family.none) = false := by simpa using hf + simp only [hfb, Bool.false_eq_true, if_false] + simp only [ite_beq_family] + rw [show (p.dag.node m).spineNext = snext p m from rfl, hS, hBdef] + refine ⟨?_, rfl, rfl⟩ + congr 1 + exact hcostOf _ hinl + obtain ⟨hc', hs', hb'⟩ := hst' + refine ⟨⟨by simp [hc', hcs], by simp [hs', hss], by simp [hb', hbs]⟩, fun t ht => ?_⟩ + by_cases htm : t = m + · subst htm + refine ⟨by rw [hc', atN _ _ hcs], fun _ => ⟨?_, ?_⟩⟩ + · rw [hs', atN _ _ hss, hSdef] + · rw [hb', atO _ _ hbs] + exact hB + · obtain ⟨h1, h2⟩ := hrows t (by omega) + refine ⟨by rw [hc', keepN _ _ _ htm, h1], fun hft => ?_⟩ + obtain ⟨h3, h4⟩ := h2 hft + exact ⟨by rw [hs', keepN _ _ _ htm, h3], by rw [hb', keepO _ _ _ htm]; exact h4⟩ + +theorem evalStep_size (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (affected : Array Bool) (st : DictEval) (m : Nat) : + (evalStep dag family spineLen tail width affected st m).cost.size = st.cost.size ∧ + (evalStep dag family spineLen tail width affected st m).sides.size = st.sides.size ∧ + (evalStep dag family spineLen tail width affected st m).below.size = st.below.size := by + unfold evalStep + split + · simp only + split + · simp + · simp + · exact ⟨rfl, rfl, rfl⟩ + +theorem evalFrom_size (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (init : DictEval) (width : Array (Option Nat)) (affected : Array Bool) : + (evalFrom dag family spineLen tail init width affected).cost.size = init.cost.size ∧ + (evalFrom dag family spineLen tail init width affected).sides.size = init.sides.size ∧ + (evalFrom dag family spineLen tail init width affected).below.size = + init.below.size := by + unfold evalFrom + rw [foldRange_zero] + generalize List.range dag.size = l + suffices h : ∀ (st : DictEval), + (l.foldl (evalStep dag family spineLen tail width affected) st).cost.size = st.cost.size ∧ + (l.foldl (evalStep dag family spineLen tail width affected) st).sides.size = + st.sides.size ∧ + (l.foldl (evalStep dag family spineLen tail width affected) st).below.size = + st.below.size from h _ + induction l with + | nil => intro st; exact ⟨rfl, rfl, rfl⟩ + | cons x l ih => + intro st + rw [List.foldl_cons] + obtain ⟨a, b, c⟩ := ih (evalStep dag family spineLen tail width affected st x) + obtain ⟨a', b', c'⟩ := evalStep_size dag family spineLen tail width affected st x + exact ⟨a.trans a', b.trans b', c.trans c'⟩ + +theorem ofDag_empty_size (dag : Dag) : + (Prep.ofDag dag).empty.cost.size = dag.size ∧ (Prep.ofDag dag).empty.sides.size = dag.size ∧ + (Prep.ofDag dag).empty.below.size = dag.size := by + have := evalFrom_size dag (Prep.ofDag dag).family (Prep.ofDag dag).spineLen + (Prep.ofDag dag).tail + { cost := Array.replicate dag.size 0, sides := Array.replicate dag.size 0, + below := Array.replicate dag.size none } (Array.replicate dag.size none) + (Array.replicate dag.size true) + simp only [Array.size_replicate] at this + exact this + +/-- The executable evaluation computes the model rows of every term. -/ +theorem PrepWF.evalFrom_spec {p : Prep} (hp : PrepWF p) {w : Nat} {avail : Nat → Bool} + (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some w else none) (init : DictEval) + (hsz : init.cost.size = p.dag.size ∧ init.sides.size = p.dag.size ∧ + init.below.size = p.dag.size) + (affected : Array Bool) (haff : ∀ t, t < p.dag.size → affected[t]! = true) : + ∀ t, t < p.dag.size → + EvalRow p w avail (evalFrom p.dag p.family p.spineLen p.tail init width affected) t := by + have hinv : ∀ m, m ≤ p.dag.size → + let st := (List.range m).foldl (evalStep p.dag p.family p.spineLen p.tail width affected) + { init with work := 0 } + (st.cost.size = p.dag.size ∧ st.sides.size = p.dag.size ∧ st.below.size = p.dag.size) ∧ + ∀ t, t < m → EvalRow p w avail st t := by + intro m + induction m with + | zero => intro _; exact ⟨hsz, fun t h => absurd h (Nat.not_lt_zero _)⟩ + | succ m ih => + intro hm + obtain ⟨hs, hrows⟩ := ih (by omega) + simp only at hs hrows ⊢ + rw [foldl_range_succ] + exact hp.evalStep_spec width hwidth affected _ m (by omega) (haff m (by omega)) hs hrows + intro t ht + unfold evalFrom + rw [foldRange_zero] + exact (hinv p.dag.size (Nat.le_refl _)).2 t ht + +theorem uVals_size (p : Prep) (w : Nat) (avail : Nat → Bool) : + (uVals p w avail).size = p.dag.size := by + unfold uVals + rw [foldRange_zero] + generalize List.range p.dag.size = l + suffices h : ∀ (arr : Array Nat), + (l.foldl (fun arr t => arr.set! t (costOf p w avail (arr[·]!) t)) arr).size = arr.size by + rw [h]; simp + induction l with + | nil => intro _; rfl + | cons x l ih => intro arr; rw [List.foldl_cons, ih]; simp + +theorem uCost_of_ge (p : Prep) (w : Nat) (avail : Nat → Bool) {t : Nat} + (ht : p.dag.size ≤ t) : uCost p w avail t = 0 := by + unfold uCost + simp [uVals_size, show ¬ t < p.dag.size by omega] + +/-- `Prep.evalAll` computes `C_S` for every term (`0` out of range on both +sides). -/ +theorem PrepWF.evalAll_cost {p : Prep} (hp : PrepWF p) {w : Nat} {avail : Nat → Bool} + (hempty : p.empty.cost.size = p.dag.size ∧ p.empty.sides.size = p.dag.size ∧ + p.empty.below.size = p.dag.size) + (width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some w else none) (t : Nat) : + (p.evalAll width).cost[t]! = uCost p w avail t := by + by_cases ht : t < p.dag.size + · exact (hp.evalFrom_spec width hwidth p.empty hempty _ + (fun t ht => by simp [ht]) t ht).1 + · have hs := (evalFrom_size p.dag p.family p.spineLen p.tail p.empty width + (Array.replicate p.dag.size true)).1 + rw [uCost_of_ge p w avail (by omega)] + unfold Prep.evalAll Prep.eval + simp [hs, hempty.1, show ¬ t < p.dag.size by omega] + +/-! ## The entry cost of materialization -/ + +theorem foldl_min_le : ∀ (xs : List Nat) (x y : Nat), y ∈ x :: xs → xs.foldl min x ≤ y := by + intro xs + induction xs with + | nil => intro x y hy; simp at hy; subst hy; simp + | cons z zs ih => + intro x y hy + simp only [List.foldl_cons] + rcases List.mem_cons.mp hy with rfl | hy + · have := ih (min y z) (min y z) List.mem_cons_self + omega + · rcases List.mem_cons.mp hy with rfl | hy + · have := ih (min x y) (min x y) List.mem_cons_self + omega + · exact ih _ y (List.mem_cons_of_mem _ hy) + +theorem foldl_min_mem : ∀ (xs : List Nat) (x : Nat), xs.foldl min x ∈ x :: xs := by + intro xs + induction xs with + | nil => intro x; simp + | cons z zs ih => + intro x + simp only [List.foldl_cons] + rcases List.mem_cons.mp (ih (min x z)) with h | h + · rw [h, Nat.min_def] + split + · exact List.mem_cons_self + · exact List.mem_cons_of_mem _ List.mem_cons_self + · exact List.mem_cons_of_mem _ (List.mem_cons_of_mem _ h) + +/-- A list minimum: the element below every element. -/ +theorem foldl_min_unique (xs : List Nat) (x c : Nat) (hc : c ∈ x :: xs) + (hle : ∀ y ∈ x :: xs, c ≤ y) : xs.foldl min x = c := by + have h1 := foldl_min_le xs x c hc + have h2 := hle _ (foldl_min_mem xs x) + omega + +/-- The step of `pickOption`. -/ +def pickStep (best : Option (Choice × Nat × ByteArray)) (o : Choice × Nat × ByteArray) : + Option (Choice × Nat × ByteArray) := + match best with + | none => some o + | some b => + if o.2.1 < b.2.1 then some o + else if o.2.1 == b.2.1 && compareBytes o.2.2 b.2.2 == .lt then some o + else best + +theorem pickStep_spec (init : Option (Choice × Nat × ByteArray)) (x : Choice × Nat × ByteArray) : + ∃ b, pickStep init x = some b ∧ (b = x ∨ init = some b) ∧ b.2.1 ≤ x.2.1 ∧ + ∀ b', init = some b' → b.2.1 ≤ b'.2.1 := by + cases init with + | none => exact ⟨x, rfl, Or.inl rfl, Nat.le_refl _, fun _ h => by cases h⟩ + | some c => + unfold pickStep + simp only + by_cases hlt : x.2.1 < c.2.1 + · rw [if_pos hlt] + exact ⟨x, rfl, Or.inl rfl, Nat.le_refl _, fun b' h => by cases h; omega⟩ + · rw [if_neg hlt] + split + · rename_i heq + have hxc : x.2.1 = c.2.1 := by + simp only [Bool.and_eq_true, beq_iff_eq] at heq + exact heq.1 + exact ⟨x, rfl, Or.inl rfl, Nat.le_refl _, fun b' h => by cases h; omega⟩ + · exact ⟨c, rfl, Or.inr rfl, by omega, fun b' h => by cases h; omega⟩ + +theorem pick_foldl_spec : + ∀ (l : List (Choice × Nat × ByteArray)) (init : Option (Choice × Nat × ByteArray)) + (o : Choice × Nat × ByteArray), l.foldl pickStep init = some o → + (o ∈ l ∨ init = some o) ∧ (∀ x ∈ l, o.2.1 ≤ x.2.1) ∧ + ∀ b, init = some b → o.2.1 ≤ b.2.1 := by + intro l + induction l with + | nil => + intro init o h + refine ⟨Or.inr h, fun _ hx => (by cases hx), fun b hb => ?_⟩ + simp only [List.foldl_nil] at h + rw [h] at hb + cases hb + omega + | cons x xs ih => + intro init o h + simp only [List.foldl_cons] at h + obtain ⟨s, hs, hsx, hsle, hsinit⟩ := pickStep_spec init x + rw [hs] at h + obtain ⟨hmem, hle, hinit⟩ := ih _ o h + have hos := hinit s rfl + refine ⟨?_, fun y hy => ?_, fun b hb => ?_⟩ + · rcases hmem with hm | hm + · exact Or.inl (List.mem_cons_of_mem _ hm) + · cases hm + rcases hsx with rfl | h' + · exact Or.inl List.mem_cons_self + · exact Or.inr h' + · rcases List.mem_cons.mp hy with rfl | hy + · omega + · exact hle y hy + · have := hsinit b hb + omega + +/-- `pickOption` returns a minimum-cost option. -/ +theorem pickOption_min (opts : Array (Choice × Nat × ByteArray)) {ch : Choice} {c : Nat} + (h : pickOption opts = some (ch, c)) : + (∀ o ∈ opts.toList, c ≤ o.2.1) ∧ ∃ o ∈ opts.toList, o.2.1 = c := by + unfold pickOption at h + rw [← Array.foldl_toList] at h + change (List.foldl pickStep none opts.toList).map _ = _ at h + cases hr : List.foldl pickStep none opts.toList with + | none => rw [hr] at h; cases h + | some o => + rw [hr] at h + simp only [Option.map_some, Option.some.injEq, Prod.mk.injEq] at h + obtain ⟨_, rfl⟩ := h + obtain ⟨hmem, hle, _⟩ := pick_foldl_spec opts.toList none o hr + rcases hmem with hm | hm + · exact ⟨hle, o, hm, rfl⟩ + · cases hm + +theorem pickOption_isSome (opts : Array (Choice × Nat × ByteArray)) (h : opts.size ≠ 0) : + ∃ ch c, pickOption opts = some (ch, c) := by + unfold pickOption + rw [← Array.foldl_toList] + change ∃ ch c, (List.foldl pickStep none opts.toList).map _ = _ + cases hl : opts.toList with + | nil => exact absurd (by simpa using congrArg List.length hl) h + | cons x xs => + obtain ⟨s, hs, _⟩ := pickStep_spec none x + simp only [List.foldl_cons, hs] + suffices hh : ∀ (l : List (Choice × Nat × ByteArray)) (s : Choice × Nat × ByteArray), + ∃ o, List.foldl pickStep (some s) l = some o by + obtain ⟨o, ho⟩ := hh xs s + rw [ho] + exact ⟨o.1, o.2.1, rfl⟩ + intro l + induction l with + | nil => intro s; exact ⟨s, rfl⟩ + | cons y ys ih => + intro s + obtain ⟨s', hs', _⟩ := pickStep_spec (some s) y + simp only [List.foldl_cons, hs'] + exact ih s' + +/-- The internal-cut options found by `Prep.cutOptions` are the available cuts. -/ +theorem PrepWF.cutOptions_spec {p : Prep} (hp : PrepWF p) {w : Nat} {avail : Nat → Bool} + (ev : DictEval) (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some w else none) + (hindex : ∀ u, (index[u]?.getD none).isSome = avail u) + {t : Nat} (ht : t < p.dag.size) (hf : p.family[t]! ≠ .none) (flag : UInt8) + (hsides : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + ev.sides[spineAt p t k]! = + prefixSides p (uCost p w avail) (spineAt p t k) (p.spineLen[t]! - k)) + (hbelow : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + FirstAvail p avail (spineAt p t k) 1 ev.below[spineAt p t k]!) : + ∀ (fuel j : Nat) (cur : Option Nat) (opts : Array (Choice × Nat × ByteArray)), + 1 ≤ j → j ≤ p.spineLen[t]! → p.spineLen[t]! - j ≤ fuel → FirstAvail p avail t j cur → + ∃ L : List (Choice × Nat × ByteArray), + (p.cutOptions ev index width flag p.spineLen[t]! + (prefixSides p (uCost p w avail) t p.spineLen[t]!) fuel cur opts).toList = + opts.toList ++ L ∧ + L.map (·.2.1) = cutsFrom p w avail (uCost p w avail) t j ∧ + ∀ o ∈ L, o.1 ≠ .share := by + obtain ⟨_, hk, _, _, _⟩ := hp.spine t ht hf + intro fuel + induction fuel with + | zero => + intro j cur opts _ hj hfuel _ + refine ⟨[], by simp [Prep.cutOptions], ?_, fun o ho => by cases ho⟩ + unfold cutsFrom + rw [show p.spineLen[t]! - j = 0 by omega] + rfl + | succ fuel ih => + intro j cur opts hj1 hj hfuel hcur + cases cur with + | none => + exact ⟨[], by simp [Prep.cutOptions], by rw [cutsFrom_nil p w avail _ t j hcur]; rfl, + fun o ho => by cases ho⟩ + | some u => + obtain ⟨k, hjk, hkl, rfl, hav, hnone⟩ := hcur + obtain ⟨_, _, hlenk, _⟩ := hk k hkl + have hcand : tag4Size (p.spineLen[t]! - p.spineLen[spineAt p t k]!) + + (prefixSides p (uCost p w avail) t p.spineLen[t]! - ev.sides[spineAt p t k]!) + + (widthOf width (spineAt p t k)).getD 0 = cutCost p w (uCost p w avail) t k := by + rw [hlenk, hsides k (by omega) hkl, hwidth, if_pos hav] + have hsplit := prefixSides_add p (uCost p w avail) k (p.spineLen[t]! - k) t + rw [show k + (p.spineLen[t]! - k) = p.spineLen[t]! by omega] at hsplit + unfold cutCost + rw [show p.spineLen[t]! - (p.spineLen[t]! - k) = k by omega, hsplit] + simp + have hidx : (index[spineAt p t k]?.getD none).isSome = true := by rw [hindex]; exact hav + simp only [Prep.cutOptions, hidx, if_true] + obtain ⟨L, hL, hcost, hnot⟩ := ih (k + 1) _ _ (by omega) (by omega) (by omega) + (FirstAvail.shift hlenk (hbelow k (by omega) hkl)) + refine ⟨(Choice.cut (p.spineLen[t]! - p.spineLen[spineAt p t k]!), + tag4Size (p.spineLen[t]! - p.spineLen[spineAt p t k]!) + + (prefixSides p (uCost p w avail) t p.spineLen[t]! - ev.sides[spineAt p t k]!) + + (widthOf width (spineAt p t k)).getD 0, + tag4Bytes flag (p.spineLen[t]! - p.spineLen[spineAt p t k]!)) :: L, ?_, ?_, ?_⟩ + · rw [hL]; simp + · rw [List.map_cons, hcost, cutsFrom_split p w avail _ t j k hjk hkl hav hnone] + simp only + rw [hcand] + · intro o ho + rcases List.mem_cons.mp ho with rfl | ho + · simp + · exact hnot o ho + +theorem choice_ne_share {o : Choice × Nat × ByteArray} (h : o.1 ≠ .share) : + (o.1 != .share) = true := by + obtain ⟨c, _, _⟩ := o + cases c with + | share => exact absurd rfl h + | inline => rfl + | cut j => rfl + +/-- The base options (`Share(t)` when `t` has an index) are removed by the +entry filter. -/ +theorem share_opts_filter (index : Array (Option Nat)) (width : Array (Option Nat)) (t : Nat) : + ((match index[t]?.getD none with + | some i => #[(Choice.share, (widthOf width t).getD 0, tag4Bytes Ixon.Expr.FLAG_SHARE i)] + | none => (#[] : Array (Choice × Nat × ByteArray))).toList.filter + (fun (o : Choice × Nat × ByteArray) => o.1 != Choice.share)) = [] := by + split <;> rfl + +theorem pickOption_toList {A B : Array (Choice × Nat × ByteArray)} (h : A.toList = B.toList) : + pickOption A = pickOption B := by + have : A = B := Array.ext' h + rw [this] + +/-- The minimum-cost pick over `x :: L` has cost `min` of the costs. -/ +theorem pickOption_cost (A : Array (Choice × Nat × ByteArray)) (x : Choice × Nat × ByteArray) + (L : List (Choice × Nat × ByteArray)) (h : A.toList = x :: L) : + ((pickOption A).map (·.2)).getD 0 = (L.map (·.2.1)).foldl min x.2.1 := by + obtain ⟨ch, c, hpick⟩ := pickOption_isSome A (by + intro h0; have := congrArg List.length h; simp [h0] at this) + rw [hpick] + obtain ⟨hle, o, ho, hoc⟩ := pickOption_min _ hpick + rw [h] at hle ho + simp only [Option.map_some, Option.getD_some] + symm + apply foldl_min_unique + · rw [← hoc] + rcases List.mem_cons.mp ho with rfl | ho + · exact List.mem_cons_self + · exact List.mem_cons_of_mem _ (List.mem_map_of_mem ho) + · intro y hy + rcases List.mem_cons.mp hy with rfl | hy + · exact hle _ List.mem_cons_self + · obtain ⟨o', ho', rfl⟩ := List.mem_map.mp hy + exact hle _ (List.mem_cons_of_mem _ ho') + +/-- The entry cost used by `materializeDependent` is the model's inline cost. -/ +theorem PrepWF.inlineCost_eq {p : Prep} (hp : PrepWF p) + (hempty : p.empty.cost.size = p.dag.size ∧ p.empty.sides.size = p.dag.size ∧ + p.empty.below.size = p.dag.size) + {w : Nat} {avail : Nat → Bool} (index width : Array (Option Nat)) + (hwidth : ∀ u, widthOf width u = if avail u then some w else none) + (hindex : ∀ u, (index[u]?.getD none).isSome = avail u) (t : Nat) (ht : t < p.dag.size) : + p.inlineCost (p.evalAll width) index width t = uInl p w avail t := by + have hrow : ∀ t', t' < p.dag.size → EvalRow p w avail (p.evalAll width) t' := + hp.evalFrom_spec width hwidth p.empty hempty _ (fun t ht => by simp [ht]) + have hcost : ∀ c, c < p.dag.size → (p.evalAll width).cost[c]! = uCost p w avail c := + fun c hc => (hrow c hc).1 + let base : Array (Choice × Nat × ByteArray) := + match index[t]?.getD none with + | some i => #[(Choice.share, (widthOf width t).getD 0, tag4Bytes Ixon.Expr.FLAG_SHARE i)] + | none => #[] + have hbase : base.toList.filter (fun o => o.1 != Choice.share) = [] := + share_opts_filter index width t + unfold Prep.inlineCost Prep.options uInl + by_cases hf : p.family[t]! = .none + · have hfb : (p.family[t]! == Family.none) = true := by simp [hf] + simp only [hfb, if_true] + have hfold : (p.dag.node t).children.foldl (fun acc c => acc + (p.evalAll width).cost[c]!) + (p.dag.node t).head.ownBytes = inlOf p w avail (uCost p w avail) t := by + unfold inlOf + rw [if_pos hf] + exact foldl_add_congr _ _ fun c hc => + hcost c (by have := hp.dag.child_lt ht hc; omega) + rw [pickOption_cost _ (Choice.inline, inlOf p w avail (uCost p w avail) t, + Ixon.runPut (Ixon.putTagN 4 (p.dag.node t).head.flag (p.dag.node t).head.tag4Field)) []] + · rfl + · rw [Array.toList_filter, Array.toList_push, List.filter_append] + change base.toList.filter _ ++ _ = _ + rw [hbase, hfold] + rfl + · have hfb : (p.family[t]! == Family.none) = false := by simpa using hf + simp only [hfb, Bool.false_eq_true, if_false] + obtain ⟨hs, hb⟩ := (hrow t ht).2 hf + obtain ⟨_, hk, _, htl, _⟩ := hp.spine t ht hf + have hspine : ∀ k, 1 ≤ k → k < p.spineLen[t]! → + EvalRow p w avail (p.evalAll width) (spineAt p t k) ∧ + p.family[spineAt p t k]! ≠ .none ∧ + p.spineLen[spineAt p t k]! = p.spineLen[t]! - k := by + intro k h1 h2 + have hlt' := hp.spineAt_lt ht hf h1 h2 + obtain ⟨_, hkf, hklen, _⟩ := hk k h2 + exact ⟨hrow _ (by omega), by rw [hkf]; exact hf, hklen⟩ + let natOpt : Choice × Nat × ByteArray := + (Choice.cut p.spineLen[t]!, + tag4Size p.spineLen[t]! + (p.evalAll width).sides[t]! + + (p.evalAll width).cost[p.tail[t]!]!, + tag4Bytes (p.dag.node t).head.flag p.spineLen[t]!) + obtain ⟨L, hL, hLcost, hLnot⟩ := hp.cutOptions_spec (p.evalAll width) index width hwidth + hindex ht hf (p.dag.node t).head.flag + (fun k h1 h2 => by + obtain ⟨hr, hfk, hlenk⟩ := hspine k h1 h2 + rw [(hr.2 hfk).1, hlenk]) + (fun k h1 h2 => by + obtain ⟨hr, hfk, _⟩ := hspine k h1 h2 + exact (hr.2 hfk).2) + p.spineLen[t]! 1 _ (base.push natOpt) (Nat.le_refl _) (by omega) (by omega) hb + rw [← hs] at hL + have hnat : natOpt.2.1 = naturalCost p (uCost p w avail) t := by + simp only [natOpt] + rw [hs, hcost _ (by omega)] + rfl + rw [pickOption_cost _ natOpt L] + · rw [hLcost, hnat] + unfold inlOf + rw [if_neg hf, cutCosts_eq] + · simp only [base, natOpt] at hL hbase + rw [Array.toList_filter] + refine (congrArg (List.filter _) hL).trans ?_ + rw [Array.toList_push, List.filter_append, List.filter_append, + hbase, List.filter_eq_self.mpr (fun o ho => choice_ne_share (hLnot o ho))] + rfl + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformOptimal.lean b/Ix/Compile/Verify/UniformOptimal.lean new file mode 100644 index 000000000..7d15c30fa --- /dev/null +++ b/Ix/Compile/Verify/UniformOptimal.lean @@ -0,0 +1,1038 @@ +import Ix.Compile.Verify.UniformSearch + +/-! +# Stage 4: the component cost and its decompositions + +The semantic cost `compCost` of a component (its roots, its certain-stored +entries and the entries of a member set), its relation to the uniform length +(`ulen`), and its modularity over separated groups of members. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (Desc) + +/-! ## Hash sets, sorted merges, partitions -/ + +theorem hashSet_foldl_contains (l : List Nat) (s : Std.HashSet Nat) (t : Nat) : + (l.foldl (fun s x => s.insert x) s).contains t = (s.contains t || decide (t ∈ l)) := by + induction l generalizing s with + | nil => simp + | cons x xs ih => + rw [List.foldl_cons, ih, Std.HashSet.contains_insert] + by_cases hx : x = t + · subst hx; simp + · have : (x == t) = false := by simpa using hx + simp only [this, Bool.false_or, List.mem_cons] + by_cases ht : t ∈ xs + · simp [ht] + · have : t ≠ x := fun h => hx h.symm + simp [ht, this] + +theorem hashSet_ofArray_contains (arr : Array Nat) (t : Nat) : + (arr.foldl (·.insert ·) ({} : Std.HashSet Nat)).contains t = decide (t ∈ arr.toList) := by + rw [← Array.foldl_toList] + have := hashSet_foldl_contains arr.toList {} t + simp only [Std.HashSet.contains_empty, Bool.false_or] at this + exact this + +theorem mergeSorted_perm (a b : Array Nat) : + (mergeSorted a b).toList.Perm (a.toList ++ b.toList) := by + unfold mergeSorted + rw [List.toList_toArray] + exact List.mergeSort_perm _ _ + +theorem mergeSorted_sorted (a b : Array Nat) : + (mergeSorted a b).toList.Pairwise (· ≤ ·) := by + unfold mergeSorted + rw [List.toList_toArray] + have := List.pairwise_mergeSort (le := fun x y : Nat => decide (x ≤ y)) + (fun a b c hab hbc => by simp only [decide_eq_true_eq] at *; omega) + (fun a b => by simp only [Bool.or_eq_true, decide_eq_true_eq]; omega) (a.toList ++ b.toList) + exact this.imp (fun h => by simpa using h) + +theorem partitionCheck_perm {und : Array Nat} {groups : Array (Array Nat)} + (h : partitionCheck und groups = true) : + (groups.toList.flatMap (·.toList)).Perm und.toList := by + unfold partitionCheck at h + have he := of_decide_eq_true (by simpa using h) + have h1 := (List.mergeSort_perm (groups.toList.flatMap (·.toList)) + (fun x y => decide (x ≤ y))).symm + have h2 := List.mergeSort_perm und.toList (fun x y => decide (x ≤ y)) + rw [he] at h1 + exact h1.trans h2 + +/-! ## The component cost -/ + +/-- Availability of a stored member list `V` over the certain-stored terms. -/ +def availOf (opaq : Array Bool) (V : List Nat) : Nat → Bool := + fun u => opaq[u]! || decide (u ∈ V) + +/-- **The component cost** of a member list `V` (stored and available): the +costs of the component's roots, its certain-stored entries and `V`'s entries. -/ +def compCost (dag : Dag) (w : Nat) (opaq : Array Bool) (rootsC storedInC V : List Nat) : Nat := + (rootsC.map (uCost (Prep.ofDag dag) w (availOf opaq V))).sum + + (storedInC.map (uInl (Prep.ofDag dag) w (availOf opaq V))).sum + + (V.map (uInl (Prep.ofDag dag) w (availOf opaq V))).sum + +theorem availOf_perm (opaq : Array Bool) {V V' : List Nat} (h : V.Perm V') : + availOf opaq V = availOf opaq V' := by + funext u; simp only [availOf, h.mem_iff] + +theorem compCost_perm {dag : Dag} {w : Nat} {opaq : Array Bool} {rootsC storedInC : List Nat} + {V V' : List Nat} (h : V.Perm V') : + compCost dag w opaq rootsC storedInC V = compCost dag w opaq rootsC storedInC V' := by + unfold compCost + rw [availOf_perm opaq h, (h.map _).sum_nat] + +theorem availOf_append (opaq : Array Bool) (V V' : List Nat) (u : Nat) : + availOf opaq (V ++ V') u = (availOf opaq V u || decide (u ∈ V')) := by + simp only [availOf, List.mem_append] + by_cases h1 : u ∈ V <;> by_cases h2 : u ∈ V' <;> simp [h1, h2] + +/-- **Modularity of the component cost.** Adding the member lists `D` and +`S` to `I` changes the component cost by the sum of adding each, when every +opaque term is opaque in the four availabilities and no available non-opaque +term reaches both `S` and `D` along non-opaque paths. -/ +theorem compCost_modular {dag : Dag} (hwf : DagWF dag) (w : Nat) (opaq : Array Bool) + (rootsC storedInC : List Nat) (hrc : ∀ r ∈ rootsC, r < dag.size) + (hsc : ∀ c ∈ storedInC, c < dag.size) (O : Nat → Bool) {I D S : List Nat} + (hin : ∀ t ∈ I ++ D ++ S, t < dag.size) + (hop : ∀ X : List Nat, (X = I ∨ X = I ++ D ∨ X = I ++ S ∨ X = I ++ D ++ S) → + OpaqueOn (Prep.ofDag dag) w O (availOf opaq X)) + (hDO : ∀ x ∈ D, O x = false) (hSO : ∀ x ∈ S, O x = false) + (hsep : ∀ v, v < dag.size → availOf opaq (I ++ D ++ S) v = true → O v = false → + Unreached (Prep.ofDag dag) O (fun y => decide (y ∈ S)) v ∨ + Unreached (Prep.ofDag dag) O (fun y => decide (y ∈ D)) v) : + compCost dag w opaq rootsC storedInC (I ++ D ++ S) + compCost dag w opaq rootsC storedInC I = + compCost dag w opaq rootsC storedInC (I ++ D) + + compCost dag w opaq rootsC storedInC (I ++ S) := by + have hp := prepWF_ofDag hwf + let A0 := availOf opaq I + let Z1 : Nat → Bool := fun y => decide (y ∈ S) + let Z2 : Nat → Bool := fun y => decide (y ∈ D) + have e1 : availOf opaq (I ++ S) = addAvail A0 Z1 := by + funext u; simp only [availOf_append, addAvail, A0, Z1] + have e2 : availOf opaq (I ++ D) = addAvail A0 Z2 := by + funext u; simp only [availOf_append, addAvail, A0, Z2] + have e12 : availOf opaq (I ++ D ++ S) = addAvail (addAvail A0 Z1) Z2 := by + funext u; simp only [availOf_append, addAvail, A0, Z1, Z2] + cases availOf opaq I u <;> cases decide (u ∈ D) <;> cases decide (u ∈ S) <;> rfl + have h0 := hop I (Or.inl rfl) + have h1 : OpaqueOn (Prep.ofDag dag) w O (addAvail A0 Z1) := by + rw [← e1]; exact hop _ (Or.inr (Or.inr (Or.inl rfl))) + have h2 : OpaqueOn (Prep.ofDag dag) w O (addAvail A0 Z2) := by + rw [← e2]; exact hop _ (Or.inr (Or.inl rfl)) + have h12 : OpaqueOn (Prep.ofDag dag) w O (addAvail (addAvail A0 Z1) Z2) := by + rw [← e12]; exact hop _ (Or.inr (Or.inr (Or.inr rfl))) + have hsep' : ∀ v, v < (Prep.ofDag dag).dag.size → addAvail (addAvail A0 Z1) Z2 v = true → + O v = false → Unreached (Prep.ofDag dag) O Z1 v ∨ Unreached (Prep.ofDag dag) O Z2 v := by + intro v hv hav hO + rw [← e12] at hav + exact hsep v hv hav hO + have hmod := hp.uCost_modular w O A0 Z1 Z2 h0 h1 h2 h12 hsep' + have hlocD : ∀ t ∈ D, uInl (Prep.ofDag dag) w (addAvail (addAvail A0 Z1) Z2) t = + uInl (Prep.ofDag dag) w (addAvail A0 Z2) t := by + intro t ht + have htn := hin t (by simp [ht]) + have hav : availOf opaq (I ++ D ++ S) t = true := by simp [availOf, ht] + rcases hsep t htn hav (hDO t ht) with hu | hu + · have hagree : ∀ v, NReach (Prep.ofDag dag) O t v → + addAvail (addAvail A0 Z1) Z2 v = addAvail A0 Z2 v := by + intro v hv + have := hu v hv + simp only [addAvail, Z1] at this ⊢ + rw [this] + simp + exact (hp.uCost_local w O t (by rw [ofDag_dag]; exact htn) _ _ h12 h2 hagree).2 + · exact absurd (hu t .refl) (by simp [ht]) + have hlocS : ∀ t ∈ S, uInl (Prep.ofDag dag) w (addAvail (addAvail A0 Z1) Z2) t = + uInl (Prep.ofDag dag) w (addAvail A0 Z1) t := by + intro t ht + have htn := hin t (by simp [ht]) + have hav : availOf opaq (I ++ D ++ S) t = true := by simp [availOf, ht] + rcases hsep t htn hav (hSO t ht) with hu | hu + · exact absurd (hu t .refl) (by simp [ht]) + · exact (hp.uCost_local w O t (by rw [ofDag_dag]; exact htn) _ _ h12 h1 + (agree_of_unreached hu)).2 + unfold compCost + rw [e1, e2, e12] + simp only [List.map_append, List.sum_append] + have hI := congrArg List.sum (List.map_congr_left (l := I) fun t ht => + (hmod t (by rw [ofDag_dag]; exact hin t (by simp [ht]))).2) + have hr := congrArg List.sum (List.map_congr_left (l := rootsC) fun r hr => + (hmod r (by rw [ofDag_dag]; exact hrc r hr)).1) + have hc := congrArg List.sum (List.map_congr_left (l := storedInC) fun c hc => + (hmod c (by rw [ofDag_dag]; exact hsc c hc)).2) + simp only [sum_map_add'] at hI hr hc + rw [List.map_congr_left hlocD, List.map_congr_left hlocS] + simp only [A0] at hI hr hc ⊢ + omega + +/-! ## The component cost is the component's part of the uniform length -/ + +theorem uInl_desc_local {dag : Dag} (hwf : DagWF dag) (w : Nat) {A B : Nat → Bool} {y : Nat} + (hy : y < dag.size) (hag : ∀ v, Desc dag y v → A v = B v) : + uInl (Prep.ofDag dag) w A y = uInl (Prep.ofDag dag) w B y := by + have hp := prepWF_ofDag hwf + let O : Nat → Bool := fun _ => false + have hOA : ∀ (C : Nat → Bool), OpaqueOn (Prep.ofDag dag) w O C := fun C u _ hu => by + simp [O] at hu + exact (hp.uCost_local w O y hy A B (hOA A) (hOA B) + (fun v hv => hag v (NReach.desc hwf hy hv))).2 + +theorem sum_filter_split (f : Nat → Nat) (q : Nat → Bool) : + ∀ l : List Nat, (l.map f).sum = ((l.filter q).map f).sum + ((l.filter (!q ·)).map f).sum + | [] => rfl + | x :: xs => by + have := sum_filter_split f q xs + cases hx : q x <;> simp [hx] <;> omega + +theorem availOf_eq_mem {opaq : Array Bool} {cs : List Nat} (hcs : ∀ u, opaq[u]! = decide (u ∈ cs)) + (V : List Nat) : availOf opaq V = fun u => decide (u ∈ cs ++ V) := by + funext u; simp only [availOf, hcs, List.mem_append] + by_cases h1 : u ∈ cs <;> by_cases h2 : u ∈ V <;> simp [h1, h2] + +/-- **The component cost is the component's part of the length.** With +`opaq` the certain-stored list `cs`, adding a list `V` of the component's +members to `cs` changes the uniform length (without the count's TagN) by the +change of the component cost. -/ +theorem ulen_compCost {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) {opaq : Array Bool} {cs : List Nat} + (hcs : ∀ u, opaq[u]! = decide (u ∈ cs)) (hcsn : cs.Nodup) (hcsb : ∀ c ∈ cs, c < dag.size) + (members : Array Nat) {V : List Nat} (hV : ∀ t ∈ V, t ∈ members.toList) : + ulen dag w roots (cs ++ V) + tag0Size cs.length + + compCost dag w opaq + (roots.toList.filter ((markTable dag.size + (upClosure dag ((markTable dag.size members)[·]!)))[·]!)) + ((upClosure dag ((markTable dag.size members)[·]!)).toList.filter (opaq[·]!)) [] = + ulen dag w roots cs + tag0Size (cs ++ V).length + + compCost dag w opaq + (roots.toList.filter ((markTable dag.size + (upClosure dag ((markTable dag.size members)[·]!)))[·]!)) + ((upClosure dag ((markTable dag.size members)[·]!)).toList.filter (opaq[·]!)) V := by + generalize hclo : upClosure dag ((markTable dag.size members)[·]!) = clo + have hclo_mem : ∀ t, t ∈ clo.toList ↔ t < dag.size ∧ + ∃ m, (markTable dag.size members)[m]! = true ∧ Desc dag t m := by + intro t; rw [← hclo]; exact mem_upClosure hwf _ t + let inC : Nat → Bool := ((markTable dag.size clo)[·]!) + have hinC : ∀ t, inC t = true ↔ t ∈ clo.toList := by + intro t + show (markTable dag.size clo)[t]! = true ↔ _ + rw [markTable_spec, Array.mem_toList_iff] + constructor + · exact fun h => h.1 + · intro h; exact ⟨h, ((hclo_mem t).mp (Array.mem_toList_iff.mpr h)).1⟩ + -- terms outside the closure do not see `V` + have hout : ∀ t, t < dag.size → inC t = false → + ∀ v, Desc dag t v → availOf opaq V v = availOf opaq [] v := by + intro t ht hc v hv + simp only [availOf, List.not_mem_nil, decide_false, Bool.or_false] + by_cases hvV : v ∈ V + · exfalso + have hvm := hV v hvV + have hvn : v < dag.size := Nat.lt_of_le_of_lt (Desc.le_of_wf hwf hv ht) ht + have : t ∈ clo.toList := (hclo_mem t).mpr ⟨ht, v, + (markTable_spec _ _ _).mpr ⟨Array.mem_toList_iff.mp hvm, hvn⟩, hv⟩ + rw [← hinC] at this + rw [this] at hc; cases hc + · simp [hvV] + have hcsC : (cs.filter inC).Perm (clo.toList.filter (opaq[·]!)) := by + have hclon : clo.toList.Nodup := by + rw [← hclo] + exact (upClosure_sorted _ _).imp (fun h => Nat.ne_of_lt h) + apply (List.perm_ext_iff_of_nodup (List.Nodup.sublist (List.filter_sublist) hcsn) + (List.Nodup.sublist (List.filter_sublist) hclon)).mpr + intro t + simp only [List.mem_filter, hinC, hcs, decide_eq_true_eq] + exact ⟨fun h => ⟨h.2, h.1⟩, fun h => ⟨h.2, h.1⟩⟩ + have e0 : (fun y => decide (y ∈ cs)) = availOf opaq [] := by + rw [availOf_eq_mem hcs [], List.append_nil] + unfold ulen uniformCost compCost + rw [← availOf_eq_mem hcs V, e0] + simp only [List.map_append, List.sum_append, List.length_append] + -- split the roots and the certain-stored entries by the closure + rw [sum_filter_split (uCost (Prep.ofDag dag) w (availOf opaq V)) inC roots.toList, + sum_filter_split (uCost (Prep.ofDag dag) w (availOf opaq [])) inC roots.toList, + sum_filter_split (uInl (Prep.ofDag dag) w (availOf opaq V)) inC cs, + sum_filter_split (uInl (Prep.ofDag dag) w (availOf opaq [])) inC cs, + (hcsC.map _).sum_nat, (hcsC.map _).sum_nat] + have hr : ((roots.toList.filter (!inC ·)).map (uCost (Prep.ofDag dag) w (availOf opaq V))).sum = + ((roots.toList.filter (!inC ·)).map (uCost (Prep.ofDag dag) w (availOf opaq []))).sum := by + congr 1 + apply List.map_congr_left + intro r hr + rw [List.mem_filter] at hr + have hrn := hroots r hr.1 + exact uCost_desc_local hwf w hrn (hout r hrn (by simpa using hr.2)) + have hc : ((cs.filter (!inC ·)).map (uInl (Prep.ofDag dag) w (availOf opaq V))).sum = + ((cs.filter (!inC ·)).map (uInl (Prep.ofDag dag) w (availOf opaq []))).sum := by + congr 1 + apply List.map_congr_left + intro c hc + rw [List.mem_filter] at hc + have hcn := hcsb c hc.1 + exact uInl_desc_local hwf w hcn (hout c hcn (by simpa using hc.2)) + rw [hr, hc] + simp only [inC, List.map_nil, List.sum_nil] at * + omega + +/-! ## The global classification -/ + +/-- The search candidates. -/ +def ucand (dag : Dag) (roots : Array Nat) (w : Nat) : Array Bool := + searchCandidates (Prep.ofDag dag) (graphFacts dag roots) w + +/-- The classification at threshold `θ`. -/ +def ucls (dag : Dag) (roots : Array Nat) (w : Nat) (θ : _root_.Int) : Array UClass := + classifyWith (Prep.ofDag dag) (graphFacts dag roots) w + (uniformBounds (Prep.ofDag dag) w (ucand dag roots w)) (visibleCounts dag roots (ucand dag roots w)) θ + +theorem ulen_perm {dag : Dag} {w : Nat} {roots : Array Nat} {Y Y' : List Nat} (h : Y.Perm Y') : + ulen dag w roots Y = ulen dag w roots Y' := by + unfold ulen uniformCost + have hm : (fun y => decide (y ∈ Y)) = (fun y => decide (y ∈ Y')) := by + funext y; simp only [h.mem_iff] + rw [hm, h.length_eq, (h.map _).sum_nat] + +/-- **Splitting off a component.** Adding a list `V` of a component's members +to `cs ++ R` (`R` uncertain terms of other components) changes the uniform +length (without the count's TagN) by the change of the component cost. -/ +theorem ulen_split_component {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) (w : Nat) (θ : _root_.Int) (hθ : 1 ≤ θ) + {opaq : Array Bool} {cs : List Nat} + (hcs : ∀ u, opaq[u]! = decide (u ∈ cs)) (hcsn : cs.Nodup) + (hcsc : ∀ t ∈ cs, t < dag.size ∧ (ucls dag roots w θ)[t]! = .certainStored) + (members : Array Nat) (comp : Nat → Nat) (i : Nat) + (hcomp : ∀ a b, a < dag.size → (ucls dag roots w θ)[a]! = .uncertain → + (ucls dag roots w θ)[b]! = .uncertain → NReach (Prep.ofDag dag) (opaq[·]!) a b → + comp a = comp b) + {V R : List Nat} + (hV : ∀ t ∈ V, t ∈ members.toList ∧ t < dag.size ∧ (ucls dag roots w θ)[t]! = .uncertain ∧ + comp t = i) + (hR : ∀ t ∈ R, t < dag.size ∧ (ucls dag roots w θ)[t]! = .uncertain ∧ comp t ≠ i) : + ulen dag w roots (cs ++ V ++ R) + tag0Size (cs ++ R).length + + compCost dag w opaq + (roots.toList.filter ((markTable dag.size + (upClosure dag ((markTable dag.size members)[·]!)))[·]!)) + ((upClosure dag ((markTable dag.size members)[·]!)).toList.filter (opaq[·]!)) [] = + ulen dag w roots (cs ++ R) + tag0Size (cs ++ V ++ R).length + + compCost dag w opaq + (roots.toList.filter ((markTable dag.size + (upClosure dag ((markTable dag.size members)[·]!)))[·]!)) + ((upClosure dag ((markTable dag.size members)[·]!)).toList.filter (opaq[·]!)) V := by + have hO : (opaq[·]!) = (fun y => decide (y ∈ cs)) := by funext y; exact hcs y + have hcm := components_modular hwf roots hroots w θ hθ (cs := cs) (z1 := V) (z2 := R) + (fun t ht => hcsc t ht) + (fun t ht => by + rcases List.mem_append.mp ht with h | h + · exact ⟨(hV t h).2.1, (hV t h).2.2.1⟩ + · exact ⟨(hR t h).1, (hR t h).2.1⟩) + comp + (fun a b ha hb hab => by + have han : a < dag.size := by + rcases List.mem_append.mp ha with h | h + · exact (hV a h).2.1 + · exact (hR a h).1 + have hua : (ucls dag roots w θ)[a]! = .uncertain := by + rcases List.mem_append.mp ha with h | h + · exact (hV a h).2.2.1 + · exact (hR a h).2.1 + have hub : (ucls dag roots w θ)[b]! = .uncertain := by + rcases List.mem_append.mp hb with h | h + · exact (hV b h).2.2.1 + · exact (hR b h).2.1 + rw [← hO] at hab + exact hcomp a b han hua hub hab) + (fun a ha b hb => by rw [(hV a ha).2.2.2]; exact fun h => (hR b hb).2.2 h.symm) + have huc := ulen_compCost hwf roots hroots w hcs hcsn (fun c hc => (hcsc c hc).1) members + (V := V) (fun t ht => (hV t ht).1) + omega + +/-! ## The search context of a component -/ + +/-- What the search context of a component satisfies (established by +`uniformChoose`). -/ +structure SCtxWF (dag : Dag) (roots : Array Nat) (w : Nat) (θ : _root_.Int) (cs : List Nat) + (cx : SCtx) : Prop where + prep : cx.up.prep = Prep.ofDag dag + width : cx.up.w = w + opaq : ∀ u, cx.up.opaq[u]! = decide (u ∈ cs) + cand : cx.cand = ucand dag roots w + bounds0 : cx.bounds0 = uniformBounds (Prep.ofDag dag) w (ucand dag roots w) + vis0 : cx.vis0 = visibleCounts dag roots (ucand dag roots w) + mem : ∀ t ∈ cx.members.toList, t < dag.size ∧ (ucls dag roots w θ)[t]! = .uncertain + memNodup : cx.members.toList.Nodup + widthCs_size : cx.widthCs.size = dag.size + widthCs : ∀ u, widthOf cx.widthCs u = if cx.up.opaq[u]! then some cx.up.w else none + allTrue : cx.allTrue = Array.replicate dag.size true + baseEv : cx.baseEv = (Prep.ofDag dag).eval cx.widthCs (Array.replicate dag.size true) + closure : cx.closure = upClosure dag ((markTable dag.size cx.members)[·]!) + rootsC : cx.rootsC = roots.filter ((markTable dag.size cx.closure)[·]!) + storedInC : cx.storedInC = cx.closure.filter (cx.up.opaq[·]!) + theta : cx.theta = θ + +/-- The component cost of a context. -/ +def scost (cx : SCtx) (dag : Dag) (V : List Nat) : Nat := + compCost dag cx.up.w cx.up.opaq cx.rootsC.toList cx.storedInC.toList V + +theorem compAvail_eq_availOf {opaq : Array Bool} {members : Array Nat} {V : List Nat} + (hV : ∀ t ∈ V, t ∈ members.toList) : + compAvail opaq members (fun t => decide (t ∈ V)) = availOf opaq V := by + funext u + simp only [compAvail, availOf] + by_cases hu : u ∈ V + · have := Array.mem_toList_iff.mp (hV u hu) + simp [hu, this] + · simp [hu] + +/-- **`phiE` is the component cost** of the entries it is given, when they are +the available members. -/ +theorem phiE_cost {dag : Dag} (hwf : DagWF dag) {roots : Array Nat} {w : Nat} {θ : _root_.Int} + {cs : List Nat} {cx : SCtx} (hcx : SCtxWF dag roots w θ cs cx) (inArr : Array Nat) + (hin : ∀ t ∈ inArr.toList, t ∈ cx.members.toList) (avail : Nat → Bool) + (havail : ∀ t, avail t = decide (t ∈ inArr.toList)) : + (cx.phiE avail inArr).1 = scost cx dag inArr.toList := by + have hmem : ∀ t ∈ cx.members, t < dag.size := + fun t ht => (hcx.mem t (Array.mem_toList_iff.mpr ht)).1 + have hclo := mem_upClosure hwf ((markTable dag.size cx.members)[·]!) + have hsc : ∀ t ∈ cx.storedInC, t < dag.size := by + intro t ht + rw [hcx.storedInC, Array.mem_filter, hcx.closure] at ht + exact ((hclo t).mp (Array.mem_toList_iff.mpr ht.1)).1 + have havail' : avail = fun t => decide (t ∈ inArr.toList) := funext havail + rw [phiE_spec hwf hcx.prep hcx.widthCs_size hcx.widthCs hcx.allTrue hcx.baseEv hcx.closure hmem + hsc avail inArr (fun x hx => hmem x (Array.mem_toList_iff.mp (hin x (Array.mem_toList_iff.mpr hx))))] + rw [havail', compAvail_eq_availOf hin] + rfl + +/-- **The lower bound of a node.** `phiE` with the undecided members also +available, but only the decided entries paid, is at most the component cost +of every completion. -/ +theorem phiE_lower {dag : Dag} (hwf : DagWF dag) {roots : Array Nat} {w : Nat} {θ : _root_.Int} + {cs : List Nat} {cx : SCtx} (hcx : SCtxWF dag roots w θ cs cx) (inArr : Array Nat) + (U : List Nat) (hin : ∀ t ∈ inArr.toList, t ∈ cx.members.toList) + (hU : ∀ t ∈ U, t ∈ cx.members.toList) (avail : Nat → Bool) + (havail : ∀ t, avail t = decide (t ∈ inArr.toList ∨ t ∈ U)) {X : List Nat} + (hX : ∀ t ∈ X, t ∈ U) : + (cx.phiE avail inArr).1 ≤ scost cx dag (inArr.toList ++ X) := by + have hp := prepWF_ofDag hwf + have hmem : ∀ t ∈ cx.members, t < dag.size := + fun t ht => (hcx.mem t (Array.mem_toList_iff.mpr ht)).1 + have hclo := mem_upClosure hwf ((markTable dag.size cx.members)[·]!) + have hsc : ∀ t ∈ cx.storedInC, t < dag.size := by + intro t ht + rw [hcx.storedInC, Array.mem_filter, hcx.closure] at ht + exact ((hclo t).mp (Array.mem_toList_iff.mpr ht.1)).1 + have hinU : ∀ t ∈ inArr.toList ++ U, t ∈ cx.members.toList := by + intro t ht + rcases List.mem_append.mp ht with h | h + · exact hin t h + · exact hU t h + have havail' : avail = fun t => decide (t ∈ inArr.toList ++ U) := by + funext t; rw [havail]; simp [List.mem_append] + rw [phiE_spec hwf hcx.prep hcx.widthCs_size hcx.widthCs hcx.allTrue hcx.baseEv hcx.closure hmem + hsc avail inArr (fun x hx => hmem x (Array.mem_toList_iff.mp (hin x (Array.mem_toList_iff.mpr hx))))] + rw [havail', compAvail_eq_availOf hinU] + unfold scost compCost + -- more availability lowers every cost + have hsub : ∀ v, availOf cx.up.opaq (inArr.toList ++ X) v = true → + availOf cx.up.opaq (inArr.toList ++ U) v = true := by + intro v hv + simp only [availOf, Bool.or_eq_true, decide_eq_true_eq, List.mem_append] at hv ⊢ + rcases hv with h | h | h + · exact Or.inl h + · exact Or.inr (Or.inl h) + · exact Or.inr (Or.inr (hX v h)) + have hlt : ∀ t, t ∈ cx.members.toList → t < (Prep.ofDag dag).dag.size := by + intro t ht; rw [ofDag_dag]; exact (hcx.mem t ht).1 + have hr := sum_le_sum_of_le cx.rootsC.toList (f := uCost (Prep.ofDag dag) cx.up.w + (availOf cx.up.opaq (inArr.toList ++ U))) + (g := uCost (Prep.ofDag dag) cx.up.w (availOf cx.up.opaq (inArr.toList ++ X))) + (fun r hr => by + by_cases hrn : r < dag.size + · exact (hp.costs_antitone cx.up.w hsub (by rw [ofDag_dag]; exact hrn)).1 + · rw [uCost_of_ge _ _ _ (by rw [ofDag_dag]; omega), + uCost_of_ge _ _ _ (by rw [ofDag_dag]; omega)] + exact Nat.le_refl 0) + have hc := sum_le_sum_of_le cx.storedInC.toList (f := uInl (Prep.ofDag dag) cx.up.w + (availOf cx.up.opaq (inArr.toList ++ U))) + (g := uInl (Prep.ofDag dag) cx.up.w (availOf cx.up.opaq (inArr.toList ++ X))) + (fun c hc => (hp.costs_antitone cx.up.w hsub (by + rw [ofDag_dag]; exact hsc c (Array.mem_toList_iff.mp hc))).2) + have he := sum_le_sum_of_le inArr.toList (f := uInl (Prep.ofDag dag) cx.up.w + (availOf cx.up.opaq (inArr.toList ++ U))) + (g := uInl (Prep.ofDag dag) cx.up.w (availOf cx.up.opaq (inArr.toList ++ X))) + (fun x hx => (hp.costs_antitone cx.up.w hsub (hlt x (hin x hx))).2) + simp only [List.map_append, List.sum_append] + omega + +/-! ## Opaque terms of a decided context -/ + +/-- The maybe-stored set of a decided-out list. -/ +def msOf (cand : Array Bool) (O : Array Nat) : Array Bool := + O.foldl (fun acc t => acc.set! t false) cand + +theorem msOf_spec (cand : Array Bool) (O : Array Nat) (v : Nat) : + (msOf cand O)[v]! = true ↔ cand[v]! = true ∧ v ∉ O.toList := by + unfold msOf + rw [← Array.foldl_toList, foldl_setBang_const] + by_cases hv : v ∈ O.toList + · by_cases hs : v < cand.size + · simp [hv, hs] + · simp only [hv, hs, and_false, if_false, not_true_eq_false, and_false, iff_false] + simp [hs] + · simp [hv] + +theorem opaqueArr_spec (cx : SCtx) (I O : Array Nat) (t : Nat) : + (cx.opaqueArr I O)[t]! = + (cx.up.opaq[t]! || (decide (t ∈ I.toList) && decide (t < cx.up.opaq.size) && + cx.opaqueUnder (cx.rebound (msOf cx.cand O)) t)) := by + unfold SCtx.opaqueArr + rw [← Array.foldl_toList, foldl_setBang_or] + rfl + +/-- **The opaque terms of a decided context are opaque** in every +availability within its maybe-stored set that contains the certain-stored +terms and the decided-stored ones. -/ +theorem opaqueArr_opaqueOn {dag : Dag} (hwf : DagWF dag) {roots : Array Nat} + (hroots : ∀ r ∈ roots.toList, r < dag.size) {w : Nat} {θ : _root_.Int} (hθ : 1 ≤ θ) + {cs : List Nat} {cx : SCtx} (hcx : SCtxWF dag roots w θ cs cx) + (hcsc : ∀ t ∈ cs, t < dag.size ∧ (ucls dag roots w θ)[t]! = .certainStored) + {I O : Array Nat} {A : Nat → Bool} + (hA : ∀ v, A v = true → (ucand dag roots w)[v]! = true ∧ v ∉ O.toList) + (hAin : ∀ t ∈ I.toList, A t = true) (hAcs : ∀ t ∈ cs, A t = true) : + OpaqueOn (Prep.ofDag dag) w ((cx.opaqueArr I O)[·]!) A := by + have hp := prepWF_ofDag hwf + intro t ht hO + rw [ofDag_dag] at ht + simp only at hO + rw [opaqueArr_spec] at hO + simp only [Bool.or_eq_true, Bool.and_eq_true, decide_eq_true_eq] at hO + rcases hO with hcs | ⟨⟨htI, _⟩, hun⟩ + · rw [hcx.opaq] at hcs + have htcs : t ∈ cs := by simpa using hcs + exact certainStored_opaque hwf roots hroots w θ hθ ht (hcsc t htcs).2 (hAcs t htcs) + (fun v hv => (hA v hv).1) + · generalize hmsd : msOf cx.cand O = ms at hun + have hms : ∀ v : Nat, ms[v]! = true → (ucand dag roots w)[v]! = true := by + intro v hv + rw [← hmsd] at hv + have := (msOf_spec cx.cand O v).mp hv + rw [hcx.cand] at this + exact this.1 + have hAms : ∀ v, A v = true → ms[v]! = true := by + intro v hv + rw [← hmsd] + apply (msOf_spec cx.cand O v).mpr + rw [hcx.cand] + exact hA v hv + have hble : BLe (cx.rebound ms) (uniformBounds (Prep.ofDag dag) w ms) := by + unfold SCtx.rebound + rw [hcx.prep, hcx.width, hcx.bounds0, ← Array.foldl_toList] + exact hp.boundsFold_le w cx.area.toList _ + (uniformBounds_antitone (Prep.ofDag dag) w hms) (uniformBounds_size _ _ _) + have hbs := hp.bounds_sound w ms A hAms t (by rw [ofDag_dag]; exact ht) + unfold SCtx.opaqueUnder at hun + rw [hcx.prep, hcx.width] at hun + refine ⟨hAin t htI, fun hf => ?_, fun hf => ?_⟩ + · have hfb : ((Prep.ofDag dag).family[t]! == .none) = true := by simp [hf] + rw [if_pos hfb] at hun + have h1 := (hble t).1 + have h2 := hbs.2.1 + simp only [ge_iff_le, decide_eq_true_eq] at hun + omega + · have hfb : ((Prep.ofDag dag).family[t]! == .none) = false := by simpa using hf + rw [if_neg (by simp [hfb])] at hun + have h1 := (hble t).2.1 + have h2 := (hbs.2.2 hf).1 + simp only [ge_iff_le, decide_eq_true_eq] at hun + omega + +/-- Certain-stored and uncertain terms are candidates. -/ +theorem ucand_of_ucls {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} {t : Nat} + (ht : t < dag.size) + (h : (ucls dag roots w θ)[t]! = .certainStored ∨ (ucls dag roots w θ)[t]! = .uncertain) : + (ucand dag roots w)[t]! = true := by + have h1 : (ucls dag roots w θ)[t]! ≠ .certainExcluded := by + rcases h with h | h <;> rw [h] <;> exact fun h => by cases h + have h2 : (ucls dag roots w θ)[t]! ≠ .lowDegree := by + rcases h with h | h <;> rw [h] <;> exact fun h => by cases h + simp only [ucls, classifyWith] at h1 h2 + rw [getElem!_range_map _ (by rw [ofDag_dag]; exact ht)] at h1 h2 + unfold ucand searchCandidates + rw [getElem!_range_map _ (by rw [ofDag_dag]; exact ht)] + simp only [Bool.and_eq_true, Bool.not_eq_true', decide_eq_true_eq] + by_cases hce : certainExcludedTest (Prep.ofDag dag) (graphFacts dag roots) w t = true + · exact absurd (by rw [if_pos hce]) h1 + · rw [if_neg hce] at h1 h2 + by_cases hdeg : (graphFacts dag roots).deg[t]! < 2 + · exact absurd (by rw [if_pos hdeg]) h2 + · exact ⟨by simpa using hce, by omega⟩ + +/-- **Groups are modular.** If a group passes the separation check under the +reduced context `(I, O)`, adding a part `S` of the group and a list `D` of +other members (outside the group and the context) to `I` is additive. -/ +theorem group_modular {dag : Dag} (hwf : DagWF dag) {roots : Array Nat} + (hroots : ∀ r ∈ roots.toList, r < dag.size) {w : Nat} {θ : _root_.Int} (hθ : 1 ≤ θ) + {cs : List Nat} {cx : SCtx} (hcx : SCtxWF dag roots w θ cs cx) + (hcsc : ∀ t ∈ cs, t < dag.size ∧ (ucls dag roots w θ)[t]! = .certainStored) + {g I O : Array Nat} (hchk : cx.sepCheck g I O = true) + (hI : ∀ t ∈ I.toList, t ∈ cx.members.toList ∧ t ∉ O.toList) + (hO : ∀ t ∈ O.toList, t ∈ cx.members.toList) + {D S : List Nat} + (hD : ∀ t ∈ D, t ∈ cx.members.toList ∧ t ∉ g.toList ∧ t ∉ I.toList ∧ t ∉ O.toList) + (hS : ∀ t ∈ S, t ∈ g.toList) : + scost cx dag (I.toList ++ D ++ S) + scost cx dag I.toList = + scost cx dag (I.toList ++ D) + scost cx dag (I.toList ++ S) := by + have hdag : cx.up.prep.dag = dag := by rw [hcx.prep]; rfl + obtain ⟨ha, hb⟩ := sepCheck_spec (cx := cx) (by rw [hdag]; exact hwf) + (by rw [hdag, hcx.closure]) + (by intro t ht; rw [hdag]; exact (hcx.mem t (Array.mem_toList_iff.mpr ht)).1) hchk + rw [hdag] at ha hb + -- members are uncertain, so not certain-stored + have hmemcs : ∀ t ∈ cx.members.toList, t ∉ cs := by + intro t ht hcs + have h1 := (hcsc t hcs).2 + rw [(hcx.mem t ht).2] at h1 + cases h1 + have hmemcand : ∀ t ∈ cx.members.toList, (ucand dag roots w)[t]! = true := + fun t ht => ucand_of_ucls (hcx.mem t ht).1 (Or.inr (hcx.mem t ht).2) + have hcscand : ∀ t ∈ cs, (ucand dag roots w)[t]! = true := + fun t ht => ucand_of_ucls (hcsc t ht).1 (Or.inl (hcsc t ht).2) + have hgm : ∀ t ∈ g.toList, t ∈ cx.members.toList ∧ t < dag.size ∧ t ∉ I ∧ t ∉ O := + fun t ht => ⟨Array.mem_toList_iff.mpr (ha t (Array.mem_toList_iff.mp ht)).1, + (ha t (Array.mem_toList_iff.mp ht)).2⟩ + have hall : ∀ t ∈ I.toList ++ D ++ S, t ∈ cx.members.toList ∧ t ∉ O.toList := by + intro t ht + rcases List.mem_append.mp ht with ht | ht + · rcases List.mem_append.mp ht with ht | ht + · exact hI t ht + · exact ⟨(hD t ht).1, (hD t ht).2.2.2⟩ + · obtain ⟨h1, _, _, h4⟩ := hgm t (hS t ht) + exact ⟨h1, fun h => h4 (Array.mem_toList_iff.mp h)⟩ + let OR : Nat → Bool := ((cx.opaqueArr I O)[·]!) + have hORcs : ∀ v, cx.up.opaq[v]! = true → OR v = true := by + intro v hv + show (cx.opaqueArr I O)[v]! = true + rw [opaqueArr_spec, hv, Bool.true_or] + have hORfalse : ∀ v, v ∉ cs → v ∉ I.toList → OR v = false := by + intro v h1 h2 + show (cx.opaqueArr I O)[v]! = false + rw [opaqueArr_spec, hcx.opaq] + simp [h1, h2] + have hop : ∀ X : List Nat, + (X = I.toList ∨ X = I.toList ++ D ∨ X = I.toList ++ S ∨ X = I.toList ++ D ++ S) → + OpaqueOn (Prep.ofDag dag) w OR (availOf cx.up.opaq X) := by + intro X hX + have hXs : ∀ t ∈ X, t ∈ I.toList ++ D ++ S := by + intro t ht + rcases hX with rfl | rfl | rfl | rfl + · simp [ht] + · rcases List.mem_append.mp ht with h | h <;> simp [h] + · rcases List.mem_append.mp ht with h | h <;> simp [h] + · exact ht + apply opaqueArr_opaqueOn hwf hroots hθ hcx hcsc + · intro v hv + simp only [availOf, Bool.or_eq_true, decide_eq_true_eq] at hv + rcases hv with hv | hv + · rw [hcx.opaq] at hv + have hvcs : v ∈ cs := by simpa using hv + refine ⟨hcscand v hvcs, fun hvO => ?_⟩ + exact hmemcs v (hO v hvO) hvcs + · obtain ⟨h1, h2⟩ := hall v (hXs v hv) + exact ⟨hmemcand v h1, h2⟩ + · intro t ht + simp only [availOf, Bool.or_eq_true, decide_eq_true_eq] + right + rcases hX with rfl | rfl | rfl | rfl <;> simp [ht] + · intro t ht + simp only [availOf, Bool.or_eq_true, decide_eq_true_eq] + left + rw [hcx.opaq]; simp [ht] + have hmod := compCost_modular hwf w cx.up.opaq cx.rootsC.toList cx.storedInC.toList + (by + intro r hr + rw [hcx.rootsC, Array.toList_filter, List.mem_filter] at hr + exact hroots r hr.1) + (by + intro c hc + rw [hcx.storedInC, Array.toList_filter, List.mem_filter, hcx.closure] at hc + exact ((mem_upClosure hwf _ c).mp hc.1).1) + OR (I := I.toList) (D := D) (S := S) + (fun t ht => (hcx.mem t (hall t ht).1).1) + hop + (fun x hx => hORfalse x (hmemcs x (hD x hx).1) (hD x hx).2.2.1) + (fun x hx => hORfalse x (hmemcs x (hgm x (hS x hx)).1) + (fun h => (hgm x (hS x hx)).2.2.1 (Array.mem_toList_iff.mp h))) + (by + intro v hv hav hOv + have hvcs : v ∉ cs := by + intro h + have := hORcs v (by rw [hcx.opaq]; simp [h]) + rw [this] at hOv; cases hOv + have hvX : v ∈ I.toList ++ D ++ S := by + simp only [availOf, Bool.or_eq_true, decide_eq_true_eq] at hav + rcases hav with h | h + · rw [hcx.opaq] at h; exact absurd (by simpa using h) hvcs + · exact h + obtain ⟨hvm, hvO⟩ := hall v hvX + refine Classical.byContradiction (fun hne => ?_) + simp only [Unreached, not_or, Classical.not_forall] at hne + obtain ⟨⟨a, haR, haS⟩, ⟨b, hbR, hbD⟩⟩ := hne + simp only [Bool.not_eq_false, decide_eq_true_eq] at haS hbD + obtain ⟨hbm, hbg, hbI, hbO⟩ := hD b hbD + exact hb v (Array.mem_toList_iff.mp hvm) (fun h => hvO (Array.mem_toList_iff.mpr h)) hOv + a b haR hbR (Array.mem_toList_iff.mp (hS a haS)) (Array.mem_toList_iff.mp hbm) + (fun h => hbg (Array.mem_toList_iff.mpr h)) (fun h => hbI (Array.mem_toList_iff.mpr h)) + (fun h => hbO (Array.mem_toList_iff.mpr h))) + unfold scost + rw [hcx.width] + exact hmod + +/-! ## The global setting and the shape of a minimum -/ + +/-- The uncertain terms. -/ +def uunc (dag : Dag) (roots : Array Nat) (w : Nat) (θ : _root_.Int) : List Nat := + (List.range dag.size).filter (fun t => (ucls dag roots w θ)[t]! == .uncertain) + +/-- The always-sound certain-stored threshold of `uniformStage`: one more than +the largest growth of the table count's TagN below the number of candidates. -/ +def uthetaMax (dag : Dag) (roots : Array Nat) (w : Nat) : _root_.Int := + (tag0StepBound ((ucand dag roots w).filter id).size : _root_.Int) + 1 + +/-- The optimizer's global checks and choices, and the telescope-spine bound +(`SpinesFit`) under which the certain-excluded class is sound. -/ +structure GlobalWF (dag : Dag) (roots : Array Nat) (w : Nat) (θ : _root_.Int) (cs : List Nat) : + Prop where + wf : DagWF dag + spines : SpinesFit (Prep.ofDag dag) + hroots : ∀ r ∈ roots.toList, r < dag.size + reach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y + theta : θ = uthetaMax dag roots w ∨ (θ = 1 ∧ tag0Size ((ucand dag roots w).filter id).size = + tag0Size ((ucls dag roots w (uthetaMax dag roots w)).filter (· == .certainStored)).size) + cs : cs = (List.range dag.size).filter (fun t => (ucls dag roots w θ)[t]! == .certainStored) + +theorem ucls_eq {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} {t : Nat} + (ht : t < dag.size) : + (ucls dag roots w θ)[t]! = + if certainExcludedTest (Prep.ofDag dag) (graphFacts dag roots) w t then .certainExcluded + else if (graphFacts dag roots).deg[t]! < 2 then .lowDegree + else if storedGainWith (Prep.ofDag dag) (uniformBounds (Prep.ofDag dag) w (ucand dag roots w)) w t + (visibleCounts dag roots (ucand dag roots w)).1[t]! + (visibleCounts dag roots (ucand dag roots w)).2[t]! ≥ θ then .certainStored + else .uncertain := by + simp only [ucls, classifyWith] + rw [getElem!_range_map _ (by rw [ofDag_dag]; exact ht)] + +theorem GlobalWF.mem_cs {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} + {cs : List Nat} (hG : GlobalWF dag roots w θ cs) (t : Nat) : + t ∈ cs ↔ t < dag.size ∧ (ucls dag roots w θ)[t]! = .certainStored := by + rw [hG.cs, List.mem_filter, List.mem_range] + constructor + · rintro ⟨h1, h2⟩; exact ⟨h1, uclass_eq_of_beq h2⟩ + · rintro ⟨h1, h2⟩; exact ⟨h1, by rw [h2]; exact uclass_beq_self _⟩ + +theorem mem_uunc {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} (t : Nat) : + t ∈ uunc dag roots w θ ↔ t < dag.size ∧ (ucls dag roots w θ)[t]! = .uncertain := by + rw [uunc, List.mem_filter, List.mem_range] + constructor + · rintro ⟨h1, h2⟩; exact ⟨h1, uclass_eq_of_beq h2⟩ + · rintro ⟨h1, h2⟩; exact ⟨h1, by rw [h2]; exact uclass_beq_self _⟩ + +theorem GlobalWF.cs_nodup {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} + {cs : List Nat} (hG : GlobalWF dag roots w θ cs) : cs.Nodup := by + rw [hG.cs]; exact List.nodup_range.sublist List.filter_sublist + +theorem uunc_nodup (dag : Dag) (roots : Array Nat) (w : Nat) (θ : _root_.Int) : + (uunc dag roots w θ).Nodup := + List.nodup_range.sublist List.filter_sublist + +/-- Certain-stored and uncertain terms have in-degree at least 2. -/ +theorem deg_of_ucls {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} {t : Nat} + (ht : t < dag.size) + (h : (ucls dag roots w θ)[t]! = .certainStored ∨ (ucls dag roots w θ)[t]! = .uncertain) : + 2 ≤ (graphFacts dag roots).deg[t]! := by + rw [ucls_eq ht] at h + by_cases hce : certainExcludedTest (Prep.ofDag dag) (graphFacts dag roots) w t = true + · rw [if_pos hce] at h; rcases h with h | h <;> cases h + · rw [if_neg hce] at h + by_cases hdeg : (graphFacts dag roots).deg[t]! < 2 + · rw [if_pos hdeg] at h; rcases h with h | h <;> cases h + · omega + +/-- The threshold condition of `classify_sound` at a candidate a minimum omits. -/ +theorem GlobalWF.theta_ok {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} + {cs : List Nat} (hG : GlobalWF dag roots w θ cs) {X : List Nat} + (hX : IsMinimum dag w roots X) {t : Nat} (htn : t < dag.size) + (hc : (ucand dag roots w)[t]! = true) (htX : t ∉ X) : + θ = uthetaMax dag roots w ∨ (θ = 1 ∧ tag0Size (X.length + 1) = tag0Size X.length) := by + rcases hG.theta with h | ⟨h1, h2⟩ + · exact Or.inl h + · exact Or.inr ⟨h1, threshold_one_sound hG.wf hG.spines roots hG.hroots hG.reach w hX htn h2 hc + htX⟩ + +/-- The threshold is at least 1. -/ +theorem GlobalWF.one_le_theta {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} + {cs : List Nat} (hG : GlobalWF dag roots w θ cs) : 1 ≤ θ := by + rcases hG.theta with h | ⟨h, _⟩ + · rw [h]; unfold uthetaMax; omega + · omega + +/-- **Every minimum contains the certain-stored terms.** -/ +theorem GlobalWF.min_cs {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} + {cs : List Nat} (hG : GlobalWF dag roots w θ cs) {X : List Nat} + (hX : IsMinimum dag w roots X) {t : Nat} (ht : t ∈ cs) : t ∈ X := by + obtain ⟨htn, hcls⟩ := (hG.mem_cs t).mp ht + refine Classical.byContradiction (fun htX => ?_) + have hθ := hG.theta_ok hX htn (ucand_of_ucls htn (Or.inl hcls)) htX + exact htX ((classify_sound hG.wf hG.spines roots hG.hroots hG.reach w hX htn θ hθ).2 hcls) + +/-- **Every term of a minimum is certain-stored or uncertain.** -/ +theorem GlobalWF.min_class {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} + {cs : List Nat} (hG : GlobalWF dag roots w θ cs) {X : List Nat} + (hX : IsMinimum dag w roots X) {t : Nat} (ht : t ∈ X) : + t < dag.size ∧ ((ucls dag roots w θ)[t]! = .certainStored ∨ + (ucls dag roots w θ)[t]! = .uncertain) := by + obtain ⟨htn, hdeg⟩ := hX.1.2 t ht + refine ⟨htn, ?_⟩ + rw [ucls_eq htn] + by_cases hce : certainExcludedTest (Prep.ofDag dag) (graphFacts dag roots) w t = true + · exfalso + unfold certainExcludedTest at hce + simp only [decide_eq_true_eq] at hce + exact excluded_of_minimum hG.wf hG.spines roots hG.hroots w hX htn hce ht + · rw [if_neg hce, if_neg (by omega)] + split + · exact Or.inl rfl + · exact Or.inr rfl + +theorem nodup_app {a b : List Nat} (ha : a.Nodup) (hb : b.Nodup) (hd : ∀ x ∈ a, x ∉ b) : + (a ++ b).Nodup := + List.nodup_append.mpr ⟨ha, hb, fun x hx _y hy hxy => hd x hx (hxy ▸ hy)⟩ + +theorem strictInc_spec {a : Array Nat} (h : strictInc a = true) : a.toList.Pairwise (· < ·) := by + unfold strictInc at h + rw [List.all_eq_true] at h + have hstep : ∀ j, j + 1 < a.size → a[j]! < a[j + 1]! := by + intro j hj + have := h j (List.mem_range.mpr (by omega)) + simp only [decide_eq_true_eq] at this + exact this hj + have hlt : ∀ x y, x < y → y < a.size → a[x]! < a[y]! := by + intro x y hxy hy + induction y with + | zero => omega + | succ y ih => + have := hstep y hy + by_cases hxy' : x = y + · subst hxy'; exact this + · exact Nat.lt_trans (ih (by omega) (by omega)) this + rw [List.pairwise_iff_getElem] + intro x y hx hy hxy + simp only [Array.length_toList] at hx hy + have := hlt x y hxy hy + rw [arr_getElem!_eq _ hx, arr_getElem!_eq _ hy] at this + simpa using this + +theorem strictInc_nodup {a : Array Nat} (h : strictInc a = true) : a.toList.Nodup := + (strictInc_spec h).imp (fun h => Nat.ne_of_lt h) + +/-- The closure lists of a context in the form of `ulen_split_component`. -/ +theorem SCtxWF.cost_eq {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} {cs : List Nat} + {cx : SCtx} (hcx : SCtxWF dag roots w θ cs cx) (V : List Nat) : + scost cx dag V = compCost dag w cx.up.opaq + (roots.toList.filter ((markTable dag.size + (upClosure dag ((markTable dag.size cx.members)[·]!)))[·]!)) + ((upClosure dag ((markTable dag.size cx.members)[·]!)).toList.filter (cx.up.opaq[·]!)) V := by + unfold scost + rw [hcx.width, hcx.rootsC, hcx.storedInC, hcx.closure, Array.toList_filter, Array.toList_filter] + +/-- **Replacing a group's part of a minimum.** Under a separated reduced +context `(I, O)` respected by a minimum `Y`, the group part of `Y` costs at +most `slack` more than any other part `S` of the group (otherwise replacing +it by `S` would shorten `Y`). -/ +theorem group_rep {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} {cs : List Nat} + (hG : GlobalWF dag roots w θ cs) {cx : SCtx} (hcx : SCtxWF dag roots w θ cs cx) + (comp : Nat → Nat) (i : Nat) + (hcomp : ∀ a b, a < dag.size → (ucls dag roots w θ)[a]! = .uncertain → + (ucls dag roots w θ)[b]! = .uncertain → NReach (Prep.ofDag dag) (cx.up.opaq[·]!) a b → + comp a = comp b) + (hmemi : ∀ t, t < dag.size → (ucls dag roots w θ)[t]! = .uncertain → + (t ∈ cx.members.toList ↔ comp t = i)) + {g I O : Array Nat} (hchk : cx.sepCheck g I O = true) (hgn : g.toList.Nodup) + (hIn : I.toList.Nodup) + (hI : ∀ t ∈ I.toList, t ∈ cx.members.toList ∧ t ∉ O.toList) + (hO : ∀ t ∈ O.toList, t ∈ cx.members.toList) + {Y : List Nat} (hY : IsMinimum dag w roots Y) + (hYI : ∀ t ∈ I.toList, t ∈ Y) (hYO : ∀ t ∈ O.toList, t ∉ Y) + {S : List Nat} (hS : ∀ t ∈ S, t ∈ g.toList) (hSn : S.Nodup) : + scost cx dag (I.toList ++ g.toList.filter (· ∈ Y)) ≤ + scost cx dag (I.toList ++ S) + + (tag0Size (cs.length + (uunc dag roots w θ).length) - tag0Size cs.length) := by + have hwf := hG.wf + have hθ1 : 1 ≤ θ := hG.one_le_theta + have hcsc : ∀ t ∈ cs, t < dag.size ∧ (ucls dag roots w θ)[t]! = .certainStored := + fun t ht => (hG.mem_cs t).mp ht + have hdag : cx.up.prep.dag = dag := by rw [hcx.prep]; rfl + obtain ⟨ha, _⟩ := sepCheck_spec (cx := cx) (by rw [hdag]; exact hwf) + (by rw [hdag, hcx.closure]) + (by intro t ht; rw [hdag]; exact (hcx.mem t (Array.mem_toList_iff.mpr ht)).1) hchk + rw [hdag] at ha + have hg : ∀ t ∈ g.toList, t ∈ cx.members.toList ∧ t ∉ I.toList ∧ t ∉ O.toList := by + intro t ht + obtain ⟨h1, _, h3, h4⟩ := ha t (Array.mem_toList_iff.mp ht) + exact ⟨Array.mem_toList_iff.mpr h1, fun h => h3 (Array.mem_toList_iff.mp h), + fun h => h4 (Array.mem_toList_iff.mp h)⟩ + have hmemu : ∀ t ∈ cx.members.toList, t < dag.size ∧ (ucls dag roots w θ)[t]! = .uncertain := + hcx.mem + have hmemcs : ∀ t ∈ cx.members.toList, t ∉ cs := by + intro t ht hcs + have h1 := (hcsc t hcs).2 + rw [(hmemu t ht).2] at h1 + cases h1 + -- the parts of `Y` + generalize hYgd : g.toList.filter (· ∈ Y) = Yg + let D := (cx.members.toList.filter (· ∈ Y)).filter (fun t => decide (t ∉ g.toList ∧ t ∉ I.toList)) + let R := Y.filter (fun t => (ucls dag roots w θ)[t]! == .uncertain && comp t != i) + have hYg : ∀ t ∈ Yg, t ∈ g.toList ∧ t ∈ Y := by + intro t ht; rw [← hYgd] at ht; simpa using ht + have hD : ∀ t ∈ D, t ∈ cx.members.toList ∧ t ∈ Y ∧ t ∉ g.toList ∧ t ∉ I.toList := by + intro t ht; simp only [D, List.mem_filter, decide_eq_true_eq] at ht; exact ⟨ht.1.1, ht.1.2, ht.2⟩ + have hR : ∀ t ∈ R, t ∈ Y ∧ (ucls dag roots w θ)[t]! = .uncertain ∧ comp t ≠ i := by + intro t ht + simp only [R, List.mem_filter, Bool.and_eq_true, bne_iff_ne, ne_eq] at ht + exact ⟨ht.1, uclass_eq_of_beq ht.2.1, ht.2.2⟩ + have hRn : ∀ t ∈ R, t < dag.size := fun t ht => (hY.1.2 t (hR t ht).1).1 + have hRm : ∀ t ∈ R, t ∉ cx.members.toList := fun t ht hm => + (hR t ht).2.2 ((hmemi t (hRn t ht) (hR t ht).2.1).mp hm) + have hRcs : ∀ t ∈ R, t ∉ cs := fun t ht hcs => by + have := (hcsc t hcs).2; rw [(hR t ht).2.1] at this; cases this + have hYn := hY.1.1 + have hmn := hcx.memNodup + -- duplicate-freedom of the rearrangements + have hDn : D.Nodup := List.Nodup.sublist (List.Sublist.trans List.filter_sublist + List.filter_sublist) hmn + have hYgn : Yg.Nodup := by rw [← hYgd]; exact List.Nodup.sublist List.filter_sublist hgn + have hRnd : R.Nodup := List.Nodup.sublist List.filter_sublist hYn + have hcsn := hG.cs_nodup + have hVn : ∀ X : List Nat, X.Nodup → (∀ t ∈ X, t ∈ g.toList) → + (I.toList ++ D ++ X).Nodup := by + intro X hXn hXg + apply nodup_app (nodup_app hIn hDn (fun x hx hxD => (hD x hxD).2.2.2 hx)) hXn + intro x hx hxX + rcases List.mem_append.mp hx with h | h + · exact (hg x (hXg x hxX)).2.1 h + · exact (hD x h).2.2.1 (hXg x hxX) + have hVm : ∀ X : List Nat, (∀ t ∈ X, t ∈ g.toList) → + ∀ t ∈ I.toList ++ D ++ X, t ∈ cx.members.toList := by + intro X hXg t ht + rcases List.mem_append.mp ht with h | h + · rcases List.mem_append.mp h with h | h + · exact (hI t h).1 + · exact (hD t h).1 + · exact (hg t (hXg t h)).1 + have hYn' : ∀ X : List Nat, X.Nodup → (∀ t ∈ X, t ∈ g.toList) → + (cs ++ (I.toList ++ D ++ X) ++ R).Nodup := by + intro X hXn hXg + apply nodup_app (nodup_app hcsn (hVn X hXn hXg) (fun x hx hxV => hmemcs x (hVm X hXg x hxV) hx)) + hRnd + intro x hx hxR + rcases List.mem_append.mp hx with h | h + · exact hRcs x hxR h + · exact hRm x hxR (hVm X hXg x h) + have hnodup1 := hYn' Yg hYgn (fun t ht => (hYg t ht).1) + -- `Y` as certain-stored, component and other parts + have hperm : Y.Perm (cs ++ (I.toList ++ D ++ Yg) ++ R) := by + apply (List.perm_ext_iff_of_nodup hYn ?_).mpr + · intro t + constructor + · intro htY + obtain ⟨htn, hcl⟩ := hG.min_class hY htY + rcases hcl with hcl | hcl + · simp [(hG.mem_cs t).mpr ⟨htn, hcl⟩] + · by_cases hci : comp t = i + · have htm := (hmemi t htn hcl).mpr hci + by_cases htI : t ∈ I.toList + · simp [htI] + · by_cases htg : t ∈ g.toList + · have : t ∈ Yg := by rw [← hYgd]; simp [htg, htY] + simp [this] + · have : t ∈ D := by + simp only [D, List.mem_filter, decide_eq_true_eq] + exact ⟨⟨htm, htY⟩, htg, htI⟩ + simp [this] + · have : t ∈ R := by + simp only [R, List.mem_filter, Bool.and_eq_true, bne_iff_ne, ne_eq] + exact ⟨htY, by rw [hcl]; exact uclass_beq_self _, hci⟩ + simp [this] + · intro ht + simp only [List.mem_append] at ht + rcases ht with (h | ((h | h) | h)) | h + · exact hG.min_cs hY h + · exact hYI t h + · exact (hD t h).2.1 + · exact (hYg t h).2 + · exact (hR t h).1 + · exact hnodup1 + -- the replaced set is in the class + let Y' := cs ++ (I.toList ++ D ++ S) ++ R + have hY'n : Y'.Nodup := hYn' S hSn hS + have hY'c : InClass dag roots Y' := by + refine ⟨hY'n, fun s hs => ?_⟩ + simp only [Y', List.mem_append] at hs + have hcl : s < dag.size ∧ ((ucls dag roots w θ)[s]! = .certainStored ∨ + (ucls dag roots w θ)[s]! = .uncertain) := by + rcases hs with (h | h) | h + · exact ⟨(hcsc s h).1, Or.inl (hcsc s h).2⟩ + · have := hmemu s (hVm S hS s (by rcases h with (h | h) | h <;> simp [h])) + exact ⟨this.1, Or.inr this.2⟩ + · exact ⟨hRn s h, Or.inr (hR s h).2.1⟩ + exact ⟨hcl.1, deg_of_ucls hcl.1 hcl.2⟩ + have hle : ulen dag w roots (cs ++ (I.toList ++ D ++ Yg) ++ R) ≤ ulen dag w roots Y' := by + rw [← ulen_perm hperm]; exact hY.2 Y' hY'c + -- the component's share of each + have hVfacts : ∀ X : List Nat, (∀ t ∈ X, t ∈ g.toList) → ∀ t ∈ I.toList ++ D ++ X, + t ∈ cx.members.toList ∧ t < dag.size ∧ (ucls dag roots w θ)[t]! = .uncertain ∧ + comp t = i := by + intro X hXg t ht + have hm := hVm X hXg t ht + exact ⟨hm, (hmemu t hm).1, (hmemu t hm).2, (hmemi t (hmemu t hm).1 (hmemu t hm).2).mp hm⟩ + have hRfacts : ∀ t ∈ R, t < dag.size ∧ (ucls dag roots w θ)[t]! = .uncertain ∧ comp t ≠ i := + fun t ht => ⟨hRn t ht, (hR t ht).2.1, (hR t ht).2.2⟩ + have hs1 := ulen_split_component hwf roots hG.hroots w θ hθ1 hcx.opaq hcsn hcsc cx.members comp i + hcomp (V := I.toList ++ D ++ Yg) (R := R) (hVfacts Yg (fun t ht => (hYg t ht).1)) hRfacts + have hs2 := ulen_split_component hwf roots hG.hroots w θ hθ1 hcx.opaq hcsn hcsc cx.members comp i + hcomp (V := I.toList ++ D ++ S) (R := R) (hVfacts S hS) hRfacts + have hDfacts : ∀ t ∈ D, t ∈ cx.members.toList ∧ t ∉ g.toList ∧ t ∉ I.toList ∧ t ∉ O.toList := + fun t ht => ⟨(hD t ht).1, (hD t ht).2.2.1, (hD t ht).2.2.2, + fun h => hYO t h (hD t ht).2.1⟩ + have hm1 := group_modular hwf hG.hroots hθ1 hcx hcsc hchk hI hO (D := D) (S := Yg) hDfacts + (fun t ht => (hYg t ht).1) + have hm2 := group_modular hwf hG.hroots hθ1 hcx hcsc hchk hI hO (D := D) (S := S) hDfacts hS + rw [hcx.cost_eq, hcx.cost_eq, hcx.cost_eq, hcx.cost_eq] at hm1 hm2 + rw [hcx.cost_eq, hcx.cost_eq] + -- the counts lie between `|cs|` and `|cs| + |unc|` + have hlenY : cs.length ≤ (cs ++ (I.toList ++ D ++ Yg) ++ R).length := by + simp only [List.length_append]; omega + have hlenY' : Y'.length ≤ cs.length + (uunc dag roots w θ).length := by + have hsub : ∀ t ∈ Y', t ∈ cs ++ uunc dag roots w θ := by + intro t ht + have := hY'c.2 t ht + simp only [Y', List.mem_append] at ht + rcases ht with (h | h) | h + · simp [h] + · have hm := hVm S hS t (by rcases h with (h | h) | h <;> simp [h]) + simp [(mem_uunc t).mpr (hmemu t hm)] + · simp [(mem_uunc t).mpr ⟨hRn t h, (hR t h).2.1⟩] + have := List.Nodup.length_le_of_subset hY'n hsub + simpa using this + have ht1 := tag0Size_mono hlenY + have ht2 := tag0Size_mono hlenY' + have ht3 := tag0Size_mono (Nat.le_add_right cs.length (uunc dag roots w θ).length) + simp only [List.length_append] at ht1 ht2 hs1 hs2 hle + simp only [Y', List.length_append] at ht2 hle + omega + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformOptimality.lean b/Ix/Compile/Verify/UniformOptimality.lean new file mode 100644 index 000000000..5283e9158 --- /dev/null +++ b/Ix/Compile/Verify/UniformOptimality.lean @@ -0,0 +1,1427 @@ +import Ix.Compile.Verify.UniformKnapsack + +/-! +# Stage 4: the uniform optimizer returns a minimum + +The stage facts of `uniformChoose` (classification, components, the search +context of every component), the component decomposition of the uniform +length, and the final theorem: a successful `optimizeUniformExpanded` (with +the default branch-and-bound search) stores a minimum of the uniform length +over the restricted class (the optimizer checks that every telescope spine +is shorter than `teleSubaddEnd`, `SpinesFit`). +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (Desc bind_eq_ok) + +/-! ## The classification stage -/ + +section Stage + +variable (w : Nat) (ex : Expanded) + +/-- The stage of an input. -/ +abbrev stg := uniformStage w ex (Prep.ofDag ex.dag) + +theorem tag0StepBound_pos (n : Nat) : 1 ≤ tag0StepBound n := by + unfold tag0StepBound + repeat' split + all_goals omega + +theorem stage_cls_theta : + (stg w ex).cls = ucls ex.dag ex.roots w (stg w ex).theta ∧ + ((stg w ex).theta = uthetaMax ex.dag ex.roots w ∨ ((stg w ex).theta = 1 ∧ + tag0Size ((ucand ex.dag ex.roots w).filter id).size = + tag0Size ((ucls ex.dag ex.roots w (uthetaMax ex.dag ex.roots w)).filter + (· == .certainStored)).size)) := by + have hmax : (uthetaMax ex.dag ex.roots w == 1) = false := by + have := tag0StepBound_pos ((ucand ex.dag ex.roots w).filter id).size + rw [beq_eq_false_iff_ne] + unfold uthetaMax + omega + have htheta : (stg w ex).theta = + if (tag0Size ((ucand ex.dag ex.roots w).filter id).size == + tag0Size ((ucls ex.dag ex.roots w (uthetaMax ex.dag ex.roots w)).filter + (· == .certainStored)).size) then 1 else uthetaMax ex.dag ex.roots w := rfl + have hcls : (stg w ex).cls = + if (stg w ex).theta == 1 then ucls ex.dag ex.roots w 1 + else ucls ex.dag ex.roots w (uthetaMax ex.dag ex.roots w) := rfl + by_cases hc : (tag0Size ((ucand ex.dag ex.roots w).filter id).size == + tag0Size ((ucls ex.dag ex.roots w (uthetaMax ex.dag ex.roots w)).filter + (· == .certainStored)).size) = true + · have ht : (stg w ex).theta = 1 := by rw [htheta, if_pos hc] + refine ⟨?_, Or.inr ⟨ht, by simpa using hc⟩⟩ + rw [hcls, ht] + rfl + · have ht : (stg w ex).theta = uthetaMax ex.dag ex.roots w := by rw [htheta, if_neg hc] + refine ⟨?_, Or.inl ht⟩ + rw [hcls, ht] + simp only [hmax, Bool.false_eq_true, if_false] + +theorem stage_pick (c : UClass) : + ((Array.range ex.dag.size).filter ((stg w ex).cls[·]! == c)).toList = + (List.range ex.dag.size).filter (fun t => (stg w ex).cls[t]! == c) := by + rw [Array.toList_filter, Array.toList_range] + +theorem stage_cs : (stg w ex).cs.toList = + (List.range ex.dag.size).filter (fun t => (ucls ex.dag ex.roots w (stg w ex).theta)[t]! == + .certainStored) := by + rw [← (stage_cls_theta w ex).1] + exact stage_pick w ex .certainStored + +theorem stage_unc : (stg w ex).unc.toList = uunc ex.dag ex.roots w (stg w ex).theta := by + rw [uunc, ← (stage_cls_theta w ex).1] + exact stage_pick w ex .uncertain + +theorem stage_cs_lt : ∀ t ∈ (stg w ex).cs.toList, t < ex.dag.size := by + intro t ht + rw [stage_cs, List.mem_filter, List.mem_range] at ht + exact ht.1 + +theorem stage_opaq (u : Nat) : (stg w ex).opaq[u]! = decide (u ∈ (stg w ex).cs.toList) := by + show ((stg w ex).cs.foldl (fun acc t => acc.set! t true) (Array.replicate ex.dag.size false))[u]! = _ + rw [← Array.foldl_toList, foldl_setBang_const] + by_cases hu : u ∈ (stg w ex).cs.toList + · have := stage_cs_lt w ex u hu + simp [hu, this] + · simp only [hu, false_and, if_false, decide_false] + by_cases hn : u < ex.dag.size + · rw [getElem!_pos _ u (by simpa using hn)]; simp + · simp [hn] + +theorem stage_widthCs_size : (stg w ex).widthCs.size = ex.dag.size := by + show ((stg w ex).cs.foldl (fun acc t => acc.set! t (some w)) (Array.replicate ex.dag.size none)).size = _ + rw [← Array.foldl_toList, foldl_setBang_const_size] + simp + +theorem stage_widthCs (u : Nat) : + widthOf (stg w ex).widthCs u = if (stg w ex).opaq[u]! then some w else none := by + show widthOf ((stg w ex).cs.foldl (fun acc t => acc.set! t (some w)) + (Array.replicate ex.dag.size none)) u = _ + rw [← Array.foldl_toList, widthOfStored ex.dag.size w _ (stage_cs_lt w ex) u, stage_opaq] + +/-- **The optimizer's global setting**, on a DAG whose telescope spines fit +(`SpinesFit`). -/ +theorem stage_global (hwf : DagWF ex.dag) (hsp : SpinesFit (Prep.ofDag ex.dag)) + (hroots : ∀ r ∈ ex.roots.toList, r < ex.dag.size) + (hreach : ∀ y, y < ex.dag.size → ∃ r ∈ ex.roots.toList, Desc ex.dag r y) : + GlobalWF ex.dag ex.roots w (stg w ex).theta (stg w ex).cs.toList := + { wf := hwf, spines := hsp, hroots, reach := hreach, theta := (stage_cls_theta w ex).2, cs := stage_cs w ex } + +end Stage + +/-! ## The search context of a component -/ + +theorem filter_and_length (p q : Nat → Bool) (l : List Nat) : + (l.filter (fun i => p i && q i)).length + (l.filter (fun i => p i && !q i)).length = + (l.filter p).length := by + induction l with + | nil => rfl + | cons x xs ih => + simp only [List.filter_cons] + cases hp : p x <;> cases hq : q x <;> simp <;> omega + +theorem edgeCount_fold (dag : Dag) (q y : Nat) (node : Node) : + ∀ (l : List Nat) (a b : Nat), + l.foldl (fun (acc : Nat × Nat × Nat) i => + if node.child i == y then + (q, acc.2.1 + 1, acc.2.2 + (if continuationEdge node i (dag.node y) then 0 else 1)) + else acc) (q, a, b) = + (q, a + (l.filter (fun i => node.child i == y)).length, + b + (l.filter (fun i => node.child i == y && + !continuationEdge node i (dag.node y))).length) + | [], a, b => by simp + | i :: l, a, b => by + rw [List.foldl_cons] + by_cases hi : (node.child i == y) = true + · rw [if_pos hi, edgeCount_fold dag q y node l] + cases hc : continuationEdge node i (dag.node y) <;> simp [hi, hc] <;> omega + · rw [if_neg hi, edgeCount_fold dag q y node l] + simp only [Bool.not_eq_true] at hi + simp [hi] + +/-- The edge counts of `edgeCount` are the model's edge multiplicities. -/ +theorem edgeCount_le {dag : Dag} (hwf : DagWF dag) (q y : Nat) : + (edgeCount dag q y).2.1 ≤ edgeAll (Prep.ofDag dag) q y ∧ + (edgeCount dag q y).2.2 ≤ edgeMult (Prep.ofDag dag) q y false := by + unfold edgeCount + rw [edgeCount_fold dag q y] + simp only [Nat.zero_add] + by_cases hq : q < dag.size + · have har := hwf.children_size hq + unfold edgeAll edgeMult + simp only [ofDag_dag] + rw [← har] + have h := filter_and_length (fun i => (dag.node q).child i == y) + (fun i => continuationEdge (dag.node q) i (dag.node y)) (List.range (dag.node q).children.size) + constructor + · have e1 : ((List.range (dag.node q).children.size).filter fun i => + (dag.node q).child i == y && continuationEdge (dag.node q) i (dag.node y) == false) = + ((List.range (dag.node q).children.size).filter fun i => + (dag.node q).child i == y && !continuationEdge (dag.node q) i (dag.node y)) := by + congr 1; funext i; cases continuationEdge (dag.node q) i (dag.node y) <;> simp + have e2 : ((List.range (dag.node q).children.size).filter fun i => + (dag.node q).child i == y && continuationEdge (dag.node q) i (dag.node y) == true) = + ((List.range (dag.node q).children.size).filter fun i => + (dag.node q).child i == y && continuationEdge (dag.node q) i (dag.node y)) := by + congr 1; funext i; cases continuationEdge (dag.node q) i (dag.node y) <;> simp + rw [e1, e2] + omega + · apply Nat.le_of_eq + congr 1 + congr 1; funext i; cases continuationEdge (dag.node q) i (dag.node y) <;> simp + · -- out of range: no children + have hn : dag.node q = default := by + simp [Dag.node, Dag.size] at hq ⊢ + simp [hq] + rw [hn] + have : (default : Node).children.size = 0 := rfl + simp [this] + +/-- The search context of component `j`. -/ +abbrev compCx (w : Nat) (ex : Expanded) (j : Nat) : SCtx := + mkSCtx ex (stg w ex).f (stg w ex).up (stg w ex).cand (stg w ex).b0 (stg w ex).vis0 + (stg w ex).rootCount (stg w ex).slack (stg w ex).theta (stg w ex).baseEv (stg w ex).widthCs + (stg w ex).allTrue (stg w ex).unc (stg w ex).comps[j]! + +/-- The search environment of component `j`. -/ +def compEnv (w : Nat) (ex : Expanded) (j : Nat) : Env := + { dag := ex.dag, roots := ex.roots, w, θ := (stg w ex).theta, cs := (stg w ex).cs.toList, + cx := compCx w ex j, + comp := fun t => ((componentLabels ex.dag.size (stg w ex).comps)[t]!).getD 0, i := j } + +theorem map_getElem! {α β : Type} [Inhabited α] [Inhabited β] (f : α → β) (a : Array α) {i : Nat} + (hi : i < a.size) : (a.map f)[i]! = f a[i]! := by + rw [getElem!_pos _ i (by simpa using hi), getElem!_pos a i hi, Array.getElem_map] + +theorem rootCount_le (ex : Expanded) (hroots : ∀ r ∈ ex.roots.toList, r < ex.dag.size) (w t : Nat) : + (stg w ex).rootCount[t]! ≤ ex.roots.toList.count t := by + show (ex.roots.foldl (fun acc r => acc.modify r (· + 1)) (Array.replicate ex.dag.size 0))[t]! ≤ _ + rw [← Array.foldl_toList] + have := (foldl_modify_count ex.roots.toList (Array.replicate ex.dag.size 0) t + (fun c hc => by simpa using hroots c hc)).1 + rw [this] + have : (Array.replicate ex.dag.size (0 : Nat))[t]! = 0 := by + by_cases ht : t < ex.dag.size + · rw [getElem!_pos _ t (by simpa using ht)]; simp + · simp [ht] + omega + +/-- **The search environment of every component is well formed.** -/ +theorem compEnv_wf {w : Nat} {ex : Expanded} (hwf : DagWF ex.dag) + (hsp : SpinesFit (Prep.ofDag ex.dag)) + (hroots : ∀ r ∈ ex.roots.toList, r < ex.dag.size) + (hreach : ∀ y, y < ex.dag.size → ∃ r ∈ ex.roots.toList, Desc ex.dag r y) + (hchk : componentsChecked ex.dag (stg w ex).cls (stg w ex).opaq (stg w ex).comps + (componentLabels ex.dag.size (stg w ex).comps) = true) + {j : Nat} (hj : j < (stg w ex).comps.size) + (hpar : areaParentsOK ex.dag.size (compCx w ex j) = true) : (compEnv w ex j).WF := by + obtain ⟨hca, hcb, hcc, hcd⟩ := componentsChecked_spec hwf hchk + have hcls := (stage_cls_theta w ex).1 + rw [hcls] at hca hcc hcd + have hn := (stage_cls_theta w ex).2 + refine { G := stage_global w ex hwf hsp hroots hreach, cx := ?_, area := ?_, comp := ?_, + memi := ?_, slack := ?_ } + · exact { prep := rfl, width := rfl, opaq := stage_opaq w ex, cand := rfl, bounds0 := rfl, + vis0 := rfl, mem := fun t ht => ⟨(hca j hj t ht).1, (hca j hj t ht).2.1⟩, + memNodup := hcb j hj, widthCs_size := stage_widthCs_size w ex, + widthCs := stage_widthCs w ex, allTrue := rfl, baseEv := rfl, closure := rfl, + rootsC := rfl, storedInC := rfl, theta := rfl } + · unfold areaParentsOK at hpar + rw [List.all_eq_true] at hpar + refine { rootOcc := ?_, nodup := ?_, lt := ?_, cnt := ?_ } + · intro j' hj' + simp only [compEnv] + show ((componentArea (stg w ex).up (stg w ex).f (stg w ex).comps[j]!).map + ((stg w ex).rootCount[·]!))[j']! ≤ _ + have hj'' : j' < (componentArea (stg w ex).up (stg w ex).f (stg w ex).comps[j]!).size := hj' + rw [map_getElem! _ _ hj''] + exact rootCount_le ex hroots w _ + · intro j' hj' + have := hpar j' (List.mem_range.mpr hj') + simp only [Bool.and_eq_true] at this + have hn := strictInc_nodup this.1 + rw [Array.toList_map] at hn + exact hn + · intro j' hj' e he + have := hpar j' (List.mem_range.mpr hj') + simp only [Bool.and_eq_true, Array.all_eq_true'] at this + exact of_decide_eq_true (this.2 e (Array.mem_toList_iff.mp he)) + · intro j' hj' e he + simp only [compEnv] at he ⊢ + have hin : (compCx w ex j).inEdges[j']! = + ((stg w ex).f.parents[(compCx w ex j).area[j']!]!).map + (fun q => edgeCount ex.dag q (compCx w ex j).area[j']!) := map_getElem! _ _ hj' + rw [hin, Array.toList_map, List.mem_map] at he + obtain ⟨q, _, rfl⟩ := he + have := edgeCount_le hwf q (compCx w ex j).area[j']! + have h1 : (edgeCount ex.dag q (compCx w ex j).area[j']!).1 = q := by + unfold edgeCount; rw [edgeCount_fold] + rw [h1] + exact this + · intro a b ha hua hub hab + simp only [compEnv] + rw [hcd a b ha hua hub hab] + · intro t ht hut + simp only [compEnv] + constructor + · intro htm + rw [(hca j hj t htm).2.2] + rfl + · intro hct + obtain ⟨i, hi, hl, htm⟩ := hcc t ht hut + rw [hl] at hct + simp only [Option.getD_some] at hct + subst hct + exact htm + · have hs : (stg w ex).slack = tag0Size ((stg w ex).cs.size + (stg w ex).unc.size) - + tag0Size (stg w ex).cs.size := rfl + show (stg w ex).slack = tag0Size ((stg w ex).cs.toList.length + + (uunc ex.dag ex.roots w (stg w ex).theta).length) - tag0Size (stg w ex).cs.toList.length + rw [hs, ← stage_unc w ex, Array.length_toList, Array.length_toList] + +/-! ## The component searches -/ + +/-- What a successful component search returns. -/ +def SearchOK (cx : SCtx) (limits : Limits) (r : CompResult) : Prop := + areaParentsOK cx.up.prep.dag.size cx = true ∧ r.members = cx.members ∧ + ∃ (st0 : SState) (st : SState), st0.memo = {} ∧ + cx.solveP limits (8 * cx.members.size + 8) cx.members #[] #[] st0 = .ok (r.bySize, st) ∧ + CTable.best r.bySize = some r.bestDelta ∧ bestSetOf r.bySize r.bestDelta = some r.bestSet + +theorem searchComponent_ok {cx : SCtx} {limits : Limits} {states costEvals : Nat} + {r : CompResult} {s c : Nat} (h : searchComponent cx limits states costEvals = .ok (r, s, c)) : + SearchOK cx limits r := by + unfold searchComponent at h + simp only at h + split at h + all_goals first | (cases h; done) | skip + rename_i hpar0 + have hpar : areaParentsOK cx.up.prep.dag.size cx = true := by simpa using hpar0 + obtain ⟨⟨tb, st⟩, hs, h⟩ := bind_eq_ok h + simp only at h + split at h + · rename_i bd hbd + split at h + · rename_i bs hbs + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, _, _⟩ := h + exact ⟨hpar, rfl, { states, costEvals }, st, rfl, hs, hbd, hbs⟩ + · cases h + · cases h + +theorem push_getElem!_lt {α : Type} [Inhabited α] (a : Array α) (x : α) {i : Nat} (hi : i < a.size) : + (a.push x)[i]! = a[i]! := by + rw [getElem!_pos _ i (by simp; omega), getElem!_pos a i hi, Array.getElem_push_lt] + +theorem push_getElem!_eq {α : Type} [Inhabited α] (a : Array α) (x : α) : + (a.push x)[a.size]! = x := by + rw [getElem!_pos _ a.size (by simp), Array.getElem_push_eq] + +/-- The step of `searchComponents` with the branch-and-bound search. -/ +theorem searchComponents_spec {w : Nat} {limits : Limits} {ex : Expanded} + (hsub : limits.uniformSubsetSearch = false) {results : Array CompResult} {s c : Nat} + (h : searchComponents limits ex (stg w ex) = .ok (results, s, c)) : + results.size = (stg w ex).comps.size ∧ + ∀ j, j < (stg w ex).comps.size → SearchOK (compCx w ex j) limits results[j]! := by + unfold searchComponents at h + rw [← Array.foldlM_toList] at h + -- induction over the components, with the processed prefix + have key : ∀ (l : List (Array Nat)) (pre : List (Array Nat)) (acc : Array CompResult × Nat × Nat), + pre ++ l = (stg w ex).comps.toList → acc.1.size = pre.length → + (∀ j, j < pre.length → SearchOK (compCx w ex j) limits acc.1[j]!) → + ∀ res, l.foldlM (fun (acc : Array CompResult × Nat × Nat) members => do + let (results, states, costEvals) := acc + if limits.uniformSubsetSearch then + let (r, states, costEvals) ← searchComponentRef (stg w ex).up (stg w ex).f + (stg w ex).opaq ex.roots (stg w ex).slack limits members states costEvals + pure (results.push r, states, costEvals) + else + let cx := mkSCtx ex (stg w ex).f (stg w ex).up (stg w ex).cand (stg w ex).b0 + (stg w ex).vis0 (stg w ex).rootCount (stg w ex).slack (stg w ex).theta + (stg w ex).baseEv (stg w ex).widthCs (stg w ex).allTrue (stg w ex).unc members + let (r, states, costEvals) ← searchComponent cx limits states costEvals + pure (results.push r, states, costEvals)) acc = .ok res → + res.1.size = (stg w ex).comps.size ∧ + ∀ j, j < (stg w ex).comps.size → SearchOK (compCx w ex j) limits res.1[j]! := by + intro l + induction l with + | nil => + intro pre acc hpre hsz hall res hres + simp only [List.foldlM_nil, pure, Except.pure, Except.ok.injEq] at hres + subst hres + have : pre.length = (stg w ex).comps.size := by + rw [← Array.length_toList, ← hpre, List.append_nil] + exact ⟨by rw [hsz, this], fun j hj => hall j (by omega)⟩ + | cons m l ih => + intro pre acc hpre hsz hall res hres + rw [List.foldlM_cons] at hres + obtain ⟨acc', hstep, hres⟩ := bind_eq_ok hres + obtain ⟨results0, states0, costEvals0⟩ := acc + simp only [hsub, Bool.false_eq_true, if_false] at hstep + obtain ⟨⟨r, s1, c1⟩, hsc, hstep⟩ := bind_eq_ok hstep + simp only [pure, Except.pure, Except.ok.injEq] at hstep + subst hstep + have hmj : (stg w ex).comps[pre.length]! = m := by + have : (stg w ex).comps.toList[pre.length]? = some m := by + rw [← hpre]; simp + rw [getElem!_def, ← Array.getElem?_toList, this] + simp only at hsz hall + refine ih (pre ++ [m]) (results0.push r, s1, c1) (by rw [← hpre]; simp) + (by simp [hsz]) ?_ res hres + intro j hj + simp only [List.length_append, List.length_singleton] at hj + by_cases hjl : j < pre.length + · simp only + rw [push_getElem!_lt _ _ (by omega)] + exact hall j hjl + · have hjeq : j = pre.length := by omega + subst hjeq + simp only + rw [← hsz, push_getElem!_eq] + have := searchComponent_ok hsc + rw [hsz] + unfold compCx + rw [hmj] + exact this + exact key (stg w ex).comps.toList [] ((#[] : Array CompResult), 0, 0) (by simp) rfl + (fun j hj => absurd hj (Nat.not_lt_zero _)) _ h + +/-! ## The uniform length of a minimum, component by component -/ + +theorem compCx_sctx {w : Nat} {ex : Expanded} (hwf : DagWF ex.dag) + (hchk : componentsChecked ex.dag (stg w ex).cls (stg w ex).opaq (stg w ex).comps + (componentLabels ex.dag.size (stg w ex).comps) = true) + {j : Nat} (hj : j < (stg w ex).comps.size) : + SCtxWF ex.dag ex.roots w (stg w ex).theta (stg w ex).cs.toList (compCx w ex j) := by + obtain ⟨hca, hcb, _, _⟩ := componentsChecked_spec hwf hchk + rw [(stage_cls_theta w ex).1] at hca + exact { prep := rfl, width := rfl, opaq := stage_opaq w ex, cand := rfl, bounds0 := rfl, + vis0 := rfl, mem := fun t ht => ⟨(hca j hj t ht).1, (hca j hj t ht).2.1⟩, + memNodup := hcb j hj, widthCs_size := stage_widthCs_size w ex, + widthCs := stage_widthCs w ex, allTrue := rfl, baseEv := rfl, closure := rfl, + rootsC := rfl, storedInC := rfl, theta := rfl } + +/-- **The base of the model** is the length of the certain-stored terms +without the count's TagN. -/ +theorem csBase_eq {w : Nat} {ex : Expanded} (hwf : DagWF ex.dag) + (hroots : ∀ r ∈ ex.roots.toList, r < ex.dag.size) : + csBase ex (Prep.ofDag ex.dag) (stg w ex) + tag0Size (stg w ex).cs.toList.length = + ulen ex.dag w ex.roots (stg w ex).cs.toList := by + have hp := prepWF_ofDag hwf + let A : Nat → Bool := fun u => (stg w ex).opaq[u]! + have hA : (fun y => decide (y ∈ (stg w ex).cs.toList)) = A := by + funext y; simp only [A, stage_opaq] + have hwid : ∀ u, widthOf (stg w ex).widthCs u = if A u then some w else none := + stage_widthCs w ex + have hrows : ∀ t, t < ex.dag.size → EvalRow (Prep.ofDag ex.dag) w A (stg w ex).baseEv t := by + intro t ht + exact hp.evalFrom_spec (stg w ex).widthCs hwid (Prep.ofDag ex.dag).empty (ofDag_empty_size ex.dag) + (Array.replicate ex.dag.size true) (fun t ht => replicate_getBang ht) t ht + have hbsz := evalFrom_size (Prep.ofDag ex.dag).dag (Prep.ofDag ex.dag).family + (Prep.ofDag ex.dag).spineLen (Prep.ofDag ex.dag).tail (Prep.ofDag ex.dag).empty + (stg w ex).widthCs (Array.replicate ex.dag.size true) + obtain ⟨e1, e2, e3⟩ := ofDag_empty_size ex.dag + rw [e1, e2, e3] at hbsz + unfold csBase ulen uniformCost + rw [hA, arr_foldl_add_eq_sum, arr_foldl_add_eq_sum, Nat.zero_add, Nat.zero_add] + have hr : (ex.roots.toList.map fun r => (stg w ex).baseEv.cost[r]!) = + ex.roots.toList.map (uCost (Prep.ofDag ex.dag) w A) := + List.map_congr_left (fun r hr => (hrows r (hroots r hr)).1) + have hc : ((stg w ex).cs.toList.map fun c => (evalStep (Prep.ofDag ex.dag).dag + (Prep.ofDag ex.dag).family (Prep.ofDag ex.dag).spineLen (Prep.ofDag ex.dag).tail + ((stg w ex).widthCs.set! c none) (stg w ex).allTrue (stg w ex).baseEv c).cost[c]!) = + (stg w ex).cs.toList.map (uInl (Prep.ofDag ex.dag) w A) := + List.map_congr_left (fun c hc => entry_inl hwf (stg w ex).widthCs (stage_widthCs_size w ex) + hwid (stg w ex).baseEv hbsz hrows (stage_cs_lt w ex c hc)) + rw [hr, hc] + omega + +/-- The parts of `Y` in the first `j` components. -/ +def compParts (comps : Array (Array Nat)) (Y : List Nat) (j : Nat) : List Nat := + ((List.range j).map fun i => partOf Y comps[i]!.toList).flatten + +theorem compParts_succ (comps : Array (Array Nat)) (Y : List Nat) (j : Nat) : + compParts comps Y (j + 1) = compParts comps Y j ++ partOf Y comps[j]!.toList := by + unfold compParts + rw [List.range_succ, List.map_append, List.flatten_append] + simp + +theorem mem_compParts {comps : Array (Array Nat)} {Y : List Nat} {j t : Nat} : + t ∈ compParts comps Y j ↔ ∃ i, i < j ∧ t ∈ comps[i]!.toList ∧ t ∈ Y := by + unfold compParts + simp only [List.mem_flatten, List.mem_map, List.mem_range] + constructor + · rintro ⟨l, ⟨i, hi, rfl⟩, ht⟩ + exact ⟨i, hi, partOf_sub t ht⟩ + · rintro ⟨i, hi, h1, h2⟩ + exact ⟨_, ⟨i, hi, rfl⟩, by simp [partOf, h1, h2]⟩ + +/-- **The uniform length of the certain-stored terms and the parts of `Y` in +the first `j` components**: each component adds its change of component +cost. -/ +theorem ulen_compParts {w : Nat} {ex : Expanded} (hwf : DagWF ex.dag) + (hsp : SpinesFit (Prep.ofDag ex.dag)) + (hroots : ∀ r ∈ ex.roots.toList, r < ex.dag.size) + (hreach : ∀ y, y < ex.dag.size → ∃ r ∈ ex.roots.toList, Desc ex.dag r y) + (hchk : componentsChecked ex.dag (stg w ex).cls (stg w ex).opaq (stg w ex).comps + (componentLabels ex.dag.size (stg w ex).comps) = true) + (Y : List Nat) : + ∀ j, j ≤ (stg w ex).comps.size → + ulen ex.dag w ex.roots ((stg w ex).cs.toList ++ compParts (stg w ex).comps Y j) + + tag0Size (stg w ex).cs.toList.length + + ((List.range j).map fun i => scost (compCx w ex i) ex.dag []).sum = + ulen ex.dag w ex.roots (stg w ex).cs.toList + + tag0Size ((stg w ex).cs.toList ++ compParts (stg w ex).comps Y j).length + + ((List.range j).map fun i => + scost (compCx w ex i) ex.dag (partOf Y (stg w ex).comps[i]!.toList)).sum := by + have hG := stage_global w ex hwf hsp hroots hreach + obtain ⟨hca, hcb, hcc, hcd⟩ := componentsChecked_spec hwf hchk + rw [(stage_cls_theta w ex).1] at hca hcc hcd + let comp : Nat → Nat := fun t => ((componentLabels ex.dag.size (stg w ex).comps)[t]!).getD 0 + have hθ1 : 1 ≤ (stg w ex).theta := hG.one_le_theta + intro j + induction j with + | zero => intro _; simp [compParts] + | succ j ih => + intro hj + have ih := ih (by omega) + have hjs : j < (stg w ex).comps.size := by omega + have hcx := compCx_sctx hwf hchk hjs + -- the new component's part and the earlier parts + have hV : ∀ t ∈ partOf Y (stg w ex).comps[j]!.toList, + t ∈ (compCx w ex j).members.toList ∧ t < ex.dag.size ∧ + (ucls ex.dag ex.roots w (stg w ex).theta)[t]! = .uncertain ∧ comp t = j := by + intro t ht + have htc := (partOf_sub t ht).1 + obtain ⟨h1, h2, h3⟩ := hca j hjs t htc + exact ⟨htc, h1, h2, by simp only [comp]; rw [h3]; rfl⟩ + have hR : ∀ t ∈ compParts (stg w ex).comps Y j, t < ex.dag.size ∧ + (ucls ex.dag ex.roots w (stg w ex).theta)[t]! = .uncertain ∧ comp t ≠ j := by + intro t ht + obtain ⟨i, hi, htc, _⟩ := mem_compParts.mp ht + obtain ⟨h1, h2, h3⟩ := hca i (by omega) t htc + exact ⟨h1, h2, by simp only [comp]; rw [h3]; simp; omega⟩ + have hsplit := ulen_split_component hwf ex.roots hroots w (stg w ex).theta hθ1 + (opaq := (compCx w ex j).up.opaq) + (fun u => stage_opaq w ex u) hG.cs_nodup (fun t ht => (hG.mem_cs t).mp ht) + (compCx w ex j).members comp j + (fun a b ha hua hub hab => by simp only [comp]; rw [hcd a b ha hua hub hab]) + (V := partOf Y (stg w ex).comps[j]!.toList) (R := compParts (stg w ex).comps Y j) hV hR + rw [← hcx.cost_eq, ← hcx.cost_eq] at hsplit + have hperm : ((stg w ex).cs.toList ++ compParts (stg w ex).comps Y (j + 1)).Perm + ((stg w ex).cs.toList ++ partOf Y (stg w ex).comps[j]!.toList ++ + compParts (stg w ex).comps Y j) := by + rw [compParts_succ] + simp only [List.append_assoc] + exact List.Perm.append_left _ List.perm_append_comm + rw [ulen_perm hperm, hperm.length_eq, List.range_succ, List.map_append, List.map_append, + List.sum_append, List.sum_append] + simp only [List.map_cons, List.map_nil, List.sum_cons, List.sum_nil, Nat.add_zero] + simp only [List.length_append] at hsplit ih ⊢ + omega + +/-! ## The count brackets and the knapsack bound -/ + +/-- **A count bracket starts with its own TagN (`f = 0`) size.** -/ +theorem tag0Size_bracketStart (k : Nat) : tag0Size (tag0BracketStart k) = tag0Size k := by + have h1 : 0 < Ixon.tagNEnd1 0 := by decide + have h12 : Ixon.tagNEnd1 0 < Ixon.tagNEnd2 0 := by decide + have h23 : Ixon.tagNEnd2 0 < Ixon.tagNEnd3 0 := by decide + have h34 : Ixon.tagNEnd3 0 < Ixon.tagNEnd4 0 := by decide + have h45 : Ixon.tagNEnd4 0 < Ixon.tagNEnd5 0 := by decide + unfold tag0BracketStart + repeat' split + all_goals + unfold tag0Size Ixon.tagNByteWidth + repeat' split + all_goals omega + +theorem tag0Size_ge_of_bracket {k m : Nat} (h : tag0BracketStart k ≤ m) : tag0Size k ≤ tag0Size m := by + rw [← tag0Size_bracketStart k] + exact tag0Size_mono h + +theorem sum_map_range {α : Type} [Inhabited α] (f : α → _root_.Int) (l : List α) : + (l.map f).sum = ((List.range l.length).map fun j => f l[j]!).sum := by + induction l with + | nil => simp + | cons x xs ih => + rw [List.length_cons, List.range_succ_eq_map, List.map_cons, List.map_cons, List.map_map, + List.sum_cons, List.sum_cons, ih] + simp [Function.comp_def] + +theorem sum_map_range' (l : List _root_.Int) : + l.sum = ((List.range l.length).map fun j => l[j]!).sum := by + have := sum_map_range id l + simpa using this + +theorem sum_le_sum_int {f g : Nat → _root_.Int} : + ∀ (l : List Nat), (∀ k ∈ l, f k ≤ g k) → (l.map f).sum ≤ (l.map g).sum + | [], _ => by simp + | a :: l, h => by + simp only [List.map_cons, List.sum_cons] + have := sum_le_sum_int l (fun k hk => h k (List.mem_cons_of_mem _ hk)) + have := h a List.mem_cons_self + omega + +/-- The sum of the bests. -/ +theorem foldl_bestDelta_eq (rs : List CompResult) (a : _root_.Int) : + rs.foldl (fun acc r => acc + r.bestDelta) a = a + (rs.map (·.bestDelta)).sum := by + induction rs generalizing a with + | nil => simp + | cons r rs ih => rw [List.foldl_cons, ih]; simp; omega + +theorem indexed_dp0 (cap : Nat) : Indexed (#[some (0, #[])] ++ Array.replicate cap none) := by + intro k e he + by_cases hk : k = 0 + · subst hk + rw [getElem!_pos _ 0 (by rw [Array.size_append]; simp; omega)] at he + simp at he + rw [← he]; rfl + · by_cases hk' : k < 1 + cap + · rw [getElem!_pos _ k (by simp; omega), Array.getElem_append_right (by simp; omega)] at he + simp at he + · simp [show ¬ k < 1 + cap by omega] at he + +theorem indexed_fold {cap : Nat} : + ∀ (ts : List CTable) (dp : CTable), (∀ t ∈ ts, Indexed t) → Indexed dp → + Indexed (ts.foldl (knapStep cap) dp) + | [], _, _, h => h + | t :: ts, _dp, ht, h => indexed_fold ts _ (fun t' h' => ht t' (List.mem_cons_of_mem _ h')) + (knapStep_indexed h (ht t List.mem_cons_self)) + +/-- **The knapsack bound.** For any choice of one entry per component table +(at counts `ks`, values at most `vs`), the chosen total is at most the +choice's `Δ` plus the TagN of its count. -/ +theorem uniformKnapsack_le {limits : Limits} {kCS : Nat} {results : Array CompResult} + {cd : _root_.Int} {cx : Array Nat} {lb : Bool} + (h : uniformKnapsack limits kCS results = .ok (cd, cx, lb)) + (ks : List Nat) (vs : List _root_.Int) (hk : ks.length = results.size) + (hv : vs.length = results.size) + (hhas : ∀ j, j < results.size → HasAt results[j]!.bySize ks[j]! vs[j]!) + (hidx : ∀ j, j < results.size → Indexed results[j]!.bySize) + (hbest : ∀ j, j < results.size → ∀ (k : Nat) (e : Entry), results[j]!.bySize[k]! = some e → + results[j]!.bestDelta ≤ e.1) : + cd + (tag0Size (kCS + cx.size) : _root_.Int) ≤ vs.sum + (tag0Size (kCS + ks.sum) : _root_.Int) := by + -- the sum of the bests is below the choice + have hbsum : (results.toList.map (·.bestDelta)).sum ≤ vs.sum := by + rw [sum_map_range (·.bestDelta) results.toList, sum_map_range' vs] + simp only [Array.length_toList, hv] + apply sum_le_sum_int + intro j hj + have hj' := List.mem_range.mp hj + obtain ⟨e, he, hev⟩ := hhas j hj' + have := hbest j hj' _ e he + rw [Array.getElem!_toList] + omega + have hbest_eq : results.foldl (fun acc r => acc + r.bestDelta) (0 : _root_.Int) = + (results.toList.map (·.bestDelta)).sum := by + rw [← Array.foldl_toList, foldl_bestDelta_eq]; simp + have hts : ∀ j, j < results.size → (results.toList.map (·.bySize))[j]! = results[j]!.bySize := by + intro j hj + rw [getElem!_pos _ j (by simpa using hj), List.getElem_map, getElem!_pos results j hj] + simp + have htsl : (results.toList.map (·.bySize)).length = results.size := by simp + unfold uniformKnapsack at h + simp only at h + generalize hbx : results.foldl (fun acc r => mergeSorted acc r.bestSet) #[] = bestX at h + generalize hbd : results.foldl (fun acc r => acc + r.bestDelta) (0 : _root_.Int) = bestDelta at h + have hbd' : bestDelta ≤ vs.sum := by rw [← hbd, hbest_eq]; exact hbsum + have hbr : tag0BracketStart (kCS + bestX.size) ≤ kCS + ks.sum → + tag0Size (kCS + bestX.size) ≤ tag0Size (kCS + ks.sum) := tag0Size_ge_of_bracket + split at h + · rename_i hstart + split at h + · cases h + · simp only [pure, Except.pure, Except.ok.injEq] at h + generalize hcap : tag0BracketStart (kCS + bestX.size) - 1 - kCS = cap at h + have hdp : results.foldl (fun dp r => knapStep cap dp r.bySize) + (#[some (0, #[])] ++ Array.replicate cap none) = + (results.toList.map (·.bySize)).foldl (knapStep cap) + (#[some (0, #[])] ++ Array.replicate cap none) := by + rw [← Array.foldl_toList, List.foldl_map] + rw [hdp] at h + have hidx_dp := indexed_fold (cap := cap) (results.toList.map (·.bySize)) + (#[some (0, #[])] ++ Array.replicate cap none) + (fun t ht => by + obtain ⟨r, hr, rfl⟩ := List.mem_map.mp ht + obtain ⟨j, hj, hrj⟩ := List.mem_iff_getElem.mp hr + simp only [Array.length_toList] at hj + have := hidx j hj + rw [getElem!_pos results j hj] at this + simpa [← hrj] using this) + (indexed_dp0 cap) + obtain ⟨hc1, hc2⟩ := knapChoose_le kCS hidx_dp (bestDelta, bestX, false) + rw [h] at hc1 hc2 + unfold knapTotal at hc1 hc2 + simp only at hc1 hc2 + by_cases hfit : ks.sum ≤ cap + · obtain ⟨e, he, hev⟩ := knapFold_hasAt (cap := cap) (results.toList.map (·.bySize)) ks vs + (#[some (0, #[])] ++ Array.replicate cap none) 0 0 (by rw [htsl, hk]) (by rw [htsl, hv]) + (fun j hj => by rw [hts j (by rw [← htsl]; exact hj)]; exact hhas j (by rw [← htsl]; exact hj)) + ⟨(0, #[]), by rw [getElem!_pos _ 0 (by rw [Array.size_append]; simp; omega)]; simp, + Int.le_refl _⟩ (by omega) + have := hc2 (0 + ks.sum) e he + simp only [Nat.zero_add, Int.zero_add] at this hev + omega + · have := hbr (by omega) + omega + · rename_i hstart + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl, rfl⟩ := h + have := hbr (by omega) + omega + +/-! ## Minima -/ + +/-- **A minimum exists** (the class contains the empty set). -/ +theorem minimum_exists (dag : Dag) (w : Nat) (roots : Array Nat) : + ∃ Y, IsMinimum dag w roots Y := by + obtain ⟨m, ⟨Y, hY, hYm⟩, hmin⟩ := exists_min_nat (fun m => ∃ Y, InClass dag roots Y ∧ ulen dag w roots Y = m) + ⟨_, [], ⟨List.nodup_nil, fun s hs => absurd hs List.not_mem_nil⟩, rfl⟩ + refine ⟨Y, hY, fun Y' hY' => ?_⟩ + rw [hYm] + refine Classical.byContradiction fun hlt => ?_ + exact hmin (ulen dag w roots Y') (by omega) ⟨Y', hY', rfl⟩ + +/-- A minimum is the certain-stored terms and its parts in the components. -/ +theorem min_perm_parts {w : Nat} {ex : Expanded} (hwf : DagWF ex.dag) + (hsp : SpinesFit (Prep.ofDag ex.dag)) + (hroots : ∀ r ∈ ex.roots.toList, r < ex.dag.size) + (hreach : ∀ y, y < ex.dag.size → ∃ r ∈ ex.roots.toList, Desc ex.dag r y) + (hchk : componentsChecked ex.dag (stg w ex).cls (stg w ex).opaq (stg w ex).comps + (componentLabels ex.dag.size (stg w ex).comps) = true) + {Y : List Nat} (hY : IsMinimum ex.dag w ex.roots Y) : + Y.Perm ((stg w ex).cs.toList ++ compParts (stg w ex).comps Y (stg w ex).comps.size) := by + have hG := stage_global w ex hwf hsp hroots hreach + obtain ⟨hca, hcb, hcc, _⟩ := componentsChecked_spec hwf hchk + rw [(stage_cls_theta w ex).1] at hca hcc + -- the parts are duplicate-free and disjoint + have hnd : ∀ j, j ≤ (stg w ex).comps.size → (compParts (stg w ex).comps Y j).Nodup := by + intro j + induction j with + | zero => intro _; simp [compParts] + | succ j ih => + intro hj + rw [compParts_succ] + apply nodup_app (ih (by omega)) (List.Nodup.sublist List.filter_sublist (hcb j (by omega))) + intro x hx hxV + obtain ⟨i, hi, hxi, _⟩ := mem_compParts.mp hx + have h1 := (hca i (by omega) x hxi).2.2 + have h2 := (hca j (by omega) x (partOf_sub x hxV).1).2.2 + rw [h1] at h2 + simp at h2 + omega + apply (List.perm_ext_iff_of_nodup hY.1.1 (nodup_app hG.cs_nodup (hnd _ (Nat.le_refl _)) ?_)).mpr + · intro t + simp only [List.mem_append, mem_compParts] + constructor + · intro htY + obtain ⟨htn, hcl⟩ := hG.min_class hY htY + rcases hcl with hcl | hcl + · exact Or.inl ((hG.mem_cs t).mpr ⟨htn, hcl⟩) + · obtain ⟨i, hi, _, hti⟩ := hcc t htn hcl + exact Or.inr ⟨i, hi, hti, htY⟩ + · rintro (h | ⟨_, _, _, h⟩) + · exact hG.min_cs hY h + · exact h + · intro x hx hxp + obtain ⟨i, hi, hxi, _⟩ := mem_compParts.mp hxp + have h1 := (hca i hi x hxi).2.1 + have h2 := ((hG.mem_cs x).mp hx).2 + rw [h1] at h2 + cases h2 + +theorem compParts_length (comps : Array (Array Nat)) (Y : List Nat) (j : Nat) : + (compParts comps Y j).length = + ((List.range j).map fun i => (partOf Y comps[i]!.toList).length).sum := by + unfold compParts + rw [List.length_flatten, List.map_map] + rfl + +theorem sum_map_sub_int (a b : Nat → Nat) (l : List Nat) : + (l.map fun j => ((a j : _root_.Int) - (b j : _root_.Int))).sum = + ((l.map a).sum : _root_.Int) - ((l.map b).sum : _root_.Int) := by + induction l with + | nil => simp + | cons x xs ih => simp only [List.map_cons, List.sum_cons]; push_cast; rw [ih]; omega + +/-! ## The model length is at most every minimum's length -/ + +/-- **The chosen model length is a lower bound of the minimum.** With the +branch-and-bound search, the model length `uniformChoose` reports is at most +the uniform length of every minimum. -/ +theorem uniformChoose_model_le {w : Nat} {limits : Limits} {ex : Expanded} + (hsub : limits.uniformSubsetSearch = false) (hwf : DagWF ex.dag) + (hsp : SpinesFit (Prep.ofDag ex.dag)) + (hroots : ∀ r ∈ ex.roots.toList, r < ex.dag.size) + (hreach : ∀ y, y < ex.dag.size → ∃ r ∈ ex.roots.toList, Desc ex.dag r y) + {c : UniformChoice} (h : uniformChoose w limits ex (Prep.ofDag ex.dag) = .ok c) + {Y : List Nat} (hY : IsMinimum ex.dag w ex.roots Y) : + c.model ≤ ulen ex.dag w ex.roots Y := by + unfold uniformChoose at h + simp only at h + split at h + all_goals first | (cases h; done) | skip + rename_i hchk0 + have hchk : componentsChecked ex.dag (stg w ex).cls (stg w ex).opaq (stg w ex).comps + (componentLabels ex.dag.size (stg w ex).comps) = true := by simpa using hchk0 + obtain ⟨⟨results, s1, c1⟩, hsc, h⟩ := bind_eq_ok h + obtain ⟨⟨cd, cx, lb⟩, hkn, h⟩ := bind_eq_ok h + simp only at h hkn + split at h + · cases h + rename_i hneg + split at h + · cases h + simp only [pure, Except.pure, Except.ok.injEq] at h + subst h + simp only + obtain ⟨hsize, hok⟩ := searchComponents_spec hsub hsc + let m := (stg w ex).comps.size + let V : Nat → List Nat := fun j => partOf Y (stg w ex).comps[j]!.toList + -- every component's table covers the minimum + have hfacts : ∀ j, j < m → + HasAt results[j]!.bySize (V j).length ((compEnv w ex j).delta [] (V j)) ∧ + Indexed results[j]!.bySize ∧ + (∀ (k : Nat) (e : Entry), results[j]!.bySize[k]! = some e → results[j]!.bestDelta ≤ e.1) := by + intro j hj + obtain ⟨hpar, _, st0, st, hm0, hsolve, hbest, _⟩ := hok j hj + have hE := compEnv_wf hwf hsp hroots hreach hchk hj hpar + obtain ⟨htabj, hcovj⟩ := Env.component_table (E := compEnv w ex j) hE hsolve hm0 + exact ⟨(hcovj Y hY).toHasAt, fun k e he => (htabj k e he).1, fun k e he => best_le hbest he⟩ + let ks := (List.range m).map fun j => (V j).length + let vs := (List.range m).map fun j => (compEnv w ex j).delta [] (V j) + have hgr : ∀ {α : Type} [Inhabited α] (f : Nat → α) {j : Nat}, j < m → + ((List.range m).map f)[j]! = f j := by + intro α _ f j hj + rw [getElem!_pos _ j (by simpa using hj), List.getElem_map, List.getElem_range] + have hkn' := uniformKnapsack_le hkn ks vs (by simp [ks, hsize, m]) (by simp [vs, hsize, m]) + (fun j hj => by + rw [hgr _ (by simp only [m]; omega), hgr _ (by simp only [m]; omega)] + exact (hfacts j (by simp only [m]; omega)).1) + (fun j hj => (hfacts j (by simp only [m]; omega)).2.1) + (fun j hj => (hfacts j (by simp only [m]; omega)).2.2) + -- the minimum's length, component by component + have hdec := ulen_compParts hwf hsp hroots hreach hchk Y m (Nat.le_refl _) + have hbase := csBase_eq (w := w) hwf hroots + have hperm := min_perm_parts hwf hsp hroots hreach hchk hY + rw [← ulen_perm hperm] at hdec + have hlen : ((stg w ex).cs.toList ++ compParts (stg w ex).comps Y m).length = + (stg w ex).cs.size + ks.sum := by + rw [List.length_append, compParts_length, Array.length_toList] + rw [hlen] at hdec + have hvs : vs.sum = (((List.range m).map fun j => scost (compCx w ex j) ex.dag (V j)).sum : _root_.Int) - + (((List.range m).map fun j => scost (compCx w ex j) ex.dag []).sum : _root_.Int) := by + rw [← sum_map_sub_int] + rfl + have hcs : (stg w ex).cs.toList.length = (stg w ex).cs.size := Array.length_toList + rw [hcs] at hbase hdec + apply Int.toNat_le.mpr + simp only [Int.not_lt] at hneg + push_cast + simp only [V, m, ks, vs, stg] at hneg hkn' hdec hbase hvs ⊢ + omega + +/-! ## The final theorem -/ + +theorem inClass_of_check {dag : Dag} {roots stored : Array Nat} + (hin : ∀ t ∈ stored.toList, t < dag.size) (h : inClassCheck dag roots stored = true) : + InClass dag roots stored.toList := by + unfold inClassCheck at h + simp only [Bool.and_eq_true] at h + obtain ⟨h1, h2⟩ := h + have hs : strictInc stored = true := h1 + refine ⟨strictInc_nodup hs, fun s hs' => ⟨hin s hs', ?_⟩⟩ + rw [Array.all_eq_true'] at h2 + exact of_decide_eq_true (h2 s (Array.mem_toList_iff.mp hs')) + +/-- **Stage 4: the uniform optimizer returns a minimum.** With the default +branch-and-bound component search (`uniformSubsetSearch = false`), the set a +successful `optimizeUniformExpanded` stores minimises the uniform length over +the restricted class (duplicate-free terms of in-degree at least 2): its +model length equals its uniform length and is at most every member's. The +certain-excluded class needs every telescope spine shorter than +`teleSubaddEnd` (`SpinesFit`), which the optimizer checks before it runs. -/ +theorem optimizeUniform_minimum {w : Nat} {limits : Limits} {ex : Expanded} + {res : UniformSharingResult} (hsub : limits.uniformSubsetSearch = false) + (h : optimizeUniformExpanded w limits ex = .ok res) : + IsMinimum ex.dag w ex.roots res.stored.toList ∧ + res.result.modelBytes = ulen ex.dag w ex.roots res.stored.toList := by + obtain ⟨_, hwf, hroots, _, hspines, c, hc, hfin⟩ := optimizeUniform_parts h + have hsp : SpinesFit (Prep.ofDag ex.dag) := hspines + have hreach := optimizeUniform_reach h + obtain ⟨hin, hcls, hstored, _, hmodel, _⟩ := uniformFinish_spec hfin + obtain ⟨_, hmb⟩ := optimizeUniform_modelBytes h + have hul : res.result.modelBytes = ulen ex.dag w ex.roots res.stored.toList := hmb + have hic : InClass ex.dag ex.roots res.stored.toList := by + rw [hstored]; exact inClass_of_check hin hcls + obtain ⟨Ys, hYs⟩ := minimum_exists ex.dag w ex.roots + have hle := uniformChoose_model_le hsub hwf hsp hroots hreach hc hYs + refine ⟨⟨hic, fun Y' hY' => ?_⟩, hul⟩ + rw [← hul, hmodel] + exact Nat.le_trans hle (hYs.2 Y' hY') + +/-! ## The tie order of the result -/ + +/-- The step of `bestSetOf`. -/ +def bestStepSet (bd : _root_.Int) (acc : Option (Array Nat)) (o : Option Entry) : Option (Array Nat) := + match o with + | some (d, s) => + if d == bd then + match acc with + | none => some s + | some a => if setPrec s a then some s else acc + else acc + | none => acc + +theorem bestSetOf_eq (tb : CTable) (bd : _root_.Int) : + bestSetOf tb bd = tb.toList.foldl (bestStepSet bd) none := by + unfold bestSetOf; rw [← Array.foldl_toList]; rfl + +/-- **The best set is the earliest set of value `bd`.** -/ +theorem bestSetOf_spec {tb : CTable} (hs : SortedT tb) {bd : _root_.Int} {bs : Array Nat} + (h : bestSetOf tb bd = some bs) : + (∃ e, some e ∈ tb.toList ∧ e.1 = bd ∧ e.2 = bs) ∧ + ∀ e, some e ∈ tb.toList → e.1 = bd → LeL bs.toList e.2.toList := by + rw [bestSetOf_eq] at h + have hsm : ∀ e, some e ∈ tb.toList → e.2.toList.Pairwise (· < ·) := by + intro e he + obtain ⟨k, hk⟩ := mem_toList_getElem! he + exact hs k e hk + -- invariant over the fold + have key : ∀ (l : List (Option Entry)), (∀ o ∈ l, o ∈ tb.toList) → ∀ acc, + (∀ a, acc = some a → (∃ e, some e ∈ tb.toList ∧ e.1 = bd ∧ e.2 = a) ∧ + a.toList.Pairwise (· < ·)) → + ∀ r, l.foldl (bestStepSet bd) acc = some r → + ((∃ e, some e ∈ tb.toList ∧ e.1 = bd ∧ e.2 = r) ∧ r.toList.Pairwise (· < ·)) ∧ + (∀ a, acc = some a → LeL r.toList a.toList) ∧ + ∀ e, some e ∈ l → e.1 = bd → LeL r.toList e.2.toList := by + intro l + induction l with + | nil => + intro _ acc hacc r hr + simp only [List.foldl_nil] at hr + subst hr + exact ⟨hacc r rfl, fun a ha => by cases ha; exact leL_refl _, + fun e he => absurd he List.not_mem_nil⟩ + | cons o l ih => + intro hl acc hacc r hr + rw [List.foldl_cons] at hr + have hacc' : ∀ a, bestStepSet bd acc o = some a → + ((∃ e, some e ∈ tb.toList ∧ e.1 = bd ∧ e.2 = a) ∧ a.toList.Pairwise (· < ·)) ∧ + (∀ a', acc = some a' → LeL a.toList a'.toList) ∧ + ∀ e, o = some e → e.1 = bd → LeL a.toList e.2.toList := by + intro a ha + cases o with + | none => + simp only [bestStepSet] at ha + refine ⟨hacc a ha, fun a' ha' => by rw [ha] at ha'; cases ha'; exact leL_refl _, + fun e he => by cases he⟩ + | some e => + obtain ⟨d, s⟩ := e + have hes : s.toList.Pairwise (· < ·) := hsm (d, s) (hl _ List.mem_cons_self) + simp only [bestStepSet] at ha + split at ha + · rename_i hdb + have hdb' : d = bd := by simpa using hdb + cases acc with + | none => + simp only [Option.some.injEq] at ha + subst ha + exact ⟨⟨⟨(d, s), hl _ List.mem_cons_self, hdb', rfl⟩, hes⟩, fun a' ha' => (by cases ha'), + fun e he _ => (by cases he; exact leL_refl _)⟩ + | some a0 => + obtain ⟨_, ha0s⟩ := hacc a0 rfl + simp only at ha + split at ha + · rename_i hp + simp only [Option.some.injEq] at ha + subst ha + exact ⟨⟨⟨(d, s), hl _ List.mem_cons_self, hdb', rfl⟩, hes⟩, + fun a' ha' => by cases ha'; exact Or.inr ((setPrec_iff hes ha0s).mp hp), + fun e he _ => by cases he; exact leL_refl _⟩ + · rename_i hp + simp only [Option.some.injEq] at ha + subst ha + refine ⟨hacc a0 rfl, fun a' ha' => by cases ha'; exact leL_refl _, fun e he _ => ?_⟩ + cases he + rcases leL_total ha0s hes with h | h + · exact h + · exact absurd ((setPrec_iff hes ha0s).mpr h) (by simp [hp]) + · rename_i hdb + refine ⟨hacc a ha, fun a' ha' => by rw [ha] at ha'; cases ha'; exact leL_refl _, + fun e he hed => ?_⟩ + cases he + simp at hdb + exact absurd hed hdb + have hstep_some : ∀ a, bestStepSet bd acc o = some a → + (∃ e, some e ∈ tb.toList ∧ e.1 = bd ∧ e.2 = a) ∧ a.toList.Pairwise (· < ·) := + fun a ha => (hacc' a ha).1 + obtain ⟨r1, r2, r3⟩ := ih (fun o' ho' => hl o' (List.mem_cons_of_mem _ ho')) _ hstep_some r hr + refine ⟨r1, fun a ha => ?_, fun e he hed => ?_⟩ + · -- the step's result is at least as early as `a` + cases hst : bestStepSet bd acc o with + | none => + -- the step never drops a set + exfalso + cases o with + | none => simp [bestStepSet, ha] at hst + | some e => + obtain ⟨d, s⟩ := e + simp only [bestStepSet, ha] at hst + split at hst + · split at hst <;> cases hst + · cases hst + | some a1 => exact leL_trans (r2 a1 hst) ((hacc' a1 hst).2.1 a ha) + · rcases List.mem_cons.mp he with he | he + · cases hst : bestStepSet bd acc o with + | none => + exfalso + subst he + obtain ⟨d, s⟩ := e + simp only at hed + simp only [bestStepSet, hed, beq_self_eq_true, if_true] at hst + cases acc with + | none => cases hst + | some a0 => simp only at hst; split at hst <;> cases hst + | some a1 => exact leL_trans (r2 a1 hst) ((hacc' a1 hst).2.2 e he.symm hed) + · exact r3 e he hed + obtain ⟨⟨r1, _⟩, _, r3⟩ := key tb.toList (fun o ho => ho) none (fun a ha => by cases ha) bs h + exact ⟨r1, fun e he hed => r3 e he hed⟩ + +/-- Termwise below with equal sums: termwise equal. -/ +theorem sum_eq_termwise : ∀ (as bs : List _root_.Int), as.length = bs.length → + (∀ j, j < as.length → as[j]! ≤ bs[j]!) → as.sum = bs.sum → ∀ j, j < as.length → as[j]! = bs[j]! + | [], [], _, _, _, j, hj => absurd hj (by simp) + | a :: as, b :: bs, hl, hle, hs, j, hj => by + simp only [List.length_cons, Nat.add_right_cancel_iff] at hl + have h0 := hle 0 (by simp) + simp only [List.getElem!_cons_zero] at h0 + have hrest : ∀ j, j < as.length → as[j]! ≤ bs[j]! := fun j hj => by + simpa using hle (j + 1) (by simp; omega) + have hsr : as.sum ≤ bs.sum := by + rw [sum_map_range' as, sum_map_range' bs, hl] + apply sum_le_sum_int + intro k hk + have := hrest k (by rw [hl]; exact List.mem_range.mp hk) + exact this + simp only [List.sum_cons] at hs + cases j with + | zero => simp; omega + | succ j => + simp only [List.getElem!_cons_succ] + exact sum_eq_termwise as bs hl hrest (by omega) j (by simp at hj; omega) + | [], _ :: _, hl, _, _, _, _ => by simp at hl + | _ :: _, [], hl, _, _, _, _ => by simp at hl + +/-- Merging per-universe sets keeps the tie order. -/ +theorem foldl_merge_leL (Uf : Nat → Nat → Prop) (hU : ∀ i i' x, i ≠ i' → Uf i x → ¬ Uf i' x) : + ∀ (As : List (Array Nat)) (Bs : List (List Nat)) (j0 : Nat) (acc : Array Nat) (B0 : List Nat), + As.length = Bs.length → + (∀ j, j < As.length → (∀ x ∈ As[j]!.toList, Uf (j0 + j) x) ∧ (∀ x ∈ Bs[j]!, Uf (j0 + j) x) ∧ + LeL As[j]!.toList Bs[j]!) → + (∀ x ∈ acc.toList, ∃ i, i < j0 ∧ Uf i x) → (∀ x ∈ B0, ∃ i, i < j0 ∧ Uf i x) → + LeL acc.toList B0 → + LeL (As.foldl mergeSorted acc).toList (B0 ++ Bs.flatten) + | [], Bs, _, acc, B0, hl, _, _, _, h => by + have : Bs = [] := List.eq_nil_of_length_eq_zero (by simpa using hl.symm) + subst this; simpa using h + | A :: As, B :: Bs, j0, acc, B0, hl, hall, hacc, hB0, h => by + simp only [List.length_cons, Nat.add_right_cancel_iff] at hl + rw [List.foldl_cons, List.flatten_cons, ← List.append_assoc] + obtain ⟨hA, hB, hAB⟩ := hall 0 (by simp) + simp only [List.getElem!_cons_zero, Nat.add_zero] at hA hB hAB + apply foldl_merge_leL Uf hU As Bs (j0 + 1) _ _ hl + · intro j hj + have := hall (j + 1) (by simp; omega) + simp only [List.getElem!_cons_succ] at this + rw [show j0 + 1 + j = j0 + (j + 1) by omega] + exact this + · intro x hx + rcases List.mem_append.mp ((mergeSorted_perm acc A).mem_iff.mp hx) with h | h + · obtain ⟨i, hi, hxi⟩ := hacc x h; exact ⟨i, by omega, hxi⟩ + · exact ⟨j0, by omega, hA x h⟩ + · intro x hx + rcases List.mem_append.mp hx with h | h + · obtain ⟨i, hi, hxi⟩ := hB0 x h; exact ⟨i, by omega, hxi⟩ + · exact ⟨j0, by omega, hB x h⟩ + · apply precL_union (X1 := acc.toList) (Y1 := B0) (X2 := A.toList) (Y2 := B) + · intro a ha hb + have ha' : ∃ i, i < j0 ∧ Uf i a := by + rcases ha with ha | ha + · exact hacc a ha + · exact hB0 a ha + have hb' : Uf j0 a := by + rcases hb with hb | hb + · exact hA a hb + · exact hB a hb + obtain ⟨i, hi, hia⟩ := ha' + exact hU i j0 a (by omega) hia hb' + · intro u; rw [(mergeSorted_perm acc A).mem_iff, List.mem_append] + · intro u; rw [List.mem_append] + · exact h + · exact hAB + | _ :: _, [], _, _, _, hl, _, _, _, _ => by simp at hl + +theorem foldl_merge_sorted (Uf : Nat → Nat → Prop) (hU : ∀ i i' x, i ≠ i' → Uf i x → ¬ Uf i' x) : + ∀ (As : List (Array Nat)) (j0 : Nat) (acc : Array Nat), + (∀ j, j < As.length → As[j]!.toList.Pairwise (· < ·) ∧ ∀ x ∈ As[j]!.toList, Uf (j0 + j) x) → + acc.toList.Pairwise (· < ·) → (∀ x ∈ acc.toList, ∃ i, i < j0 ∧ Uf i x) → + (As.foldl mergeSorted acc).toList.Pairwise (· < ·) + | [], _, _, _, h, _ => h + | A :: As, j0, acc, hall, hs, hacc => by + rw [List.foldl_cons] + obtain ⟨hA, hAU⟩ := hall 0 (by simp) + simp only [List.getElem!_cons_zero, Nat.add_zero] at hA hAU + apply foldl_merge_sorted Uf hU As (j0 + 1) _ (fun j hj => by + have := hall (j + 1) (by simp; omega) + simp only [List.getElem!_cons_succ] at this + rw [show j0 + 1 + j = j0 + (j + 1) by omega] + exact this) + · apply mergeSorted_strict hs hA + intro x hx hx' + obtain ⟨i, hi, hxi⟩ := hacc x hx + exact hU i j0 x (by omega) hxi (hAU x hx') + · intro x hx + rcases List.mem_append.mp ((mergeSorted_perm acc A).mem_iff.mp hx) with h | h + · obtain ⟨i, hi, hxi⟩ := hacc x h; exact ⟨i, by omega, hxi⟩ + · exact ⟨j0, by omega, hAU x h⟩ + +/-- **The knapsack's choice with the tie order.** -/ +theorem uniformKnapsack_tie {limits : Limits} {kCS : Nat} {results : Array CompResult} + {cd : _root_.Int} {cx : Array Nat} {lb : Bool} + (h : uniformKnapsack limits kCS results = .ok (cd, cx, lb)) + (Uf : Nat → Nat → Prop) (hU : ∀ i i' x, i ≠ i' → Uf i x → ¬ Uf i' x) + (ks : List Nat) (vs : List _root_.Int) (Ss : List (List Nat)) (hk : ks.length = results.size) + (hv : vs.length = results.size) (hS : Ss.length = results.size) + (hcj : ∀ j, j < results.size → + SortedT results[j]!.bySize ∧ Indexed results[j]!.bySize ∧ SetsIn results[j]!.bySize (Uf j) ∧ + HasAtT results[j]!.bySize ks[j]! vs[j]! Ss[j]! ∧ (∀ x ∈ Ss[j]!, Uf j x) ∧ + (∀ (k : Nat) (e : Entry), results[j]!.bySize[k]! = some e → results[j]!.bestDelta ≤ e.1) ∧ + bestSetOf results[j]!.bySize results[j]!.bestDelta = some results[j]!.bestSet) : + CLe (cd + (tag0Size (kCS + cx.size) : _root_.Int)) cx.toList + (vs.sum + (tag0Size (kCS + ks.sum) : _root_.Int)) Ss.flatten := by + -- per component: the best is below the choice, and the best set precedes it at a tie + have hbs : ∀ j, j < results.size → results[j]!.bestDelta ≤ vs[j]! ∧ + (results[j]!.bestDelta = vs[j]! → LeL results[j]!.bestSet.toList Ss[j]!) ∧ + results[j]!.bestSet.toList.Pairwise (· < ·) ∧ ∀ x ∈ results[j]!.bestSet.toList, Uf j x := by + intro j hjl + obtain ⟨hsrt, _, hset, hhas, _, hle, hbset⟩ := hcj j hjl + obtain ⟨⟨eb, heb, hebv, hebs⟩, hleast⟩ := bestSetOf_spec hsrt hbset + obtain ⟨kb, hkb⟩ := mem_toList_getElem! heb + obtain ⟨e, he, hev⟩ := hhas + have hbe := hle _ e he + refine ⟨by rcases hev with hev | ⟨hev, _⟩ <;> omega, fun heq => ?_, ?_, ?_⟩ + · rcases hev with hev | ⟨hev, hev'⟩ + · omega + · exact leL_trans (hleast e (getElem!_mem_toList he) (by omega)) hev' + · rw [← hebs]; exact hsrt kb eb hkb + · intro x hx; rw [← hebs] at hx; exact hset kb eb hkb x hx + -- the per-component bests combined + have hbest_eq : results.foldl (fun acc r => acc + r.bestDelta) (0 : _root_.Int) = + (results.toList.map (·.bestDelta)).sum := by + rw [← Array.foldl_toList, foldl_bestDelta_eq]; simp + have hbx_eq : results.foldl (fun acc r => mergeSorted acc r.bestSet) #[] = + (results.toList.map (·.bestSet)).foldl mergeSorted #[] := by + rw [← Array.foldl_toList, List.foldl_map] + have hgetL : ∀ {α : Type} [Inhabited α] (f : CompResult → α) {j : Nat}, j < results.size → + (results.toList.map f)[j]! = f results[j]! := by + intro α _ f j hj + rw [getElem!_pos _ j (by simpa using hj), List.getElem_map, getElem!_pos results j hj] + simp + have hbxs : ((results.toList.map (·.bestSet)).foldl mergeSorted #[]).toList.Pairwise (· < ·) := + foldl_merge_sorted Uf hU _ 0 #[] (fun j hj => by + simp only [List.length_map, Array.length_toList] at hj + rw [hgetL _ hj, Nat.zero_add] + exact ⟨(hbs j hj).2.2.1, (hbs j hj).2.2.2⟩) (by simp) (by simp) + have hsumle : (results.toList.map (·.bestDelta)).sum ≤ vs.sum := by + rw [sum_map_range (·.bestDelta) results.toList, sum_map_range' vs] + simp only [Array.length_toList, hv] + apply sum_le_sum_int + intro j hjr + have hj' := List.mem_range.mp hjr + rw [Array.getElem!_toList] + exact (hbs j hj').1 + -- the bracket comparison against the per-component bests + have hbracket : ∀ (bestDelta : _root_.Int) (bestX : Array Nat), bestDelta = + (results.toList.map (·.bestDelta)).sum → + bestX = (results.toList.map (·.bestSet)).foldl mergeSorted #[] → + tag0Size (kCS + bestX.size) ≤ tag0Size (kCS + ks.sum) → + CLe (bestDelta + (tag0Size (kCS + bestX.size) : _root_.Int)) bestX.toList + (vs.sum + (tag0Size (kCS + ks.sum) : _root_.Int)) Ss.flatten := by + intro bestDelta bestX hbd hbx ht + by_cases hlt : bestDelta + (tag0Size (kCS + bestX.size) : _root_.Int) < + vs.sum + (tag0Size (kCS + ks.sum) : _root_.Int) + · exact Or.inl hlt + · refine Or.inr ⟨by omega, ?_⟩ + have hsum : (results.toList.map (·.bestDelta)).sum = vs.sum := by omega + have hterm := sum_eq_termwise (results.toList.map (·.bestDelta)) vs (by simp [hv]) + (fun j hj => by + simp only [List.length_map, Array.length_toList] at hj + rw [hgetL _ hj]; exact (hbs j hj).1) hsum + rw [hbx] + have := foldl_merge_leL Uf hU (results.toList.map (·.bestSet)) Ss 0 #[] [] (by simp [hS]) + (fun j hj => by + simp only [List.length_map, Array.length_toList] at hj + rw [hgetL _ hj, Nat.zero_add] + refine ⟨(hbs j hj).2.2.2, (hcj j hj).2.2.2.2.1, (hbs j hj).2.1 ?_⟩ + have := hterm j (by simp; exact hj) + rw [hgetL _ hj] at this + exact this) (by simp) (by simp) (leL_refl _) + simpa using this + unfold uniformKnapsack at h + simp only at h + rw [hbx_eq, hbest_eq] at h + generalize hbx : (results.toList.map (·.bestSet)).foldl mergeSorted #[] = bestX at h hbxs + generalize hbd : (results.toList.map (·.bestDelta)).sum = bestDelta at h hsumle + split at h + · rename_i hstart + split at h + · cases h + · simp only [pure, Except.pure, Except.ok.injEq] at h + generalize hcap : tag0BracketStart (kCS + bestX.size) - 1 - kCS = cap at h + have hdp : results.foldl (fun dp r => knapStep cap dp r.bySize) + (#[some (0, #[])] ++ Array.replicate cap none) = + (results.toList.map (·.bySize)).foldl (knapStep cap) + (#[some (0, #[])] ++ Array.replicate cap none) := by + rw [← Array.foldl_toList, List.foldl_map] + rw [hdp] at h + have hts : ∀ j, j < (results.toList.map (·.bySize)).length → + (results.toList.map (·.bySize))[j]! = results[j]!.bySize := fun j hj => by + simp only [List.length_map, Array.length_toList] at hj + exact hgetL _ hj + have hsorted0 : SortedT (#[some (0, #[])] ++ Array.replicate cap none) := by + intro k e he + by_cases hk : k = 0 + · subst hk + rw [getElem!_pos _ 0 (by rw [Array.size_append]; simp; omega)] at he + simp at he + subst he + simp + · by_cases hk' : k < 1 + cap + · rw [getElem!_pos _ k (by simp; omega), Array.getElem_append_right (by simp; omega)] at he + simp at he + · simp [show ¬ k < 1 + cap by omega] at he + have hsets0 : SetsIn (#[some (0, #[])] ++ Array.replicate cap none) (fun x => ∃ i, i < 0 ∧ Uf i x) := by + intro k e he x hx + by_cases hk : k = 0 + · subst hk + rw [getElem!_pos _ 0 (by rw [Array.size_append]; simp; omega)] at he + simp at he; rw [← he] at hx; simp at hx + · by_cases hk' : k < 1 + cap + · rw [getElem!_pos _ k (by simp; omega), Array.getElem_append_right (by simp; omega)] at he + simp at he + · simp [show ¬ k < 1 + cap by omega] at he + have hdpS := knapFold_sorted (cap := cap) Uf hU (results.toList.map (·.bySize)) 0 _ + (fun j hj => by rw [hts j hj, Nat.zero_add] + simp only [List.length_map, Array.length_toList] at hj + exact ⟨(hcj j hj).1, (hcj j hj).2.2.1⟩) hsorted0 hsets0 + have hidx_dp := indexed_fold (cap := cap) (results.toList.map (·.bySize)) + (#[some (0, #[])] ++ Array.replicate cap none) + (fun t ht => by + obtain ⟨r, hr, rfl⟩ := List.mem_map.mp ht + obtain ⟨j, hj', hrj⟩ := List.mem_iff_getElem.mp hr + simp only [Array.length_toList] at hj' + have := (hcj j hj').2.1 + rw [getElem!_pos results j hj'] at this + simpa [← hrj] using this) + (indexed_dp0 cap) + obtain ⟨hc1, hc2⟩ := knapChoose_tie kCS hidx_dp hdpS (bestDelta, bestX, false) hbxs + rw [h] at hc1 hc2 + unfold knapTotal at hc1 hc2 + simp only at hc1 hc2 + by_cases hfit : ks.sum ≤ cap + · have hfold := knapFold_tie (cap := cap) Uf hU (results.toList.map (·.bySize)) 0 ks vs Ss + (#[some (0, #[])] ++ Array.replicate cap none) 0 0 [] + (by simp [hk]) (by simp [hv]) (by simp [hS]) + (fun j hj => by + rw [hts j hj, Nat.zero_add] + simp only [List.length_map, Array.length_toList] at hj + exact ⟨(hcj j hj).1, (hcj j hj).2.2.1, (hcj j hj).2.2.2.1, (hcj j hj).2.2.2.2.1⟩) + hsorted0 hsets0 + ⟨(0, #[]), by rw [getElem!_pos _ 0 (by rw [Array.size_append]; simp; omega)]; simp, + Or.inr ⟨rfl, leL_refl _⟩⟩ (by simp) (by omega) (by simp <;> omega) + obtain ⟨e, he, hev⟩ := hfold + have := hc2 (0 + ks.sum) e he + simp only [Nat.zero_add, Int.zero_add, List.nil_append] at this hev + refine cle_trans this ?_ + rcases hev with hev | ⟨hev, hev'⟩ + · exact Or.inl (by omega) + · exact Or.inr ⟨by omega, hev'⟩ + · exact cle_trans hc1 (hbracket bestDelta bestX hbd.symm hbx.symm + (tag0Size_ge_of_bracket (by omega))) + · rename_i hstart + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl, rfl⟩ := h + exact hbracket _ _ hbd.symm hbx.symm (tag0Size_ge_of_bracket (by omega)) + +theorem comps_disjoint {w : Nat} {ex : Expanded} (hwf : DagWF ex.dag) + (hchk : componentsChecked ex.dag (stg w ex).cls (stg w ex).opaq (stg w ex).comps + (componentLabels ex.dag.size (stg w ex).comps) = true) : + ∀ (i i' x : Nat), i ≠ i' → x ∈ (stg w ex).comps[i]!.toList → ¬ x ∈ (stg w ex).comps[i']!.toList := by + obtain ⟨hca, _, _, _⟩ := componentsChecked_spec hwf hchk + intro i i' x hii hx hx' + have hi : i < (stg w ex).comps.size := Classical.byContradiction fun h => by + rw [getElem!_neg (stg w ex).comps i h] at hx; exact absurd hx (by simp [default]; exact Array.not_mem_empty x) + have hi' : i' < (stg w ex).comps.size := Classical.byContradiction fun h => by + rw [getElem!_neg (stg w ex).comps i' h] at hx'; exact absurd hx' (by simp [default]; exact Array.not_mem_empty x) + have h1 := (hca i hi x hx).2.2 + have h2 := (hca i' hi' x hx').2.2 + rw [h1] at h2 + simp at h2 + exact hii h2 + +/-- **The chosen set with the tie order.** The model length and the chosen +uncertain set are at least as good as every minimum's length and uncertain +part. -/ +theorem uniformChoose_tie {w : Nat} {limits : Limits} {ex : Expanded} + (hsub : limits.uniformSubsetSearch = false) (hwf : DagWF ex.dag) + (hsp : SpinesFit (Prep.ofDag ex.dag)) + (hroots : ∀ r ∈ ex.roots.toList, r < ex.dag.size) + (hreach : ∀ y, y < ex.dag.size → ∃ r ∈ ex.roots.toList, Desc ex.dag r y) + {c : UniformChoice} (h : uniformChoose w limits ex (Prep.ofDag ex.dag) = .ok c) + {Y : List Nat} (hY : IsMinimum ex.dag w ex.roots Y) : + ∃ cx : Array Nat, c.stored = mergeSorted (stg w ex).cs cx ∧ + CLe (c.model : _root_.Int) cx.toList (ulen ex.dag w ex.roots Y : _root_.Int) + (compParts (stg w ex).comps Y (stg w ex).comps.size) := by + unfold uniformChoose at h + simp only at h + split at h + all_goals first | (cases h; done) | skip + rename_i hchk0 + have hchk : componentsChecked ex.dag (stg w ex).cls (stg w ex).opaq (stg w ex).comps + (componentLabels ex.dag.size (stg w ex).comps) = true := by simpa using hchk0 + obtain ⟨⟨results, s1, c1⟩, hsc, h⟩ := bind_eq_ok h + obtain ⟨⟨cd, cx, lb⟩, hkn, h⟩ := bind_eq_ok h + simp only at h hkn + split at h + · cases h + rename_i hneg + split at h + · cases h + simp only [pure, Except.pure, Except.ok.injEq] at h + subst h + refine ⟨cx, rfl, ?_⟩ + simp only + obtain ⟨hsize, hok⟩ := searchComponents_spec hsub hsc + let m := (stg w ex).comps.size + let V : Nat → List Nat := fun j => partOf Y (stg w ex).comps[j]!.toList + let Uf : Nat → Nat → Prop := fun j x => x ∈ (stg w ex).comps[j]!.toList + have hU : ∀ i i' x, i ≠ i' → Uf i x → ¬ Uf i' x := comps_disjoint hwf hchk + have hfacts : ∀ j, j < m → + SortedT results[j]!.bySize ∧ Indexed results[j]!.bySize ∧ SetsIn results[j]!.bySize (Uf j) ∧ + HasAtT results[j]!.bySize (V j).length ((compEnv w ex j).delta [] (V j)) (V j) ∧ + (∀ x ∈ V j, Uf j x) ∧ + (∀ (k : Nat) (e : Entry), results[j]!.bySize[k]! = some e → results[j]!.bestDelta ≤ e.1) ∧ + bestSetOf results[j]!.bySize results[j]!.bestDelta = some results[j]!.bestSet := by + intro j hj + obtain ⟨hpar, _, st0, st, hm0, hsolve, hbest, hbset⟩ := hok j hj + have hE := compEnv_wf hwf hsp hroots hreach hchk hj hpar + obtain ⟨htabj, hcovj⟩ := Env.component_table (E := compEnv w ex j) hE hsolve hm0 + exact ⟨htabj.sorted, fun k e he => (htabj k e he).1, fun k e he x hx => (htabj k e he).2.2.1 x hx, + hcovj Y hY, fun x hx => (partOf_sub x hx).1, fun k e he => best_le hbest he, hbset⟩ + let ks := (List.range m).map fun j => (V j).length + let vs := (List.range m).map fun j => (compEnv w ex j).delta [] (V j) + let Ss := (List.range m).map V + have hgr : ∀ {α : Type} [Inhabited α] (f : Nat → α) {j : Nat}, j < m → + ((List.range m).map f)[j]! = f j := by + intro α _ f j hj + rw [getElem!_pos _ j (by simpa using hj), List.getElem_map, List.getElem_range] + have hkt := uniformKnapsack_tie hkn Uf hU ks vs Ss (by simp [ks, hsize, m]) (by simp [vs, hsize, m]) + (by simp [Ss, hsize, m]) + (fun j hj => by + have hjm : j < m := by simp only [m]; omega + rw [hgr _ hjm, hgr _ hjm, hgr _ hjm] + exact hfacts j hjm) + -- the minimum's length, component by component + have hdec := ulen_compParts hwf hsp hroots hreach hchk Y m (Nat.le_refl _) + have hbase := csBase_eq (w := w) hwf hroots + have hperm := min_perm_parts hwf hsp hroots hreach hchk hY + rw [← ulen_perm hperm] at hdec + have hlen : ((stg w ex).cs.toList ++ compParts (stg w ex).comps Y m).length = + (stg w ex).cs.size + ks.sum := by + rw [List.length_append, compParts_length, Array.length_toList] + rw [hlen] at hdec + have hvs : vs.sum = (((List.range m).map fun j => scost (compCx w ex j) ex.dag (V j)).sum : _root_.Int) - + (((List.range m).map fun j => scost (compCx w ex j) ex.dag []).sum : _root_.Int) := by + rw [← sum_map_sub_int] + rfl + have hcs : (stg w ex).cs.toList.length = (stg w ex).cs.size := Array.length_toList + rw [hcs] at hbase hdec + have hflat : Ss.flatten = compParts (stg w ex).comps Y m := rfl + rw [hflat] at hkt + have hmodel : ((((csBase ex (Prep.ofDag ex.dag) (uniformStage w ex (Prep.ofDag ex.dag)) : Nat) : + _root_.Int) + cd + (tag0Size ((uniformStage w ex (Prep.ofDag ex.dag)).cs.size + cx.size) : _root_.Int)).toNat : + _root_.Int) = (csBase ex (Prep.ofDag ex.dag) (stg w ex) : _root_.Int) + cd + + (tag0Size ((stg w ex).cs.size + cx.size) : _root_.Int) := by + simp only [Int.not_lt] at hneg + rw [Int.toNat_of_nonneg hneg] + have hY' : (ulen ex.dag w ex.roots Y : _root_.Int) = (csBase ex (Prep.ofDag ex.dag) (stg w ex) : _root_.Int) + + (vs.sum + (tag0Size ((stg w ex).cs.size + ks.sum) : _root_.Int)) := by + simp only [V, m, ks, vs, stg] at hbase hdec hvs ⊢ + omega + rw [hmodel, hY'] + simp only [stg] at hkt ⊢ + rcases hkt with hk1 | ⟨hk1, hk2⟩ + · exact Or.inl (by omega) + · exact Or.inr ⟨by omega, hk2⟩ + +/-- **Stage 4: the uniform optimizer returns the tie-least minimum.** With the +default branch-and-bound component search, the set a successful +`optimizeUniformExpanded` stores minimises the uniform length over the +restricted class, its `modelBytes` is that length, and it comes first in the +tie order `setPrec` (the smallest term where it differs from another minimum +belongs to the other) among all minima. -/ +theorem optimizeUniform_least {w : Nat} {limits : Limits} {ex : Expanded} + {res : UniformSharingResult} (hsub : limits.uniformSubsetSearch = false) + (h : optimizeUniformExpanded w limits ex = .ok res) : + IsMinimum ex.dag w ex.roots res.stored.toList ∧ + res.result.modelBytes = ulen ex.dag w ex.roots res.stored.toList ∧ + ∀ Y, IsMinimum ex.dag w ex.roots Y → LeL res.stored.toList Y := by + obtain ⟨hmin, hmb⟩ := optimizeUniform_minimum hsub h + refine ⟨hmin, hmb, fun Y hY => ?_⟩ + obtain ⟨_, hwf, hroots, _, hspines, c, hc, hfin⟩ := optimizeUniform_parts h + have hsp : SpinesFit (Prep.ofDag ex.dag) := hspines + have hreach := optimizeUniform_reach h + obtain ⟨_, _, hstored, _, hmodel, _⟩ := uniformFinish_spec hfin + obtain ⟨cx, hcs, hcle⟩ := uniformChoose_tie hsub hwf hsp hroots hreach hc hY + -- both are minima, so their lengths agree + have h1 := hmin.2 Y hY.1 + have h2 := hY.2 _ hmin.1 + have hX : ulen ex.dag w ex.roots res.stored.toList = c.model := by rw [← hmb, hmodel] + have hcle' : LeL cx.toList (compParts (stg w ex).comps Y (stg w ex).comps.size) := by + rcases hcle with hlt | ⟨_, hle⟩ + · exfalso; omega + · exact hle + -- the stored set is the certain-stored terms and `cx`; a minimum is them and its parts + have hchk : componentsChecked ex.dag (stg w ex).cls (stg w ex).opaq (stg w ex).comps + (componentLabels ex.dag.size (stg w ex).comps) = true := by + unfold uniformChoose at hc + simp only at hc + split at hc + · simpa using (by assumption : _) + · cases hc + have hperm := min_perm_parts hwf hsp hroots hreach hchk hY + have hXperm : res.stored.toList.Perm ((stg w ex).cs.toList ++ cx.toList) := by + rw [hstored, hcs]; exact mergeSorted_perm _ _ + have hXn := hmin.1.1 + have hYn := hY.1.1 + have hdisjX := (List.nodup_append.mp (hXperm.nodup_iff.mp hXn)).2.2 + have hdisjY := (List.nodup_append.mp (hperm.nodup_iff.mp hYn)).2.2 + have hu := precL_union (X1 := (stg w ex).cs.toList) (Y1 := (stg w ex).cs.toList) + (X2 := cx.toList) (Y2 := compParts (stg w ex).comps Y (stg w ex).comps.size) + (X := res.stored.toList) (Y := Y) + (fun a ha hb => by + have ha' : a ∈ (stg w ex).cs.toList := by rcases ha with ha | ha <;> exact ha + rcases hb with hb | hb + · exact hdisjX a ha' a hb rfl + · exact hdisjY a ha' a hb rfl) + (fun u => by rw [hXperm.mem_iff, List.mem_append]) + (fun u => by rw [hperm.mem_iff, List.mem_append]) + (leL_refl _) hcle' + exact hu + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformOptimizer.lean b/Ix/Compile/Verify/UniformOptimizer.lean new file mode 100644 index 000000000..3cab8e611 --- /dev/null +++ b/Ix/Compile/Verify/UniformOptimizer.lean @@ -0,0 +1,339 @@ +import Ix.Compile.Verify.UniformModel + +/-! +# The uniform-width optimizer against the model + +`modelBytes` of `optimizeSharingUniform` is the model length +`uniformCost` of the stored set it returns, and the table it materializes is +a permutation of that set. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (bind_eq_ok indexOfTable_spec indexOfPairs_mem + getElem!_of_getElem? foldl_some_mem setBang_getElem! cp_of_childrenPrecede) + +/-! ## Pinned order -/ + +theorem toList_erase (xs : Array Nat) (a : Nat) : (xs.erase a).toList = xs.toList.erase a := by + rcases xs with ⟨xs⟩ + simp + +theorem pinnedPick_mem (deg : Array Nat) (deps : Std.HashMap Nat (Array Nat)) + (placed : Std.HashSet Nat) (remaining : Array Nat) {pick : Nat} + (h : pinnedPick deg deps placed remaining = some pick) : pick ∈ remaining.toList := by + unfold pinnedPick at h + rw [← Array.foldl_toList] at h + rcases foldl_some_mem _ (by + intro b o r hb + cases b with + | none => simp only [Option.some.injEq] at hb; exact Or.inl hb.symm + | some b => + simp only at hb + split at hb + · simp only [Option.some.injEq] at hb; exact Or.inl hb.symm + · exact Or.inr hb) _ _ _ h with hm | hm + · rw [Array.toList_filter] at hm + exact (List.mem_filter.mp hm).1 + · cases hm + +/-- The pinned order places every remaining term exactly once. -/ +theorem pinnedPlace_perm (deg : Array Nat) (deps : Std.HashMap Nat (Array Nat)) : + ∀ (fuel : Nat) (order remaining : Array Nat) (placed : Std.HashSet Nat), + (pinnedPlace deg deps fuel order remaining placed).toList.Perm + (order.toList ++ remaining.toList) := by + intro fuel + induction fuel with + | zero => intro order remaining placed; simp [pinnedPlace] + | succ fuel ih => + intro order remaining placed + simp only [pinnedPlace] + split + · simp + · rename_i pick hpick + have hmem := pinnedPick_mem deg deps placed remaining hpick + refine (ih _ _ _).trans ?_ + rw [Array.toList_push, toList_erase, List.append_assoc] + exact List.Perm.append_left _ (List.perm_cons_erase hmem).symm + +theorem pinnedOrder_perm (dag : Dag) (deg : Array Nat) (stored : Array Nat) : + (pinnedOrder dag deg stored).toList.Perm stored.toList := by + unfold pinnedOrder + simpa using pinnedPlace_perm deg (pinnedDeps dag stored) stored.size #[] stored {} + +/-! ## Dictionaries of a table -/ + +theorem getD_setBang (acc : Array (Option Nat)) (t u : Nat) (v : Option Nat) : + (acc.set! t v)[u]?.getD none = if t = u ∧ t < acc.size then v else acc[u]?.getD none := by + simp only [Array.set!, Array.getElem?_setIfInBounds] + by_cases h : t = u + · subst h + by_cases hs : t < acc.size <;> simp [hs] + · simp [h] + +theorem indexOfPairs_isSome : + ∀ (pairs : List (Nat × Nat)) (acc : Array (Option Nat)) (u : Nat), u < acc.size → + ((acc[u]?.getD none).isSome = true ∨ ∃ i, (u, i) ∈ pairs) → + ((pairs.foldl (fun acc (t, i) => acc.set! t (some i)) acc)[u]?.getD none).isSome = true := by + intro pairs + induction pairs with + | nil => + intro acc u _ h + rcases h with h | ⟨_, h⟩ + · exact h + · cases h + | cons x xs ih => + intro acc u hu h + obtain ⟨t, i⟩ := x + rw [List.foldl_cons] + apply ih _ u (by simp [Array.set!]; omega) + by_cases htu : t = u + · subst htu + left + rw [getD_setBang, if_pos ⟨rfl, hu⟩] + rfl + · rw [getD_setBang, if_neg (fun h => htu h.1)] + rcases h with h | ⟨i', hi'⟩ + · exact Or.inl h + · rcases List.mem_cons.mp hi' with h | h + · cases h; exact absurd rfl htu + · exact Or.inr ⟨i', h⟩ + +theorem indexOfPairs_size : + ∀ (pairs : List (Nat × Nat)) (acc : Array (Option Nat)), + (pairs.foldl (fun acc (t, i) => acc.set! t (some i)) acc).size = acc.size := by + intro pairs + induction pairs with + | nil => intro _; rfl + | cons x xs ih => intro acc; rw [List.foldl_cons, ih]; simp [Array.set!] + +/-- The dictionary of a table holds exactly the table's terms. -/ +theorem indexOfTable_isSome (size : Nat) (table : Array Nat) (hin : ∀ t ∈ table.toList, t < size) + (u : Nat) : + ((indexOfPairs size table.toList.zipIdx)[u]?.getD none).isSome = + decide (u ∈ table.toList) := by + by_cases hu : u ∈ table.toList + · rw [decide_eq_true hu] + obtain ⟨i, hi⟩ := List.mem_iff_getElem?.mp hu + unfold indexOfPairs + apply indexOfPairs_isSome _ _ u (by simp; exact hin u hu) + exact Or.inr ⟨i, List.mem_zipIdx_iff_getElem?.mpr hi⟩ + · rw [decide_eq_false hu] + cases hs : (indexOfPairs size table.toList.zipIdx)[u]?.getD none with + | none => rfl + | some i => + have := indexOfTable_spec size table u i hs + exact absurd (Array.mem_toList_iff.mpr (Array.mem_of_getElem? this)) hu + +theorem widthOfStored (n w : Nat) (stored : List Nat) (hin : ∀ t ∈ stored, t < n) (u : Nat) : + widthOf (stored.foldl (fun acc t => acc.set! t (some w)) (Array.replicate n none)) u = + if decide (u ∈ stored) then some w else none := by + unfold widthOf + suffices h : ∀ (l : List Nat) (acc : Array (Option Nat)), acc.size = n → + (∀ t ∈ l, t < n) → + (l.foldl (fun acc t => acc.set! t (some w)) acc)[u]?.getD none = + if u ∈ l then some w else acc[u]?.getD none by + rw [h stored _ (by simp) hin] + by_cases hu : u ∈ stored + · simp [hu] + · simp only [hu, decide_false, if_false, Bool.false_eq_true] + simp only [Array.getElem?_replicate] + split <;> rfl + intro l + induction l with + | nil => intro acc _ _; simp + | cons x xs ih => + intro acc hacc hl + rw [List.foldl_cons, ih _ (by simp [Array.set!, hacc]) + (fun t ht => hl t (List.mem_cons_of_mem _ ht)), getD_setBang] + have hx := hl x List.mem_cons_self + by_cases hux : u ∈ xs + · simp [hux] + · by_cases hxu : x = u + · subst hxu; simp [hacc, hx] + · simp [hux, hxu, Ne.symm hxu] + +/-! ## The materialized total -/ + +theorem foldl_add_eq_sum {α : Type} (f : α → Nat) : + ∀ (l : List α) (a : Nat), l.foldl (fun acc t => acc + f t) a = a + (l.map f).sum := by + intro l + induction l with + | nil => intro a; simp + | cons x xs ih => intro a; rw [List.foldl_cons, ih]; simp; omega + +theorem array_foldl_add_sum {α : Type} (f : α → Nat) (arr : Array α) : + arr.foldl (fun acc t => acc + f t) 0 = (arr.toList.map f).sum := by + rw [← Array.foldl_toList, foldl_add_eq_sum] + simp + +theorem materializeDependent_total {p : Prep} {table roots : Array Nat} + {width : Array (Option Nat)} {limits : Limits} {es rs : Array Ixon.Expr} {total work : Nat} + (h : p.materializeDependent table roots width limits = .ok (es, rs, total, work)) : + total = tag0Size table.size + + (table.toList.map (p.inlineCost (p.evalAll width) + (indexOfPairs p.dag.size table.toList.zipIdx) width)).sum + + (roots.toList.map fun r => (p.evalAll width).cost[r]!).sum := by + unfold Prep.materializeDependent at h + split at h + · cases h + simp only at h + split at h + · cases h + obtain ⟨es', _, h⟩ := bind_eq_ok h + obtain ⟨rs', _, h⟩ := bind_eq_ok h + cases h + rw [array_foldl_add_sum, array_foldl_add_sum] + +/-! ## The optimizer's last stage -/ + +/-- What a successful `uniformFinish` returns. -/ +theorem uniformFinish_spec {w : Nat} {limits : Limits} {ex : Expanded} {p : Prep} + {c : UniformChoice} {res : UniformSharingResult} + (h : uniformFinish w limits ex p c = .ok res) : + (∀ t ∈ c.stored.toList, t < ex.dag.size) ∧ inClassCheck ex.dag ex.roots c.stored = true ∧ + res.stored = c.stored ∧ + res.result.tableTerms = pinnedOrder ex.dag c.facts.deg c.stored ∧ + res.result.modelBytes = c.model ∧ + ∃ work, p.materializeDependent (pinnedOrder ex.dag c.facts.deg c.stored) ex.roots + (c.stored.foldl (fun acc t => acc.set! t (some w)) (Array.replicate ex.dag.size none)) + limits = .ok (res.result.sharing, res.result.roots, c.model, work) ∧ + res.result.variableBytes = tag0Size res.result.sharing.size + + exprsSize res.result.sharing + exprsSize res.result.roots := by + unfold uniformFinish at h + simp only at h + split at h + · rename_i hall + split at h + case isFalse => cases h + rename_i hcls + have hcls' : inClassCheck ex.dag ex.roots c.stored = true := by simpa using hcls + obtain ⟨⟨entries, roots, predicted, work⟩, hmat, h⟩ := bind_eq_ok h + simp only at h + split at h + · rename_i hpred + obtain ⟨⟨entryIds, rootIds, visits⟩, _, h⟩ := bind_eq_ok h + simp only at h + split at h + · split at h + · cases h + have hpm : predicted = c.model := by simpa using hpred + subst hpm + refine ⟨fun t ht => ?_, hcls', rfl, rfl, rfl, work, hmat, rfl⟩ + rw [Array.all_eq_true] at hall + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp ht + simpa using hall i (by simpa using hi) + · cases h + · cases h + · cases h + · cases h + +/-! ## `modelBytes` soundness -/ + +theorem dagWF_of_checks {dag : Dag} (hcp : childrenPrecede dag.nodes = true) + (har : dag.nodes.all (fun node => node.children.size == node.head.arity) = true) : + DagWF dag where + precede := cp_of_childrenPrecede hcp + arity := by + intro t ht + rw [Array.all_eq_true] at har + have := har t ht + rw [Ix.Compile.Verify.SharingExact.getElem!_eq_getElem _ t ht] + simpa using this + +/-- The optimizer's checks and its last stage. -/ +theorem optimizeUniform_parts {w : Nat} {limits : Limits} {ex : Expanded} + {res : UniformSharingResult} (h : optimizeUniformExpanded w limits ex = .ok res) : + w ≠ 0 ∧ DagWF ex.dag ∧ (∀ r ∈ ex.roots.toList, r < ex.dag.size) ∧ + (reachMarks ex.dag.nodes ex.roots).all id = true ∧ + (∀ t, t < ex.dag.size → (Prep.ofDag ex.dag).spineLen[t]! < teleSubaddEnd) ∧ + ∃ c, uniformChoose w limits ex (Prep.ofDag ex.dag) = .ok c ∧ + uniformFinish w limits ex (Prep.ofDag ex.dag) c = .ok res := by + unfold optimizeUniformExpanded at h + cases hw : (w == 0) with + | true => simp [hw] at h; cases h + | false => + cases hcp : childrenPrecede ex.dag.nodes with + | false => simp [hw, hcp] at h; cases h + | true => + cases har : ex.dag.nodes.all (fun node => node.children.size == node.head.arity) with + | false => simp [hw, hcp, har] at h; cases h + | true => + cases hr : ex.roots.all (· < ex.dag.size) with + | false => simp [hw, hcp, har, hr] at h; cases h + | true => + cases hm : (reachMarks ex.dag.nodes ex.roots).all id with + | false => + simp only [hw, hcp, har, hr, hm, Bool.false_eq_true, + ↓reduceIte] at h + cases h + | true => + simp only [hw, hcp, har, hr, hm, Bool.false_eq_true, if_false, if_true] at h + cases hs : (List.range ex.dag.size).all + (fun t => (Prep.ofDag ex.dag).spineLen[t]! < teleSubaddEnd) with + | false => + simp only [hs, Bool.false_eq_true, ↓reduceIte] at h + cases h + | true => + simp only [hs, ↓reduceIte] at h + obtain ⟨c, hc, h⟩ := bind_eq_ok h + refine ⟨by simpa using hw, dagWF_of_checks hcp har, fun r hrm => ?_, rfl, + fun t ht => ?_, c, hc, h⟩ + · rw [Array.all_eq_true] at hr + obtain ⟨i, hi, rfl⟩ := List.mem_iff_getElem.mp hrm + simpa using hr i (by simpa using hi) + · rw [List.all_eq_true] at hs + simpa using hs t (List.mem_range.mpr ht) + +/-- **`modelBytes` soundness.** The model length reported by the uniform +optimizer is `uniformCost` of the stored set it returns (every stored term +at width `w`, each entry at its cheapest inline writing, each root at its +cheapest standalone writing), and the materialized table is a permutation +of that set. -/ +theorem optimizeUniform_modelBytes {w : Nat} {limits : Limits} {ex : Expanded} + {res : UniformSharingResult} (h : optimizeUniformExpanded w limits ex = .ok res) : + res.result.tableTerms.toList.Perm res.stored.toList ∧ + res.result.modelBytes = uniformCost (Prep.ofDag ex.dag) w + (fun t => decide (t ∈ res.stored.toList)) res.stored.toList ex.roots.toList := by + obtain ⟨_, hwf, _, _, _, c, _, hfin⟩ := optimizeUniform_parts h + obtain ⟨hin, _, hstored, htable, hmodel, work, hmat, _⟩ := uniformFinish_spec hfin + have hp := prepWF_ofDag hwf + have hempty := ofDag_empty_size ex.dag + let p := Prep.ofDag ex.dag + let order := pinnedOrder ex.dag c.facts.deg c.stored + have hperm : order.toList.Perm c.stored.toList := pinnedOrder_perm _ _ _ + have hin' : ∀ t ∈ order.toList, t < p.dag.size := fun t ht => hin t (hperm.subset ht) + have hwidth : ∀ u, widthOf (c.stored.foldl (fun acc t => acc.set! t (some w)) + (Array.replicate ex.dag.size none)) u = + if (fun t => decide (t ∈ c.stored.toList)) u then some w else none := by + intro u + rw [← Array.foldl_toList] + exact widthOfStored ex.dag.size w c.stored.toList hin u + have hindex : ∀ u, ((indexOfPairs p.dag.size order.toList.zipIdx)[u]?.getD none).isSome = + (fun t => decide (t ∈ c.stored.toList)) u := by + intro u + rw [indexOfTable_isSome _ order hin' u] + simp only [decide_eq_decide] + exact hperm.mem_iff + refine ⟨by rw [htable, hstored]; exact hperm, ?_⟩ + rw [hmodel, materializeDependent_total hmat, hstored] + unfold uniformCost + have hlen : order.size = c.stored.toList.length := by + rw [← Array.length_toList]; exact hperm.length_eq + have hentries : (order.toList.map (p.inlineCost (p.evalAll + (c.stored.foldl (fun acc t => acc.set! t (some w)) (Array.replicate ex.dag.size none))) + (indexOfPairs p.dag.size order.toList.zipIdx) + (c.stored.foldl (fun acc t => acc.set! t (some w)) (Array.replicate ex.dag.size none)))).sum = + (c.stored.toList.map (uInl p w (fun t => decide (t ∈ c.stored.toList)))).sum := by + rw [List.map_congr_left (fun t ht => hp.inlineCost_eq hempty _ _ hwidth hindex t (hin' t ht))] + exact List.Perm.sum_nat (hperm.map _) + have hroots : (ex.roots.toList.map fun r => (p.evalAll + (c.stored.foldl (fun acc t => acc.set! t (some w)) + (Array.replicate ex.dag.size none))).cost[r]!).sum = + (ex.roots.toList.map (uCost p w (fun t => decide (t ∈ c.stored.toList)))).sum := by + rw [List.map_congr_left (fun r _ => hp.evalAll_cost hempty _ hwidth r)] + simp only [p, order] at hentries hroots hlen + rw [hlen, hentries, hroots] + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformRevisible.lean b/Ix/Compile/Verify/UniformRevisible.lean new file mode 100644 index 000000000..6f9bfc36a --- /dev/null +++ b/Ix/Compile/Verify/UniformRevisible.lean @@ -0,0 +1,342 @@ +import Ix.Compile.Verify.UniformOptimal + +/-! +# Stage 4: the visible counts of a search node + +Visible counts are positive and antitone in the maybe-stored set, and the +counts `revisible` recomputes at a search node are below the visible counts +of the node's maybe-stored set, so the node's reclassification is sound. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (Desc child_eq_getElem setBang_getElem!) + +/-- A path is empty or ends in an edge. -/ +theorem desc_last {dag : Dag} {r y : Nat} (h : Desc dag r y) : + r = y ∨ ∃ z k, Desc dag r z ∧ k < (dag.node z).children.size ∧ (dag.node z).child k = y := by + induction h with + | refl => exact Or.inl rfl + | @child t u k hk _ ih => + rcases ih with h | ⟨z, k', hz, hk', he⟩ + · exact Or.inr ⟨t, k, .refl _, hk, h⟩ + · exact Or.inr ⟨z, k', .child k hk hz, hk', he⟩ + +theorem edgeAll_pos {dag : Dag} {z y k : Nat} (hk : k < (dag.node z).head.arity) + (he : (dag.node z).child k = y) : 1 ≤ edgeAll (Prep.ofDag dag) z y := by + unfold edgeAll edgeMult + simp only [ofDag_dag] + have hmem : ∀ c : Bool, continuationEdge (dag.node z) k (dag.node y) = c → + k ∈ (List.range (dag.node z).head.arity).filter (fun i => (dag.node z).child i == y && + continuationEdge (dag.node z) i (dag.node y) == c) := by + intro c hc + simp [List.mem_filter, List.mem_range, hk, he, hc] + cases hc : continuationEdge (dag.node z) k (dag.node y) + · have := List.length_pos_of_mem (hmem false hc); omega + · have := List.length_pos_of_mem (hmem true hc); omega + +theorem le_sum_of_mem_nat : ∀ {l : List Nat} {a : Nat}, a ∈ l → a ≤ l.sum + | [], _, h => absurd h List.not_mem_nil + | x :: xs, a, h => by + rcases List.mem_cons.mp h with rfl | h + · simp + · have := le_sum_of_mem_nat h; simp; omega + +theorem sum_range_ge (f : Nat → Nat) {n z : Nat} (hz : z < n) : + f z ≤ ((List.range n).map f).sum := by + have hmem : f z ∈ (List.range n).map f := List.mem_map.mpr ⟨z, List.mem_range.mpr hz, rfl⟩ + exact le_sum_of_mem_nat hmem + +/-- **Visible counts are positive** on a DAG whose roots reach every term. -/ +theorem vis_pos {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y) (ms : Array Bool) : + ∀ y, y < dag.size → 1 ≤ (visibleCounts dag roots ms).1[y]! := by + have key : ∀ m y, dag.size - y = m → y < dag.size → 1 ≤ (visibleCounts dag roots ms).1[y]! := by + intro m + induction m using Nat.strongRecOn with + | _ m ih => + intro y hm hy + rw [(visibleCounts_spec hwf roots hroots ms hy).1] + obtain ⟨r, hr, hd⟩ := hreach y hy + rcases desc_last hd with rfl | ⟨z, k, hz, hk, he⟩ + · have := List.count_pos_iff.mpr hr + omega + · have hrn := hroots r hr + have hzn : z < dag.size := Nat.lt_of_le_of_lt (Desc.le_of_wf hwf hz hrn) hrn + have hyz : y < z := by + rw [← he, child_eq_getElem _ k hk] + exact hwf.child_lt hzn (Array.getElem_mem _) + have hk' : k < (dag.node z).head.arity := by rw [← hwf.children_size hzn]; exact hk + have he1 := edgeAll_pos hk' he + have hw1 : 1 ≤ visWeight ms (visibleCounts dag roots ms).1 z := by + unfold visWeight + split + · exact Nat.le_refl 1 + · have := ih (dag.size - z) (by omega) z rfl hzn + unfold visibleCap; simp only [Nat.le_min]; omega + have := sum_range_ge (fun y' => edgeAll (Prep.ofDag dag) y' y * + visWeight ms (visibleCounts dag roots ms).1 y') hzn + have := Nat.mul_le_mul he1 hw1 + omega + exact fun y hy => key _ y rfl hy + +/-- **Visible counts are antitone** in the maybe-stored set. -/ +theorem vis_mono {dag : Dag} (hwf : DagWF dag) (roots : Array Nat) + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y) {ms ms' : Array Bool} + (hms : ∀ v : Nat, ms'[v]! = true → ms[v]! = true) : + ∀ t, t < dag.size → (visibleCounts dag roots ms).1[t]! ≤ (visibleCounts dag roots ms').1[t]! ∧ + (visibleCounts dag roots ms).2[t]! ≤ (visibleCounts dag roots ms').2[t]! := by + have hp := prepWF_ofDag hwf + have key : ∀ m t, dag.size - t = m → t < dag.size → + (visibleCounts dag roots ms).1[t]! ≤ (visibleCounts dag roots ms').1[t]! ∧ + (visibleCounts dag roots ms).2[t]! ≤ (visibleCounts dag roots ms').2[t]! := by + intro m + induction m using Nat.strongRecOn with + | _ m ih => + intro t hm ht + obtain ⟨a1, a2⟩ := visibleCounts_spec hwf roots hroots ms ht + obtain ⟨b1, b2⟩ := visibleCounts_spec hwf roots hroots ms' ht + have hw : ∀ y ∈ List.range dag.size, t < y → + visWeight ms (visibleCounts dag roots ms).1 y ≤ + visWeight ms' (visibleCounts dag roots ms').1 y := by + intro y hy hty + have hyn := List.mem_range.mp hy + unfold visWeight + by_cases h1 : ms'[y]! = true + · rw [if_pos h1, if_pos (hms y h1)] + exact Nat.le_refl 1 + · rw [if_neg h1] + by_cases h2 : ms[y]! = true + · rw [if_pos h2] + have := vis_pos hwf roots hroots hreach ms' y hyn + unfold visibleCap; simp only [Nat.le_min]; omega + · rw [if_neg h2] + have := (ih (dag.size - y) (by omega) y rfl hyn).1 + simp only [Nat.min_def]; split <;> split <;> omega + have hterm : ∀ (e : Nat → Nat), (∀ y, y ≤ t → e y = 0) → + ((List.range dag.size).map fun y => e y * + visWeight ms (visibleCounts dag roots ms).1 y).sum ≤ + ((List.range dag.size).map fun y => e y * + visWeight ms' (visibleCounts dag roots ms').1 y).sum := by + intro e he + apply sum_le_sum_of_le + intro y hy + by_cases hty : t < y + · exact Nat.mul_le_mul_left _ (hw y hy hty) + · rw [he y (by omega)]; simp + refine ⟨?_, ?_⟩ + · rw [a1, b1] + exact Nat.add_le_add_left (hterm _ (fun y hy => edgeAll_zero_of_le hp hy)) _ + · rw [a2, b2] + exact Nat.add_le_add_left (hterm _ (fun y hy => edgeMult_zero_of_le hp hy false)) _ + exact fun t ht => key _ t rfl ht + +/-! ## The recomputed counts of a search node -/ + +/-- What the area tables of a component's context satisfy. -/ +structure AreaWF (dag : Dag) (roots : Array Nat) (cx : SCtx) : Prop where + rootOcc : ∀ j, j < cx.area.size → cx.rootOcc[j]! ≤ roots.toList.count cx.area[j]! + nodup : ∀ j, j < cx.area.size → ((cx.inEdges[j]!).toList.map (·.1)).Nodup + lt : ∀ j, j < cx.area.size → ∀ e ∈ (cx.inEdges[j]!).toList, e.1 < dag.size + cnt : ∀ j, j < cx.area.size → ∀ e ∈ (cx.inEdges[j]!).toList, + e.2.1 ≤ edgeAll (Prep.ofDag dag) e.1 cx.area[j]! ∧ + e.2.2 ≤ edgeMult (Prep.ofDag dag) e.1 cx.area[j]! false + +theorem foldl_pair_sum (W : Nat → Nat) : + ∀ (l : List (Nat × Nat × Nat)) (a b : Nat), + l.foldl (fun (dh : Nat × Nat) (e : Nat × Nat × Nat) => + (dh.1 + e.2.1 * W e.1, dh.2 + e.2.2 * W e.1)) (a, b) = + (a + (l.map fun e => e.2.1 * W e.1).sum, b + (l.map fun e => e.2.2 * W e.1).sum) + | [], a, b => by simp + | e :: l, a, b => by + rw [List.foldl_cons, foldl_pair_sum W l] + simp only [List.map_cons, List.sum_cons, Prod.mk.injEq] + omega + +theorem sum_le_sum_map {α : Type} {f g : α → Nat} : + ∀ (l : List α), (∀ a ∈ l, f a ≤ g a) → (l.map f).sum ≤ (l.map g).sum + | [], _ => Nat.le_refl 0 + | a :: l, h => by + simp only [List.map_cons, List.sum_cons] + have := sum_le_sum_map l (fun b hb => h b (List.mem_cons_of_mem _ hb)) + have := h a List.mem_cons_self + omega + +/-- Sum over a duplicate-free list of parents, below the sum over all terms. -/ +theorem sum_parents_le (f : Nat → Nat) {L : List Nat} {n : Nat} (hL : L.Nodup) + (hlt : ∀ q ∈ L, q < n) : (L.map f).sum ≤ ((List.range n).map f).sum := + sum_le_of_subset f hL List.nodup_range (fun q hq => List.mem_range.mpr (hlt q hq)) + +/-- **The recomputed counts are below the visible counts** of the node's +maybe-stored set (within the candidates). -/ +theorem revisible_le {dag : Dag} (hwf : DagWF dag) {roots : Array Nat} + (hroots : ∀ r ∈ roots.toList, r < dag.size) + (hreach : ∀ y, y < dag.size → ∃ r ∈ roots.toList, Desc dag r y) + {w : Nat} {θ : _root_.Int} {cs : List Nat} {cx : SCtx} (hcx : SCtxWF dag roots w θ cs cx) + (ha : AreaWF dag roots cx) {ms : Array Bool} + (hms : ∀ v : Nat, ms[v]! = true → (ucand dag roots w)[v]! = true) : + ∀ t, t < dag.size → (cx.revisible ms).1[t]! ≤ (visibleCounts dag roots ms).1[t]! ∧ + (cx.revisible ms).2[t]! ≤ (visibleCounts dag roots ms).2[t]! := by + let Vm := visibleCounts dag roots ms + let Inv : Array Nat × Array Nat → Prop := fun dh => + ∀ t, t < dag.size → dh.1[t]! ≤ Vm.1[t]! ∧ dh.2[t]! ≤ Vm.2[t]! + have hinit : Inv cx.vis0 := by + intro t ht + rw [hcx.vis0] + exact vis_mono hwf roots hroots hreach hms t ht + have hstep : ∀ (ds hs : Array Nat) (k : Nat), Inv (ds, hs) → k < cx.area.size → + Inv (let j := cx.area.size - 1 - k + let y := cx.area[j]! + let r := cx.rootOcc[j]! + let dh := cx.inEdges[j]!.foldl (fun (dh : Nat × Nat) (e : Nat × Nat × Nat) => + let wq := if ms[e.1]! then 1 else min ds[e.1]! visibleCap + (dh.1 + e.2.1 * wq, dh.2 + e.2.2 * wq)) (r, r) + (ds.set! y dh.1, hs.set! y dh.2)) := by + intro ds hs k hinv hk + simp only + generalize hj : cx.area.size - 1 - k = j + have hjs : j < cx.area.size := by omega + let W : Nat → Nat := fun q => if ms[q]! then 1 else min ds[q]! visibleCap + have hfold := foldl_pair_sum W (cx.inEdges[j]!).toList (cx.rootOcc[j]!) (cx.rootOcc[j]!) + rw [Array.foldl_toList] at hfold + simp only [W] at hfold + rw [hfold] + generalize hy : cx.area[j]! = y + have hW : ∀ q, q < dag.size → W q ≤ visWeight ms Vm.1 q := by + intro q hq + simp only [W, visWeight] + split + · exact Nat.le_refl 1 + · have := (hinv q hq).1 + simp only at this + simp only [Nat.min_def]; split <;> split <;> omega + have hbound : ∀ (c : Bool), y < dag.size → + (cx.rootOcc[j]! + ((cx.inEdges[j]!).toList.map fun e => + (if c then e.2.2 else e.2.1) * W e.1).sum) ≤ + roots.toList.count y + ((List.range dag.size).map fun q => + (if c then edgeMult (Prep.ofDag dag) q y false else edgeAll (Prep.ofDag dag) q y) * + visWeight ms Vm.1 q).sum := by + intro c hyn + have h1 : cx.rootOcc[j]! ≤ roots.toList.count y := by rw [← hy]; exact ha.rootOcc j hjs + have h2 : ((cx.inEdges[j]!).toList.map fun e => (if c then e.2.2 else e.2.1) * W e.1).sum ≤ + (((cx.inEdges[j]!).toList.map (·.1)).map fun q => + (if c then edgeMult (Prep.ofDag dag) q y false else edgeAll (Prep.ofDag dag) q y) * + visWeight ms Vm.1 q).sum := by + rw [List.map_map] + apply sum_le_sum_map + intro e he + have hc := ha.cnt j hjs e he + rw [hy] at hc + have hq := ha.lt j hjs e he + cases c + · exact Nat.mul_le_mul hc.1 (hW e.1 hq) + · exact Nat.mul_le_mul hc.2 (hW e.1 hq) + have h3 := sum_parents_le (fun q => + (if c then edgeMult (Prep.ofDag dag) q y false else edgeAll (Prep.ofDag dag) q y) * + visWeight ms Vm.1 q) (ha.nodup j hjs) + (fun q hq => by + obtain ⟨e, he, rfl⟩ := List.mem_map.mp hq + exact ha.lt j hjs e he) + omega + intro t ht + simp only + rw [setBang_getElem!, setBang_getElem!] + by_cases hyt : y = t + · subst hyt + have e := visibleCounts_spec hwf roots hroots ms ht + refine ⟨?_, ?_⟩ + · by_cases hs : y < ds.size + · rw [if_pos ⟨rfl, hs⟩] + have := hbound false ht + simp only [Bool.false_eq_true, if_false] at this + rw [e.1]; exact this + · rw [if_neg (fun h => hs h.2)]; exact (hinv y ht).1 + · by_cases hs : y < hs.size + · rw [if_pos ⟨rfl, hs⟩] + have := hbound true ht + simp only [if_true] at this + rw [e.2]; exact this + · rw [if_neg (fun h => hs h.2)]; exact (hinv y ht).2 + · rw [if_neg (fun h => hyt h.1), if_neg (fun h => hyt h.1)] + exact hinv t ht + have hall : ∀ (l : List Nat) (acc : Array Nat × Array Nat), (∀ k ∈ l, k < cx.area.size) → + Inv acc → Inv (l.foldl (fun (acc : Array Nat × Array Nat) k => + match acc with + | (ds, hs) => + let j := cx.area.size - 1 - k + let y := cx.area[j]! + let r := cx.rootOcc[j]! + let dh := cx.inEdges[j]!.foldl (fun (dh : Nat × Nat) (e : Nat × Nat × Nat) => + let wq := if ms[e.1]! then 1 else min ds[e.1]! visibleCap + (dh.1 + e.2.1 * wq, dh.2 + e.2.2 * wq)) (r, r) + (ds.set! y dh.1, hs.set! y dh.2)) acc) := by + intro l + induction l with + | nil => intro acc _ h; exact h + | cons k l ih => + intro acc hl h + rw [List.foldl_cons] + apply ih _ (fun k' hk' => hl k' (List.mem_cons_of_mem _ hk')) + obtain ⟨ds, hs⟩ := acc + exact hstep ds hs k h (hl k List.mem_cons_self) + intro t ht + exact hall (List.range cx.area.size) cx.vis0 (fun k hk => List.mem_range.mp hk) hinit t ht + +/-- The node's bounds are below the bounds of its maybe-stored set. -/ +theorem rebound_le {dag : Dag} (hwf : DagWF dag) {roots : Array Nat} {w : Nat} {θ : _root_.Int} + {cs : List Nat} {cx : SCtx} (hcx : SCtxWF dag roots w θ cs cx) {ms : Array Bool} + (hms : ∀ v : Nat, ms[v]! = true → (ucand dag roots w)[v]! = true) : + BLe (cx.rebound ms) (uniformBounds (Prep.ofDag dag) w ms) := by + have hp := prepWF_ofDag hwf + unfold SCtx.rebound + rw [hcx.prep, hcx.width, hcx.bounds0, ← Array.foldl_toList] + exact hp.boundsFold_le w cx.area.toList _ + (uniformBounds_antitone (Prep.ofDag dag) w hms) (uniformBounds_size _ _ _) + +/-- **Reclassification at a search node is sound.** A member whose gain under +the node's bounds and recomputed counts reaches the threshold (with +`1 ≤ d` and `h ≤ d`) is in every minimum that stores no decided-out term. -/ +theorem forced_mem {dag : Dag} {roots : Array Nat} {w : Nat} {θ : _root_.Int} {cs : List Nat} + (hG : GlobalWF dag roots w θ cs) {cx : SCtx} (hcx : SCtxWF dag roots w θ cs cx) + (ha : AreaWF dag roots cx) {outAll : Array Nat} {Y : List Nat} + (hY : IsMinimum dag w roots Y) (hYo : ∀ t ∈ outAll.toList, t ∉ Y) {t : Nat} + (htm : t ∈ cx.members.toList) + (hd1 : 1 ≤ (cx.revisible (msOf cx.cand outAll)).1[t]!) + (hhd : (cx.revisible (msOf cx.cand outAll)).2[t]! ≤ (cx.revisible (msOf cx.cand outAll)).1[t]!) + (hgain : storedGainWith cx.up.prep (cx.rebound (msOf cx.cand outAll)) cx.up.w t + (cx.revisible (msOf cx.cand outAll)).1[t]! (cx.revisible (msOf cx.cand outAll)).2[t]! ≥ + cx.theta) : t ∈ Y := by + have hwf := hG.wf + obtain ⟨htn, htu⟩ := hcx.mem t htm + have htc : (ucand dag roots w)[t]! = true := ucand_of_ucls htn (Or.inr htu) + generalize hmsd : msOf cx.cand outAll = ms at hd1 hhd hgain + have hms : ∀ v : Nat, ms[v]! = true → (ucand dag roots w)[v]! = true := by + intro v hv + rw [← hmsd] at hv + have := (msOf_spec cx.cand outAll v).mp hv + rw [hcx.cand] at this + exact this.1 + have hYms : ∀ s ∈ Y, ms[s]! = true := by + intro s hs + rw [← hmsd] + apply (msOf_spec cx.cand outAll s).mpr + obtain ⟨hsn, hcl⟩ := hG.min_class hY hs + rw [hcx.cand] + exact ⟨ucand_of_ucls hsn hcl, fun h => hYo s h hs⟩ + have hble := rebound_le hwf hcx hms + have hvis := revisible_le hwf hG.hroots hG.reach hcx ha hms t htn + rw [hcx.prep, hcx.width, hcx.theta] at hgain + refine Classical.byContradiction (fun htY => ?_) + have hθ := hG.theta_ok hY htn htc htY + apply htY + exact stored_in_minimum hwf roots hG.hroots hG.reach w ms hY hYms htn + (deg_of_ucls htn (Or.inr htu)) (hble t).1 (hble t).2.1 hvis.1 hvis.2 hhd hd1 + (fun _ => minimum_length_lt hwf hG.spines roots hG.hroots w hY htn htc htY) + (by rcases hθ with h | ⟨h, hb⟩ + · left; rw [h] at hgain; exact hgain + · right; rw [h] at hgain; exact ⟨hgain, hb⟩) + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformSearch.lean b/Ix/Compile/Verify/UniformSearch.lean new file mode 100644 index 000000000..254c1ff60 --- /dev/null +++ b/Ix/Compile/Verify/UniformSearch.lean @@ -0,0 +1,742 @@ +import Ix.Compile.Verify.UniformChecks +import Ix.Compile.Verify.UniformFinal + +/-! +# Stage 4: specifications of the component search's checks and tables + +The restricted reach-label pass (`reachLabelsOn`) over the members' +ancestors (`upClosure`), the label and mark tables, and what a passing +group separation check (`SCtx.sepCheck`) guarantees. These are proofs about the +implementation module of the same name, `Ix.Sharing.Exact.UniformSearch`; +they extend the namespace `Ix.Compile.Verify.UniformModel`. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (Desc child_eq_getElem setBang_getElem!) + +/-! ## Folds of `set!` -/ + +theorem size_setBang {α : Type} (a : Array α) (i : Nat) (v : α) : (a.set! i v).size = a.size := by + simp [Array.set!] + +/-- Setting a constant along a list. -/ +theorem foldl_setBang_const {α : Type} [Inhabited α] (v : α) : + ∀ (l : List Nat) (a : Array α) (x : Nat), + (l.foldl (fun acc t => acc.set! t v) a)[x]! = if x ∈ l ∧ x < a.size then v else a[x]! + | [], a, x => by simp + | t :: l, a, x => by + rw [List.foldl_cons, foldl_setBang_const v l _ x, size_setBang, setBang_getElem!] + by_cases hxt : t = x + · subst hxt + by_cases hx : t < a.size <;> by_cases hxl : t ∈ l <;> simp [hx, hxl] + · have : x ≠ t := fun h => hxt h.symm + simp [hxt, this] + +theorem foldl_setBang_const_size {α : Type} (v : α) : + ∀ (l : List Nat) (a : Array α), (l.foldl (fun acc t => acc.set! t v) a).size = a.size + | [], _ => rfl + | t :: l, a => by rw [List.foldl_cons, foldl_setBang_const_size v l, size_setBang] + +/-- Or-ing a value into a table along a list. -/ +theorem foldl_setBang_or (f : Nat → Bool) : + ∀ (l : List Nat) (a : Array Bool) (x : Nat), + (l.foldl (fun acc t => acc.set! t (acc[t]! || f t)) a)[x]! = + (a[x]! || (decide (x ∈ l) && decide (x < a.size) && f x)) + | [], a, x => by simp + | t :: l, a, x => by + rw [List.foldl_cons, foldl_setBang_or f l _ x, size_setBang, setBang_getElem!] + by_cases hxt : t = x + · subst hxt + by_cases hx : t < a.size <;> by_cases hxl : t ∈ l <;> cases a[t]! <;> cases f t <;> + simp [hx, hxl] + · have : x ≠ t := fun h => hxt h.symm + simp [hxt, this] + +/-! ## Mark and label tables -/ + +theorem markTable_spec (n : Nat) (ts : Array Nat) (x : Nat) : + (markTable n ts)[x]! = true ↔ x ∈ ts ∧ x < n := by + unfold markTable + rw [← Array.foldl_toList, foldl_setBang_const] + by_cases h : x ∈ ts.toList ∧ x < (Array.replicate n false).size + · rw [if_pos h] + simp only [Array.size_replicate, Array.mem_toList_iff] at h + simp [h] + · rw [if_neg h] + simp only [Array.size_replicate, Array.mem_toList_iff, not_and] at h + constructor + · intro hx + by_cases hxn : x < n + · simp [hxn] at hx + · simp [hxn] at hx + · rintro ⟨h1, h2⟩; exact absurd h2 (h h1) + +theorem sepLabels_spec (n : Nat) (members g inRed outRed : Array Nat) (x : Nat) : + (sepLabels n members g inRed outRed)[x]! = + if x < n ∧ x ∉ inRed ∧ x ∉ outRed then + (if x ∈ g then some 1 else if x ∈ members then some 2 else none) + else none := by + unfold sepLabels + simp only + rw [← Array.foldl_toList, foldl_setBang_const, ← Array.foldl_toList, foldl_setBang_const, + ← Array.foldl_toList, foldl_setBang_const] + simp only [foldl_setBang_const_size, Array.size_replicate, + Array.toList_append, List.mem_append, Array.mem_toList_iff] + by_cases hxn : x < n + · by_cases hio : x ∈ inRed ∨ x ∉ outRed <;> by_cases hi : x ∈ inRed <;> by_cases ho : x ∈ outRed <;> + by_cases hg : x ∈ g <;> by_cases hm : x ∈ members <;> + simp_all + · have : ¬ x < (Array.replicate n (none : Option Nat)).size := by simpa using hxn + simp [hxn] + rfl + +/-! ## Paths and descendants -/ + +theorem DagWF.children_size {dag : Dag} (hwf : DagWF dag) {t : Nat} (ht : t < dag.size) : + (dag.node t).children.size = (dag.node t).head.arity := by + have := hwf.arity t ht + rw [← dag_node_eq ht] at this + exact this + +/-- A path avoiding opaque terms is a path. -/ +theorem NReach.desc {dag : Dag} (hwf : DagWF dag) {O : Nat → Bool} {y v : Nat} + (hy : y < dag.size) (h : NReach (Prep.ofDag dag) O y v) : Desc dag y v := by + induction h with + | refl => exact .refl _ + | @tail u v hu _ he ih => + obtain ⟨k, hk, rfl⟩ := he + have hun : u < dag.size := Nat.lt_of_le_of_lt (NReach.le_of_wf hwf hu hy) hy + simp only [ofDag_dag] at hk ⊢ + exact desc_snoc ih (by rw [hwf.children_size hun]; exact hk) + +theorem Desc.le_of_wf {dag : Dag} (hwf : DagWF dag) {y v : Nat} (h : Desc dag y v) + (hy : y < dag.size) : v ≤ y := by + induction h with + | refl => exact Nat.le_refl _ + | @child t u k hk _ ih => + have hc : (dag.node t).child k < t := by + rw [child_eq_getElem _ k hk] + exact hwf.child_lt hy (Array.getElem_mem _) + have := ih (by omega) + omega + +/-! ## Members and their ancestors -/ + +/-- The marks of `upClosure`. -/ +def upMarks (dag : Dag) (isMember : Nat → Bool) : Array Bool := + foldRange (fun (acc : Array Bool) t => + acc.set! t (isMember t || (dag.node t).children.any (acc[·]!))) 0 dag.size + (Array.replicate dag.size false) + +theorem upClosure_eq (dag : Dag) (isMember : Nat → Bool) : + upClosure dag isMember = (Array.range dag.size).filter ((upMarks dag isMember)[·]!) := rfl + +/-- The row of `upMarks` at `t`, reading `acc` for the children. -/ +def upRow (dag : Dag) (isMember : Nat → Bool) (acc : Array Bool) (t : Nat) : Bool := + isMember t || (dag.node t).children.any (acc[·]!) + +theorem upRow_congr {dag : Dag} (hwf : DagWF dag) {isMember : Nat → Bool} {a b : Array Bool} + {t : Nat} (ht : t < dag.size) (h : ∀ c, c < t → a[c]! = b[c]!) : + upRow dag isMember a t = upRow dag isMember b t := by + unfold upRow + congr 1 + apply Bool.eq_iff_iff.mpr + rw [Array.any_eq_true, Array.any_eq_true] + constructor <;> rintro ⟨i, hi, hc⟩ <;> refine ⟨i, hi, ?_⟩ + · rw [← h _ (hwf.child_lt ht (Array.getElem_mem _))]; exact hc + · rw [h _ (hwf.child_lt ht (Array.getElem_mem _))]; exact hc + +theorem upMarks_spec {dag : Dag} (hwf : DagWF dag) (isMember : Nat → Bool) {t : Nat} + (ht : t < dag.size) : + (upMarks dag isMember)[t]! = upRow dag isMember (upMarks dag isMember) t := by + have hinv : ∀ m, m ≤ dag.size → + ((List.range m).foldl (fun acc t => acc.set! t (upRow dag isMember acc t)) + (Array.replicate dag.size false)).size = dag.size ∧ + ∀ t, t < m → + ((List.range m).foldl (fun acc t => acc.set! t (upRow dag isMember acc t)) + (Array.replicate dag.size false))[t]! = + upRow dag isMember ((List.range m).foldl + (fun acc t => acc.set! t (upRow dag isMember acc t)) + (Array.replicate dag.size false)) t := by + intro m + induction m with + | zero => intro _; exact ⟨by simp, fun _ h => absurd h (Nat.not_lt_zero _)⟩ + | succ m ih => + intro hm + obtain ⟨hs, hrows⟩ := ih (by omega) + rw [foldl_range_succ] + generalize (List.range m).foldl (fun acc t => acc.set! t (upRow dag isMember acc t)) + (Array.replicate dag.size false) = acc at hs hrows + have keep : ∀ c, c < m → (acc.set! m (upRow dag isMember acc m))[c]! = acc[c]! := + fun c hc => setBang_getElem!_ne _ _ (by omega) + refine ⟨by simp [hs], fun t ht => ?_⟩ + by_cases htm : t = m + · subst htm + rw [setBang_getElem!_self _ _ (by omega)] + exact upRow_congr hwf (by omega) fun c hc => (keep c hc).symm + · rw [keep t (by omega), hrows t (by omega)] + exact upRow_congr hwf (by omega) fun c hc => (keep c (by omega)).symm + unfold upMarks + rw [foldRange_zero] + exact (hinv dag.size (Nat.le_refl _)).2 t ht + +/-- **A term is marked iff a member lies at or below it.** -/ +theorem upMarks_iff {dag : Dag} (hwf : DagWF dag) (isMember : Nat → Bool) : + ∀ t, t < dag.size → + ((upMarks dag isMember)[t]! = true ↔ ∃ m, isMember m = true ∧ Desc dag t m) := by + intro t + induction t using Nat.strongRecOn with + | _ t ih => + intro ht + rw [upMarks_spec hwf isMember ht] + unfold upRow + rw [Bool.or_eq_true, Array.any_eq_true] + constructor + · rintro (h | ⟨k, hk, hc⟩) + · exact ⟨t, h, .refl _⟩ + · have hlt : (dag.node t).children[k] < t := hwf.child_lt ht (Array.getElem_mem _) + obtain ⟨m, hm, hd⟩ := (ih _ hlt (by omega)).mp hc + refine ⟨m, hm, .child k hk ?_⟩ + rw [child_eq_getElem _ k hk] + exact hd + · rintro ⟨m, hm, hd⟩ + cases hd with + | refl => exact Or.inl hm + | child k hk hd => + right + refine ⟨k, hk, ?_⟩ + have hlt : (dag.node t).children[k] < t := hwf.child_lt ht (Array.getElem_mem _) + rw [child_eq_getElem _ k hk] at hd + exact (ih _ hlt (by omega)).mpr ⟨m, hm, hd⟩ + +theorem mem_upClosure {dag : Dag} (hwf : DagWF dag) (isMember : Nat → Bool) (t : Nat) : + t ∈ (upClosure dag isMember).toList ↔ + t < dag.size ∧ ∃ m, isMember m = true ∧ Desc dag t m := by + rw [upClosure_eq, Array.mem_toList_iff, Array.mem_filter, Array.mem_range] + constructor + · rintro ⟨ht, hm⟩; exact ⟨ht, (upMarks_iff hwf isMember t ht).mp hm⟩ + · rintro ⟨ht, hm⟩; exact ⟨ht, (upMarks_iff hwf isMember t ht).mpr hm⟩ + +theorem upClosure_sorted (dag : Dag) (isMember : Nat → Bool) : + (upClosure dag isMember).toList.Pairwise (· < ·) := by + rw [upClosure_eq, Array.toList_filter, Array.toList_range] + exact (List.pairwise_lt_range).filter _ + +/-! ## Restricted reach summaries -/ + +/-- **The restricted reach summaries allow every reachable label** at the +terms of a strictly increasing `order` that contains every non-opaque child +of its terms reaching a labeled term. -/ +theorem reachLabelsOn_allows {dag : Dag} (hwf : DagWF dag) (order : Array Nat) + (opq : Nat → Bool) (lab : Nat → Option Nat) + (hsorted : order.toList.Pairwise (· < ·)) (hlt : ∀ t ∈ order.toList, t < dag.size) + (hclosed : ∀ y ∈ order.toList, ∀ k, k < (dag.node y).head.arity → + opq ((dag.node y).child k) = false → + ∀ v ℓ, NReach (Prep.ofDag dag) opq ((dag.node y).child k) v → lab v = some ℓ → + (dag.node y).child k ∈ order.toList) : + ∀ y ∈ order.toList, ∀ v, NReach (Prep.ofDag dag) opq y v → ∀ ℓ, lab v = some ℓ → + Allows (reachLabelsOn dag order opq lab)[y]! ℓ := by + let Inv (acc : Array (Option (Option Nat))) (P : List Nat) : Prop := + ∀ y ∈ P, ∀ v, NReach (Prep.ofDag dag) opq y v → ∀ ℓ, lab v = some ℓ → Allows acc[y]! ℓ + have key : ∀ (l P : List Nat) (acc : Array (Option (Option Nat))), + l.Pairwise (· < ·) → (∀ y ∈ P, ∀ x ∈ l, y < x) → (∀ x ∈ l, x < dag.size) → + acc.size = dag.size → + (∀ y ∈ l, ∀ k, k < (dag.node y).head.arity → opq ((dag.node y).child k) = false → + ∀ v ℓ, NReach (Prep.ofDag dag) opq ((dag.node y).child k) v → lab v = some ℓ → + (dag.node y).child k ∈ P ∨ (dag.node y).child k ∈ l) → + Inv acc P → + Inv (l.foldl (fun acc t => acc.set! t (labelRow dag opq lab acc t)) acc) (P ++ l) := by + intro l + induction l with + | nil => intro P acc _ _ _ _ _ h; simpa using h + | cons x l ih => + intro P acc hs hPl hl hsz hcl hinv + rw [List.foldl_cons] + have hx : x < dag.size := hl x List.mem_cons_self + have hxl : ∀ z ∈ l, x < z := (List.pairwise_cons.mp hs).1 + have step : Inv (acc.set! x (labelRow dag opq lab acc x)) (P ++ [x]) := by + intro y hy v hv ℓ hℓ + rcases List.mem_append.mp hy with hyP | hyx + · have hyx : y < x := hPl y hyP x List.mem_cons_self + rw [setBang_getElem!_ne _ _ (by omega)] + exact hinv y hyP v hv ℓ hℓ + · rw [List.mem_singleton] at hyx + subst hyx + rw [setBang_getElem!_self _ _ (by omega)] + unfold labelRow + rw [← Array.foldl_toList] + apply allows_foldl + rcases hv.head with rfl | ⟨k, hk, (⟨hO, rfl⟩ | ⟨hO, hc⟩)⟩ + · left; rw [hℓ]; exact Or.inr rfl + · right + simp only [ofDag_dag] at hk hO hℓ ⊢ + refine ⟨(dag.node y).child k, ?_, ?_⟩ + · rw [child_eq_getElem _ k (by rw [hwf.children_size hx]; exact hk)] + exact Array.mem_toList_iff.mpr (Array.getElem_mem _) + · rw [if_pos hO, hℓ]; exact Or.inr rfl + · right + simp only [ofDag_dag] at hk hO hc ⊢ + have hclt := hwf.childAt_lt hx hk + refine ⟨(dag.node y).child k, ?_, ?_⟩ + · rw [child_eq_getElem _ k (by rw [hwf.children_size hx]; exact hk)] + exact Array.mem_toList_iff.mpr (Array.getElem_mem _) + · rw [if_neg (by simp [hO])] + rcases hcl y List.mem_cons_self k hk hO v ℓ hc hℓ with hcP | hcl' + · exact hinv _ hcP v hc ℓ hℓ + · rcases List.mem_cons.mp hcl' with he | he + · omega + · have := hxl _ he; omega + have := ih (P ++ [x]) (acc.set! x (labelRow dag opq lab acc x)) hs.of_cons + (fun y hy z hz => by + rcases List.mem_append.mp hy with hyP | hyx + · exact hPl y hyP z (List.mem_cons_of_mem _ hz) + · rw [List.mem_singleton] at hyx; subst hyx; exact hxl z hz) + (fun z hz => hl z (List.mem_cons_of_mem _ hz)) + (by rw [size_setBang, hsz]) + (fun y hy k hk hO v ℓ hc hℓ => by + rcases hcl y (List.mem_cons_of_mem _ hy) k hk hO v ℓ hc hℓ with h | h + · exact Or.inl (List.mem_append_left _ h) + · rcases List.mem_cons.mp h with h | h + · exact Or.inl (List.mem_append_right _ (by rw [h]; exact List.mem_singleton_self _)) + · exact Or.inr h) + step + simpa using this + intro y hy v hv ℓ hℓ + have := key order.toList [] (Array.replicate dag.size none) hsorted (by simp) hlt (by simp) + (fun y hy k hk hO v ℓ hc hℓ => Or.inr (hclosed y hy k hk hO v ℓ hc hℓ)) (by simp [Inv]) + unfold reachLabelsOn + rw [← Array.foldl_toList] + exact this y (by simpa using hy) v hv ℓ hℓ + +/-! ## The group separation check -/ + +/-- **What a passing separation check guarantees.** The group's terms are +members outside the reduced context; and no member that can be stored (not +in `outRed`) and is not opaque under the reduced context reaches, along paths +whose intermediate terms are not opaque, both a group term and a member +outside the group and the context. -/ +theorem sepCheck_spec {cx : SCtx} (hwf : DagWF cx.up.prep.dag) + (hclo : cx.closure = + upClosure cx.up.prep.dag ((markTable cx.up.prep.dag.size cx.members)[·]!)) + (hmem : ∀ t ∈ cx.members, t < cx.up.prep.dag.size) + {g inRed outRed : Array Nat} (hchk : cx.sepCheck g inRed outRed = true) : + (∀ t ∈ g, t ∈ cx.members ∧ t < cx.up.prep.dag.size ∧ t ∉ inRed ∧ t ∉ outRed) ∧ + (∀ v ∈ cx.members, v ∉ outRed → (cx.opaqueArr inRed outRed)[v]! = false → + ∀ a b, NReach (Prep.ofDag cx.up.prep.dag) ((cx.opaqueArr inRed outRed)[·]!) v a → + NReach (Prep.ofDag cx.up.prep.dag) ((cx.opaqueArr inRed outRed)[·]!) v b → + a ∈ g → b ∈ cx.members → b ∉ g → b ∉ inRed → b ∉ outRed → False) := by + generalize hdag : cx.up.prep.dag = dag at hwf hclo hmem + have hn : cx.up.prep.dag.size = dag.size := by rw [hdag] + unfold SCtx.sepCheck at hchk + simp only [Bool.and_eq_true, Array.all_eq_true'] at hchk + obtain ⟨hg, hv⟩ := hchk + rw [hdag] at hv hg + generalize hO : cx.opaqueArr inRed outRed = O at hv ⊢ + have hga : ∀ t ∈ g, t ∈ cx.members ∧ t < dag.size ∧ t ∉ inRed ∧ t ∉ outRed := by + intro t ht + have := hg t ht + simp only [beq_iff_eq] at this + obtain ⟨h1, h2⟩ := this + rw [markTable_spec] at h1 + rw [sepLabels_spec] at h2 + by_cases hc : t < dag.size ∧ t ∉ inRed ∧ t ∉ outRed + · exact ⟨h1.1, hc⟩ + · rw [if_neg hc] at h2; cases h2 + refine ⟨hga, ?_⟩ + intro v hvm hvo hvO a b ha hb hag hbm hbg hbi hbo + have hvn := hmem v hvm + have hbn : b < dag.size := Nat.lt_of_le_of_lt (NReach.le_of_wf hwf hb hvn) hvn + -- the labels of `a` and `b` + let lab := sepLabels dag.size cx.members g inRed outRed + have hla : lab[a]! = some 1 := by + obtain ⟨_, han, hai, hao⟩ := hga a hag + show (sepLabels dag.size cx.members g inRed outRed)[a]! = some 1 + rw [sepLabels_spec, if_pos ⟨han, hai, hao⟩, if_pos hag] + have hlb : lab[b]! = some 2 := by + show (sepLabels dag.size cx.members g inRed outRed)[b]! = some 2 + rw [sepLabels_spec, if_pos ⟨hbn, hbi, hbo⟩, if_neg hbg, if_pos hbm] + -- every labeled term is a member + have hlabm : ∀ x ℓ, lab[x]! = some ℓ → x ∈ cx.members ∧ x < dag.size := by + intro x ℓ hx + have hx' : (sepLabels dag.size cx.members g inRed outRed)[x]! = some ℓ := hx + rw [sepLabels_spec] at hx' + by_cases hc : x < dag.size ∧ x ∉ inRed ∧ x ∉ outRed + · rw [if_pos hc] at hx' + by_cases hxg : x ∈ g + · exact ⟨(hga x hxg).1, hc.1⟩ + · rw [if_neg hxg] at hx' + by_cases hxm : x ∈ cx.members + · exact ⟨hxm, hc.1⟩ + · rw [if_neg hxm] at hx'; cases hx' + · rw [if_neg hc] at hx'; cases hx' + -- the closure facts + let isMem := markTable dag.size cx.members + have hcl_mem : ∀ t, t ∈ cx.closure.toList ↔ t < dag.size ∧ ∃ m, isMem[m]! = true ∧ Desc dag t m := by + intro t; rw [hclo]; exact mem_upClosure hwf _ t + have hvc : v ∈ cx.closure.toList := + (hcl_mem v).mpr ⟨hvn, v, (markTable_spec _ _ _).mpr ⟨hvm, hvn⟩, .refl _⟩ + have hallows := reachLabelsOn_allows hwf cx.closure (O[·]!) (lab[·]!) + (by rw [hclo]; exact upClosure_sorted _ _) + (fun t ht => ((hcl_mem t).mp ht).1) + (by + intro y hy k hk _ x ℓ hx hℓ + have hyn := ((hcl_mem y).mp hy).1 + have hcn := hwf.childAt_lt hyn hk + obtain ⟨hxm, hxn⟩ := hlabm x ℓ hℓ + exact (hcl_mem _).mpr ⟨by omega, x, (markTable_spec _ _ _).mpr ⟨hxm, hxn⟩, + NReach.desc hwf (by omega) hx⟩) + have h1 := hallows v hvc a ha 1 hla + have h2 := hallows v hvc b hb 2 hlb + have hcheck := hv v hvm + have hout : (markTable dag.size outRed)[v]! = false := by + cases h : (markTable dag.size outRed)[v]! + · rfl + · exact absurd ((markTable_spec _ _ _).mp h).1 hvo + rw [hout, hvO] at hcheck + simp only [Bool.false_or, bne_iff_ne, ne_eq] at hcheck + rcases h1 with h1 | h1 <;> rcases h2 with h2 | h2 + · exact hcheck h1 + · exact hcheck h1 + · exact hcheck h2 + · rw [h1] at h2; cases h2 + +/-! ## The component evaluation (B2) -/ + +/-- Availability of a component evaluation: the certain-stored terms and the +available members. -/ +def compAvail (opaq : Array Bool) (members : Array Nat) (avail : Nat → Bool) : Nat → Bool := + fun u => opaq[u]! || (decide (u ∈ members) && avail u) + +theorem widthOf_eq (width : Array (Option Nat)) (u : Nat) : widthOf width u = width[u]! := by + unfold widthOf + rw [getElem!_def] + cases width[u]? <;> rfl + +theorem widthFold_size (w : Nat) (avail : Nat → Bool) : + ∀ (l : List Nat) (a : Array (Option Nat)), + (l.foldl (fun acc t => if avail t then acc.set! t (some w) else acc) a).size = a.size + | [], _ => rfl + | t :: l, a => by + rw [List.foldl_cons, widthFold_size w avail l] + split <;> simp + +theorem widthFold_spec (w : Nat) (avail : Nat → Bool) : + ∀ (l : List Nat) (a : Array (Option Nat)) (u : Nat), + widthOf (l.foldl (fun acc t => if avail t then acc.set! t (some w) else acc) a) u = + if u ∈ l ∧ avail u = true ∧ u < a.size then some w else widthOf a u + | [], a, u => by simp + | t :: l, a, u => by + rw [List.foldl_cons, widthFold_spec w avail l] + have hsz : (if avail t = true then a.set! t (some w) else a).size = a.size := by + split <;> simp + rw [hsz] + by_cases hut : u = t + · subst hut + by_cases hav : avail u = true + · simp only [hav, if_true, widthOf_eq] + by_cases hu : u < a.size + · simp [hu] + · simp [hu] + · simp [hav] + · have hw : widthOf (if avail t = true then a.set! t (some w) else a) u = widthOf a u := by + split + · rw [widthOf_eq, widthOf_eq, setBang_getElem!_ne _ _ hut] + · rfl + simp only [List.mem_cons, hut, false_or, hw] + +/-- The model rows of a term agree under availabilities that agree on its +descendants. -/ +theorem evalRow_local {dag : Dag} (hwf : DagWF dag) {w : Nat} {A B : Nat → Bool} {st : DictEval} + {t : Nat} (ht : t < dag.size) (hagree : ∀ v, Desc dag t v → A v = B v) + (h : EvalRow (Prep.ofDag dag) w A st t) : EvalRow (Prep.ofDag dag) w B st t := by + have hp := prepWF_ofDag hwf + let O : Nat → Bool := fun _ => false + have hOA : ∀ (C : Nat → Bool), OpaqueOn (Prep.ofDag dag) w O C := fun C u _ hu => by + simp [O] at hu + have hloc : ∀ y, y < dag.size → (∀ v, Desc dag y v → A v = B v) → + uCost (Prep.ofDag dag) w A y = uCost (Prep.ofDag dag) w B y := fun y hy hag => + (hp.uCost_local w O y hy A B (hOA A) (hOA B) + (fun v hv => hag v (NReach.desc hwf hy hv))).1 + have hspine : ∀ k, (Prep.ofDag dag).family[t]! ≠ .none → k < (Prep.ofDag dag).spineLen[t]! → + Desc dag t (spineAt (Prep.ofDag dag) t k) := fun k hf hk => + NReach.desc hwf ht (hp.spine_nreach (O := O) ht hf (k := 0) k (Nat.zero_le _) hk + (fun _ _ _ => rfl)) + obtain ⟨hc, hs⟩ := h + refine ⟨by rw [hc]; exact hloc t ht hagree, fun hf => ?_⟩ + obtain ⟨hsd, hfa⟩ := hs hf + refine ⟨?_, ?_⟩ + · rw [hsd] + apply prefixSides_local + intro i hi + obtain ⟨hts, htf, _⟩ := hp.spine_shift ht hf (k := i) hi + have hfs : (Prep.ofDag dag).family[spineAt (Prep.ofDag dag) t i]! ≠ .none := by + rw [htf]; exact hf + obtain ⟨m, hm, he⟩ := hp.side_edge hts hfs + have hlt := hp.sideAt_lt ht hf hi + have hd : Desc dag t (sideAt (Prep.ofDag dag) t i) := by + unfold sideAt + rw [← he] + exact desc_snoc (hspine i hf hi) (by rw [hwf.children_size hts]; exact hm) + exact hloc _ (by omega) (fun v hv => hagree v (hd.trans hv)) + · have hag : ∀ k, k < (Prep.ofDag dag).spineLen[t]! → + A (spineAt (Prep.ofDag dag) t k) = B (spineAt (Prep.ofDag dag) t k) := + fun k hk => hagree _ (hspine k hf hk) + cases hb : st.below[t]! with + | none => + rw [hb] at hfa + intro k hk1 hk2 + rw [← hag k hk2]; exact hfa k hk1 hk2 + | some u => + rw [hb] at hfa + obtain ⟨k, hk1, hk2, hu, hau, hnone⟩ := hfa + refine ⟨k, hk1, hk2, hu, by rw [hu, ← hag k hk2, ← hu]; exact hau, fun k' h1 h2 => ?_⟩ + rw [← hag k' (by omega)]; exact hnone k' h1 h2 + +theorem evalStep_keep (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (aff : Array Bool) (st : DictEval) {x t : Nat} (h : t ≠ x) : + (evalStep dag family spineLen tail width aff st x).cost[t]! = st.cost[t]! ∧ + (evalStep dag family spineLen tail width aff st x).sides[t]! = st.sides[t]! ∧ + (evalStep dag family spineLen tail width aff st x).below[t]! = st.below[t]! := by + unfold evalStep + split + · dsimp only + split + · exact ⟨setBang_getElem!_ne _ _ h, rfl, rfl⟩ + · exact ⟨setBang_getElem!_ne _ _ h, setBang_getElem!_ne _ _ h, setBang_getElem!_ne _ _ h⟩ + · exact ⟨rfl, rfl, rfl⟩ + +theorem evalRow_of_agree {p : Prep} {w : Nat} {A : Nat → Bool} {st st' : DictEval} {t : Nat} + (h1 : st'.cost[t]! = st.cost[t]!) (h2 : st'.sides[t]! = st.sides[t]!) + (h3 : st'.below[t]! = st.below[t]!) (h : EvalRow p w A st t) : EvalRow p w A st' t := by + obtain ⟨hc, hs⟩ := h + exact ⟨by rw [h1, hc], fun hf => by rw [h2, h3]; exact hs hf⟩ + +theorem uCost_desc_local {dag : Dag} (hwf : DagWF dag) (w : Nat) {A B : Nat → Bool} {y : Nat} + (hy : y < dag.size) (hag : ∀ v, Desc dag y v → A v = B v) : + uCost (Prep.ofDag dag) w A y = uCost (Prep.ofDag dag) w B y := by + have hp := prepWF_ofDag hwf + let O : Nat → Bool := fun _ => false + have hOA : ∀ (C : Nat → Bool), OpaqueOn (Prep.ofDag dag) w O C := fun C u _ hu => by + simp [O] at hu + exact (hp.uCost_local w O y hy A B (hOA A) (hOA B) + (fun v hv => hag v (NReach.desc hwf hy hv))).1 + +/-- Folding `evalStep` over a list of terms. -/ +def evalFold (dag : Dag) (width : Array (Option Nat)) (aff : Array Bool) (l : List Nat) + (st : DictEval) : DictEval := + l.foldl (evalStep (Prep.ofDag dag).dag (Prep.ofDag dag).family (Prep.ofDag dag).spineLen + (Prep.ofDag dag).tail width aff) st + +/-- **Incremental evaluation.** Folding `evalStep` over a strictly increasing +list from an evaluation whose rows are the model rows at every term outside +the list establishes the model rows at every term. -/ +theorem evalFold_rows {dag : Dag} (hwf : DagWF dag) {w : Nat} {A : Nat → Bool} + (width : Array (Option Nat)) (hwidth : ∀ u, widthOf width u = if A u then some w else none) + (aff : Array Bool) (haff : ∀ t, t < dag.size → aff[t]! = true) : + ∀ (l : List Nat) (st : DictEval), l.Pairwise (· < ·) → (∀ x ∈ l, x < dag.size) → + (st.cost.size = dag.size ∧ st.sides.size = dag.size ∧ st.below.size = dag.size) → + (∀ t, t < dag.size → t ∉ l → EvalRow (Prep.ofDag dag) w A st t) → + ((evalFold dag width aff l st).cost.size = dag.size ∧ + (evalFold dag width aff l st).sides.size = dag.size ∧ + (evalFold dag width aff l st).below.size = dag.size) ∧ + ∀ t, t < dag.size → EvalRow (Prep.ofDag dag) w A (evalFold dag width aff l st) t + | [], st, _, _, hsz, hrows => ⟨hsz, fun t ht => hrows t ht List.not_mem_nil⟩ + | x :: l, st, hs, hlt, hsz, hrows => by + have hx := hlt x List.mem_cons_self + have hxl : ∀ z ∈ l, x < z := (List.pairwise_cons.mp hs).1 + have hp := prepWF_ofDag hwf + obtain ⟨hsz', hrows'⟩ := hp.evalStep_spec width hwidth aff st x hx (haff x hx) hsz + (fun t htx => hrows t (by omega) (by + intro hm + rcases List.mem_cons.mp hm with h | h + · omega + · have := hxl t h; omega)) + have := evalFold_rows hwf width hwidth aff haff l _ hs.of_cons + (fun z hz => hlt z (List.mem_cons_of_mem _ hz)) hsz' (fun t ht htl => by + by_cases htx : t < x + 1 + · exact hrows' t htx + · have hne : t ≠ x := by omega + obtain ⟨k1, k2, k3⟩ := evalStep_keep _ _ _ _ width aff st hne + exact evalRow_of_agree k1 k2 k3 (hrows t ht (by + intro hm + rcases List.mem_cons.mp hm with h | h + · omega + · exact htl h))) + unfold evalFold at this ⊢ + rw [List.foldl_cons] + exact this + +theorem inlOf_avail_congr {p : Prep} {w : Nat} {A B : Nat → Bool} {f : Nat → Nat} {x : Nat} + (h : p.family[x]! ≠ .none → ∀ j, 1 ≤ j → j < p.spineLen[x]! → + A (spineAt p x j) = B (spineAt p x j)) : + inlOf p w A f x = inlOf p w B f x := by + unfold inlOf + split + · rfl + · rename_i hf + congr 1 + unfold cutCosts + apply filterMap_congr' + intro j hj + rw [List.mem_range'_1] at hj + rw [h hf j hj.1 (by omega)] + +/-- **An entry's body by one more step.** Re-evaluating a term with its own +width removed gives its inline cost. -/ +theorem entry_inl {dag : Dag} (hwf : DagWF dag) {w : Nat} {A : Nat → Bool} + (width : Array (Option Nat)) (hwsz : width.size = dag.size) + (hwidth : ∀ u, widthOf width u = if A u then some w else none) (ev : DictEval) + (hsz : ev.cost.size = dag.size ∧ ev.sides.size = dag.size ∧ ev.below.size = dag.size) + (hrows : ∀ t, t < dag.size → EvalRow (Prep.ofDag dag) w A ev t) {x : Nat} (hx : x < dag.size) : + (evalStep (Prep.ofDag dag).dag (Prep.ofDag dag).family (Prep.ofDag dag).spineLen + (Prep.ofDag dag).tail (width.set! x none) (Array.replicate dag.size true) ev x).cost[x]! = + uInl (Prep.ofDag dag) w A x := by + have hp := prepWF_ofDag hwf + let A' : Nat → Bool := fun u => A u && decide (u ≠ x) + have hwidth' : ∀ u, widthOf (width.set! x none) u = if A' u then some w else none := by + intro u + by_cases hux : u = x + · subst hux + rw [widthOf_eq, setBang_getElem!_self _ _ (by omega)] + simp [A'] + · rw [widthOf_eq, setBang_getElem!_ne _ _ hux, ← widthOf_eq, hwidth] + simp [A', hux] + have hag : ∀ t, t < x → ∀ v, Desc dag t v → A v = A' v := by + intro t htx v hv + have := Desc.le_of_wf hwf hv (by omega) + have hvx : v ≠ x := by omega + simp [A', hvx] + have rows' : ∀ t, t < x → EvalRow (Prep.ofDag dag) w A' ev t := + fun t htx => evalRow_local hwf (by omega) (hag t htx) (hrows t (by omega)) + obtain ⟨_, hr⟩ := hp.evalStep_spec (width.set! x none) hwidth' (Array.replicate dag.size true) + ev x hx (by simp [hx]) hsz rows' + rw [(hr x (Nat.lt_succ_self x)).1, hp.uCost_eq w A' x hx] + unfold costOf uInl + rw [if_neg (by simp [A'])] + rw [hp.inlOf_congr (avail := A') hx (g := uCost (Prep.ofDag dag) w A) (fun c hc => + uCost_desc_local hwf w (Nat.lt_trans hc hx) (fun v hv => (hag c hc v hv).symm))] + apply inlOf_avail_congr + intro hf j hj1 hj2 + have := hp.spineAt_lt hx hf hj1 hj2 + have hne : spineAt (Prep.ofDag dag) x j ≠ x := by omega + simp [A', hne] + +theorem replicate_getBang {α : Type} [Inhabited α] {n t : Nat} {v : α} (ht : t < n) : + (Array.replicate n v)[t]! = v := by + simp [ht] + +/-- The evaluation of a component with `avail` available: the model rows of +`compAvail` at every term. -/ +theorem compEval_rows {dag : Dag} (hwf : DagWF dag) (w : Nat) (opaq : Array Bool) + (members : Array Nat) (hmem : ∀ t ∈ members, t < dag.size) (avail : Nat → Bool) + (widthCs : Array (Option Nat)) (hwsz : widthCs.size = dag.size) + (hwcs : ∀ u, widthOf widthCs u = if opaq[u]! then some w else none) : + let width := members.foldl (fun acc t => if avail t then acc.set! t (some w) else acc) widthCs + let ev := evalFold dag width (Array.replicate dag.size true) + (upClosure dag ((markTable dag.size members)[·]!)).toList + ((Prep.ofDag dag).eval widthCs (Array.replicate dag.size true)) + width.size = dag.size ∧ + (∀ u, widthOf width u = if compAvail opaq members avail u then some w else none) ∧ + (ev.cost.size = dag.size ∧ ev.sides.size = dag.size ∧ ev.below.size = dag.size) ∧ + ∀ t, t < dag.size → EvalRow (Prep.ofDag dag) w (compAvail opaq members avail) ev t := by + intro width ev + have hp := prepWF_ofDag hwf + let A := compAvail opaq members avail + have hwsz' : width.size = dag.size := by + show (members.foldl _ widthCs).size = _ + rw [← Array.foldl_toList, widthFold_size, hwsz] + have hwidth : ∀ u, widthOf width u = if A u then some w else none := by + intro u + show widthOf (members.foldl _ widthCs) u = _ + rw [← Array.foldl_toList, widthFold_spec, hwcs] + simp only [Array.mem_toList_iff, A, compAvail] + by_cases hum : u ∈ members <;> by_cases hav : avail u = true <;> + by_cases ho : opaq[u]! = true <;> simp [hum, hav, ho, hwsz, hmem u] + -- the certain-stored evaluation + let Acs : Nat → Bool := fun u => opaq[u]! + have hbrows : ∀ t, t < dag.size → EvalRow (Prep.ofDag dag) w Acs + ((Prep.ofDag dag).eval widthCs (Array.replicate dag.size true)) t := by + intro t ht + exact hp.evalFrom_spec widthCs hwcs (Prep.ofDag dag).empty (ofDag_empty_size dag) + (Array.replicate dag.size true) (fun t ht => replicate_getBang ht) t ht + have hbsz := evalFrom_size (Prep.ofDag dag).dag (Prep.ofDag dag).family + (Prep.ofDag dag).spineLen (Prep.ofDag dag).tail (Prep.ofDag dag).empty widthCs + (Array.replicate dag.size true) + obtain ⟨e1, e2, e3⟩ := ofDag_empty_size dag + rw [e1, e2, e3] at hbsz + have hclo := mem_upClosure hwf ((markTable dag.size members)[·]!) + have hfold := evalFold_rows hwf width hwidth (Array.replicate dag.size true) + (fun t ht => replicate_getBang ht) (upClosure dag ((markTable dag.size members)[·]!)).toList + ((Prep.ofDag dag).eval widthCs (Array.replicate dag.size true)) + (upClosure_sorted _ _) (fun x hx => ((hclo x).mp hx).1) hbsz + (fun t ht htc => evalRow_local hwf ht (fun v hv => by + show Acs v = A v + simp only [Acs, A, compAvail] + by_cases hvm : v ∈ members + · exact absurd ((hclo t).mpr ⟨ht, v, (markTable_spec _ _ _).mpr ⟨hvm, hmem v hvm⟩, hv⟩) htc + · simp [hvm]) (hbrows t ht)) + exact ⟨hwsz', hwidth, hfold⟩ + +/-- **The component evaluation (B2).** `phiE` is the model cost of the +component's roots, its certain-stored entries and the entries of `stored`, +with the certain-stored terms and the available members stored. -/ +theorem phiE_spec {cx : SCtx} {dag : Dag} (hwf : DagWF dag) (hprep : cx.up.prep = Prep.ofDag dag) + (hwsz : cx.widthCs.size = dag.size) + (hwcs : ∀ u, widthOf cx.widthCs u = if cx.up.opaq[u]! then some cx.up.w else none) + (hall : cx.allTrue = Array.replicate dag.size true) + (hbase : cx.baseEv = (Prep.ofDag dag).eval cx.widthCs (Array.replicate dag.size true)) + (hclo : cx.closure = upClosure dag ((markTable dag.size cx.members)[·]!)) + (hmem : ∀ t ∈ cx.members, t < dag.size) (hsc : ∀ t ∈ cx.storedInC, t < dag.size) + (avail : Nat → Bool) (stored : Array Nat) (hst : ∀ x ∈ stored, x < dag.size) : + (cx.phiE avail stored).1 = + (cx.rootsC.toList.map + (uCost (Prep.ofDag dag) cx.up.w (compAvail cx.up.opaq cx.members avail))).sum + + (cx.storedInC.toList.map + (uInl (Prep.ofDag dag) cx.up.w (compAvail cx.up.opaq cx.members avail))).sum + + (stored.toList.map + (uInl (Prep.ofDag dag) cx.up.w (compAvail cx.up.opaq cx.members avail))).sum := by + obtain ⟨hwsz', hwidth, hsz, hrows⟩ := compEval_rows hwf cx.up.w cx.up.opaq cx.members hmem avail + cx.widthCs hwsz hwcs + unfold SCtx.phiE + rw [hprep, hall, hbase, hclo] + dsimp only + generalize hW : cx.members.foldl (fun acc t => if avail t = true then + acc.set! t (some cx.up.w) else acc) cx.widthCs = width at hwsz' hwidth hsz hrows + have hev : (upClosure dag ((markTable dag.size cx.members)[·]!)).foldl + (evalStep (Prep.ofDag dag).dag (Prep.ofDag dag).family (Prep.ofDag dag).spineLen + (Prep.ofDag dag).tail width (Array.replicate dag.size true)) + ((Prep.ofDag dag).eval cx.widthCs (Array.replicate dag.size true)) = + evalFold dag width (Array.replicate dag.size true) + (upClosure dag ((markTable dag.size cx.members)[·]!)).toList + ((Prep.ofDag dag).eval cx.widthCs (Array.replicate dag.size true)) := by + unfold evalFold; rw [Array.foldl_toList] + rw [hev] + generalize evalFold dag width (Array.replicate dag.size true) + (upClosure dag ((markTable dag.size cx.members)[·]!)).toList + ((Prep.ofDag dag).eval cx.widthCs (Array.replicate dag.size true)) = ev at hsz hrows + rw [arr_foldl_add_eq_sum, arr_foldl_add_eq_sum, arr_foldl_add_eq_sum] + simp only [Nat.zero_add] + have hroot : ∀ r, ev.cost[r]! = uCost (Prep.ofDag dag) cx.up.w + (compAvail cx.up.opaq cx.members avail) r := by + intro r + by_cases hr : r < dag.size + · exact (hrows r hr).1 + · rw [uCost_of_ge _ _ _ (by simp only [ofDag_dag]; omega)] + simp [show ¬ r < ev.cost.size by omega] + have hent : ∀ x, x < dag.size → + (evalStep (Prep.ofDag dag).dag (Prep.ofDag dag).family (Prep.ofDag dag).spineLen + (Prep.ofDag dag).tail (width.set! x none) (Array.replicate dag.size true) ev x).cost[x]! = + uInl (Prep.ofDag dag) cx.up.w (compAvail cx.up.opaq cx.members avail) x := + fun x hx => entry_inl hwf width hwsz' hwidth ev hsz hrows hx + congr 1 + · congr 1 + · congr 1 + exact List.map_congr_left (fun r _ => hroot r) + · congr 1 + exact List.map_congr_left (fun x hx => hent x (hsc x (Array.mem_toList_iff.mp hx))) + · congr 1 + exact List.map_congr_left (fun x hx => hent x (hst x (Array.mem_toList_iff.mp hx))) + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformSearchSpec.lean b/Ix/Compile/Verify/UniformSearchSpec.lean new file mode 100644 index 000000000..68f022a0c --- /dev/null +++ b/Ix/Compile/Verify/UniformSearchSpec.lean @@ -0,0 +1,1152 @@ +import Ix.Compile.Verify.UniformTables + +/-! +# Stage 4: the component search finds every minimum's choice + +The invariant of the explicit-state component search (`solveP`, `solveBody`, +`nodeP`, `splitP`): every table entry is a real set of the group with its +exact `Δ`, and for every minimum respecting a node's decisions the table has +an entry at that minimum's count of the group that is at most its `Δ`. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (bind_eq_ok) + +/-! ## The setting of one component's search -/ + +/-- The data of one component's search. -/ +structure Env where + dag : Dag + roots : Array Nat + w : Nat + θ : _root_.Int + cs : List Nat + cx : SCtx + comp : Nat → Nat + i : Nat + +/-- What the search of a component may assume. -/ +structure Env.WF (E : Env) : Prop where + G : GlobalWF E.dag E.roots E.w E.θ E.cs + cx : SCtxWF E.dag E.roots E.w E.θ E.cs E.cx + area : AreaWF E.dag E.roots E.cx + comp : ∀ a b, a < E.dag.size → (ucls E.dag E.roots E.w E.θ)[a]! = .uncertain → + (ucls E.dag E.roots E.w E.θ)[b]! = .uncertain → + NReach (Prep.ofDag E.dag) (E.cx.up.opaq[·]!) a b → E.comp a = E.comp b + memi : ∀ t, t < E.dag.size → (ucls E.dag E.roots E.w E.θ)[t]! = .uncertain → + (t ∈ E.cx.members.toList ↔ E.comp t = E.i) + slack : E.cx.slack = tag0Size (E.cs.length + (uunc E.dag E.roots E.w E.θ).length) - + tag0Size E.cs.length + +/-- The change of the component cost from adding `S` to `I`. -/ +def Env.delta (E : Env) (I S : List Nat) : _root_.Int := + (scost E.cx E.dag (I ++ S) : _root_.Int) - (scost E.cx E.dag I : _root_.Int) + +/-- `Y` is a minimum storing `I` and not `O`. -/ +def Env.Cons (E : Env) (Y I O : List Nat) : Prop := + IsMinimum E.dag E.w E.roots Y ∧ (∀ t ∈ I, t ∈ Y) ∧ (∀ t ∈ O, t ∉ Y) + +/-- The part of `Y` in `g`. -/ +def partOf (Y g : List Nat) : List Nat := g.filter (fun t => decide (t ∈ Y)) + +/-- Every entry is a duplicate-free set of `g`'s terms with its exact `Δ`. -/ +def Env.TabOK (E : Env) (g I : List Nat) (tb : CTable) : Prop := + Entries tb (fun e => e.2.toList.Pairwise (· < ·) ∧ (∀ x ∈ e.2.toList, x ∈ g) ∧ + e.1 = E.delta I e.2.toList) + +/-- Every minimum respecting `(I, O)` has an entry at its count of `g`, at most +its `Δ`. -/ +def Env.Covers (E : Env) (g I O : List Nat) (tb : CTable) : Prop := + ∀ Y, E.Cons Y I O → HasAtT tb (partOf Y g).length (E.delta I (partOf Y g)) (partOf Y g) + +/-- A group's reduced context: separated, duplicate-free, of members. -/ +def Env.GroupCtx (E : Env) (g I O : Array Nat) : Prop := + strictInc g = true ∧ strictInc I = true ∧ strictInc O = true ∧ + E.cx.sepCheck g I O = true ∧ (∀ t ∈ I.toList, t ∈ E.cx.members.toList) ∧ + (∀ t ∈ O.toList, t ∈ E.cx.members.toList) ∧ (∀ t ∈ I.toList, t ∉ O.toList) + +/-- The memo holds valid tables of their keys' contexts. -/ +def Env.MemoOK (E : Env) (memo : Std.HashMap (Array Nat × Array Nat) CTable) : Prop := + ∀ g ent tb, memo.get? (g, ent) = some tb → + E.GroupCtx g (keyContext ent).1 (keyContext ent).2 ∧ + E.TabOK g.toList (keyContext ent).1.toList tb ∧ + E.Covers g.toList (keyContext ent).1.toList (keyContext ent).2.toList tb + +/-! ## Basic facts -/ + +theorem scost_perm {cx : SCtx} {dag : Dag} {V V' : List Nat} (h : V.Perm V') : + scost cx dag V = scost cx dag V' := by + unfold scost; exact compCost_perm h + +theorem Env.delta_perm (E : Env) {I S S' : List Nat} (h : S.Perm S') : + E.delta I S = E.delta I S' := by + unfold Env.delta + rw [scost_perm (List.Perm.append_left I h)] + +theorem chargeP_memo {limits : Limits} {work : Nat} {st st' : SState} + (h : chargeP limits work st = .ok st') : st'.memo = st.memo := by + unfold chargeP at h + simp only at h + split at h + · cases h + · split at h + · cases h + · cases h; rfl + +/-- The step of `pickBranch`. -/ +def branchStep (acc : Option (Nat × _root_.Int)) (x : Nat × _root_.Int) : Option (Nat × _root_.Int) := + match acc with + | none => some (x.1, x.2) + | some (a, ga) => + if x.2.natAbs > ga.natAbs || (x.2.natAbs == ga.natAbs && x.1 < a) then some (x.1, x.2) else acc + +theorem pickBranch_eq (l : Array (Nat × _root_.Int)) : pickBranch l = l.toList.foldl branchStep none := by + unfold pickBranch + rw [← Array.foldl_toList] + rfl + +theorem pickFold_mem : ∀ (L : List (Nat × _root_.Int)) (acc : Option (Nat × _root_.Int)) + (x : Nat × _root_.Int), L.foldl branchStep acc = some x → acc = some x ∨ x ∈ L + | [], _, _, h => Or.inl h + | y :: L, acc, x, h => by + rw [List.foldl_cons] at h + rcases pickFold_mem L _ x h with h' | h' + · cases acc with + | none => simp only [branchStep, Option.some.injEq] at h'; exact Or.inr (by rw [← h']; simp) + | some a => + obtain ⟨a, ga⟩ := a + simp only [branchStep] at h' + split at h' + · simp only [Option.some.injEq] at h'; exact Or.inr (by rw [← h']; simp) + · exact Or.inl h' + · exact Or.inr (List.mem_cons_of_mem _ h') + +theorem pickFold_some : ∀ (L : List (Nat × _root_.Int)) (acc : Option (Nat × _root_.Int)), + (acc ≠ none ∨ L ≠ []) → L.foldl branchStep acc ≠ none + | [], acc, h => by + rcases h with h | h + · exact h + · exact absurd rfl h + | y :: L, acc, _ => by + rw [List.foldl_cons] + apply pickFold_some L + left + cases acc with + | none => simp [branchStep] + | some a => + obtain ⟨a, ga⟩ := a + simp only [branchStep] + split <;> simp + +theorem pickBranch_mem {l : Array (Nat × _root_.Int)} {x : Nat × _root_.Int} + (h : pickBranch l = some x) : x ∈ l.toList := by + rw [pickBranch_eq] at h + rcases pickFold_mem _ _ _ h with h | h + · cases h + · exact h + +theorem pickBranch_isSome {l : Array (Nat × _root_.Int)} (h : l.toList ≠ []) : + pickBranch l ≠ none := by + rw [pickBranch_eq] + exact pickFold_some _ _ (Or.inr h) + +/-! ## Groups: shifting the base, pruning, trimming -/ + +theorem Env.WF.θ1 {E : Env} (hE : E.WF) : 1 ≤ E.θ := hE.G.one_le_theta + +theorem Env.WF.csc {E : Env} (hE : E.WF) : + ∀ t ∈ E.cs, t < E.dag.size ∧ (ucls E.dag E.roots E.w E.θ)[t]! = .certainStored := + fun t ht => (hE.G.mem_cs t).mp ht + +/-- **Shifting the base of a group.** Under the group's reduced context, the +`Δ` of a part of the group is the same from any duplicate-free base of +members that contains the context's stored terms and avoids the group and the +context's unstored terms. -/ +theorem Env.delta_shift {E : Env} (hE : E.WF) {h Ih Oh : Array Nat} (hctx : E.GroupCtx h Ih Oh) + {B S : List Nat} (hBn : B.Nodup) (hIB : ∀ t ∈ Ih.toList, t ∈ B) + (hBm : ∀ t ∈ B, t ∈ E.cx.members.toList) (hBh : ∀ t ∈ B, t ∉ h.toList) + (hBO : ∀ t ∈ B, t ∉ Oh.toList) (hS : ∀ t ∈ S, t ∈ h.toList) : + E.delta B S = E.delta Ih.toList S := by + obtain ⟨_, hIs, _, hchk, hIm, hOm, hIO⟩ := hctx + have hIn := strictInc_nodup hIs + let D := B.filter (fun t => decide (t ∉ Ih.toList)) + have hperm : B.Perm (Ih.toList ++ D) := by + apply (List.perm_ext_iff_of_nodup hBn (nodup_app hIn (List.Nodup.sublist List.filter_sublist hBn) + (fun x hx hxD => by simp only [List.mem_filter, decide_eq_true_eq] at hxD; exact hxD.2 hx))).mpr + intro t + simp only [List.mem_append, List.mem_filter, decide_eq_true_eq] + constructor + · intro ht + by_cases hti : t ∈ Ih.toList + · exact Or.inl hti + · exact Or.inr ⟨ht, hti⟩ + · rintro (h | ⟨h, _⟩) + · exact hIB t h + · exact h + have hmod := group_modular hE.G.wf hE.G.hroots hE.θ1 hE.cx hE.csc hchk + (fun t ht => ⟨hIm t ht, hIO t ht⟩) hOm (D := D) (S := S) + (fun t ht => by + simp only [D, List.mem_filter, decide_eq_true_eq] at ht + exact ⟨hBm t ht.1, hBh t ht.1, ht.2, hBO t ht.1⟩) hS + unfold Env.delta + rw [scost_perm (List.Perm.append_right S hperm), scost_perm hperm] + omega + +/-- **Pruning is sound.** Under a group's reduced context, every minimum's +`Δ` of the group is within `slack` of the best entry of a valid table. -/ +theorem Env.prune_ok {E : Env} (hE : E.WF) {g I O : Array Nat} (hctx : E.GroupCtx g I O) + {tb : CTable} (htab : E.TabOK g.toList I.toList tb) {bd : _root_.Int} (hbd : tb.best = some bd) + {Y : List Nat} (hY : E.Cons Y I.toList O.toList) : + E.delta I.toList (partOf Y g.toList) ≤ bd + (E.cx.slack : _root_.Int) := by + obtain ⟨hgs, hIs, _, hchk, hIm, hOm, hIO⟩ := hctx + obtain ⟨k, e, he, heb⟩ := best_attained hbd + obtain ⟨_, hen, hesub, hev⟩ := htab k e he + have hrep := group_rep hE.G hE.cx E.comp E.i hE.comp hE.memi hchk (strictInc_nodup hgs) + (strictInc_nodup hIs) (fun t ht => ⟨hIm t ht, hIO t ht⟩) hOm hY.1 hY.2.1 hY.2.2 + (S := e.2.toList) hesub (hen.imp Nat.ne_of_lt) + rw [← hE.slack] at hrep + unfold Env.delta at hev ⊢ + unfold partOf + omega + +/-- **Trimming keeps the coverage** of a valid table. -/ +theorem Env.covers_trim {E : Env} (hE : E.WF) {g I O : Array Nat} (hctx : E.GroupCtx g I O) + {tb : CTable} (htab : E.TabOK g.toList I.toList tb) + (hcov : E.Covers g.toList I.toList O.toList tb) : + E.Covers g.toList I.toList O.toList (tb.trim E.cx.slack) := by + intro Y hY + exact (trim_tie E.cx.slack (fun k e he => (htab k e he).2.1)).2 (hcov Y hY) + (fun b hb => E.prune_ok hE hctx htab hb hY) + +theorem Env.TabOK.sorted {E : Env} {g I : List Nat} {tb : CTable} (h : E.TabOK g I tb) : + SortedT tb := fun k e he => (h k e he).2.1 + +/-! ## Reclassification -/ + +theorem filter_map_perm {α : Type} (p : α → Bool) (f : α → Nat) (l : List α) : + ((l.filter p).map f ++ (l.filter (fun x => !p x)).map f).Perm (l.map f) := by + rw [← List.map_append] + exact (List.filter_append_perm p l).map f + +/-- The gain record of a member at a node. -/ +def reGain (cx : SCtx) (outAll : Array Nat) (t : Nat) : Nat × _root_.Int × Bool := + (t, storedGainWith cx.up.prep (cx.rebound (msOf cx.cand outAll)) cx.up.w t + (cx.revisible (msOf cx.cand outAll)).1[t]! (cx.revisible (msOf cx.cand outAll)).2[t]!, + 1 ≤ (cx.revisible (msOf cx.cand outAll)).1[t]! && + (cx.revisible (msOf cx.cand outAll)).2[t]! ≤ (cx.revisible (msOf cx.cand outAll)).1[t]!) + +/-- Whether a gain record is forced. -/ +def reForced (cx : SCtx) (e : Nat × _root_.Int × Bool) : Bool := e.2.2 && e.2.1 ≥ cx.theta + +theorem reclassify_eq (cx : SCtx) (outAll localIn und : Array Nat) : + cx.reclassify outAll localIn und = + (if (((und.map (reGain cx outAll)).filter (reForced cx)).map (·.1)).isEmpty then localIn + else mergeSorted localIn (((und.map (reGain cx outAll)).filter (reForced cx)).map (·.1)), + ((und.map (reGain cx outAll)).filter (fun e => !reForced cx e)).map (fun e => (e.1, e.2.1)), + cx.rebound (msOf cx.cand outAll)) := rfl + +theorem reclassify_sorted (cx : SCtx) (outAll localIn und : Array Nat) : + (cx.reclassify outAll localIn und).1 = localIn ∨ + (cx.reclassify outAll localIn und).1.toList.Pairwise (· ≤ ·) := by + rw [reclassify_eq] + simp only + split + · exact Or.inl rfl + · exact Or.inr (mergeSorted_sorted _ _) + +theorem reclassify_spec (cx : SCtx) (outAll localIn und : Array Nat) : + ∃ F : List Nat, + (cx.reclassify outAll localIn und).1.toList.Perm (localIn.toList ++ F) ∧ + und.toList.Perm (F ++ ((cx.reclassify outAll localIn und).2.1.toList.map (·.1))) ∧ + ∀ t ∈ F, 1 ≤ (cx.revisible (msOf cx.cand outAll)).1[t]! ∧ + (cx.revisible (msOf cx.cand outAll)).2[t]! ≤ (cx.revisible (msOf cx.cand outAll)).1[t]! ∧ + storedGainWith cx.up.prep (cx.rebound (msOf cx.cand outAll)) cx.up.w t + (cx.revisible (msOf cx.cand outAll)).1[t]! + (cx.revisible (msOf cx.cand outAll)).2[t]! ≥ cx.theta := by + rw [reclassify_eq] + generalize hgains : und.map (reGain cx outAll) = gains + have hgl : gains.toList = und.toList.map (reGain cx outAll) := by + rw [← hgains, Array.toList_map] + refine ⟨((gains.filter (reForced cx)).map (·.1)).toList, ?_, ?_, ?_⟩ + · simp only + split + · rename_i hemp + have : ((gains.filter (reForced cx)).map (·.1)).toList = [] := by + rw [Array.isEmpty_iff.mp hemp] + rw [this, List.append_nil] + · exact mergeSorted_perm _ _ + · simp only [Array.toList_map, Array.toList_filter, List.map_map] + have h1 := filter_map_perm (reForced cx) (·.1) gains.toList + have h2 : gains.toList.map (·.1) = und.toList := by + rw [hgl, List.map_map] + conv => rhs; rw [← List.map_id und.toList] + rfl + rw [h2] at h1 + exact h1.symm + · intro t ht + simp only [Array.toList_map, Array.toList_filter, List.mem_map, List.mem_filter] at ht + obtain ⟨e, ⟨he, hf⟩, rfl⟩ := ht + rw [hgl, List.mem_map] at he + obtain ⟨t', _, rfl⟩ := he + simp only [reForced, reGain, Bool.and_eq_true, decide_eq_true_eq] at hf + exact ⟨hf.1.1, hf.1.2, of_decide_eq_true hf.2⟩ + +/-! ## The memo -/ + +theorem Env.memoOK_insert {E : Env} {memo : Std.HashMap (Array Nat × Array Nat) CTable} + (hm : E.MemoOK memo) {g ent : Array Nat} {tb : CTable} + (hctx : E.GroupCtx g (keyContext ent).1 (keyContext ent).2) + (htab : E.TabOK g.toList (keyContext ent).1.toList tb) + (hcov : E.Covers g.toList (keyContext ent).1.toList (keyContext ent).2.toList tb) : + E.MemoOK (memo.insert (g, ent) tb) := by + intro g' ent' tb' h + rw [Std.HashMap.get?_insert] at h + split at h + · rename_i hk + have hk' : (g, ent) = (g', ent') := by simpa using hk + cases hk' + cases h + exact ⟨hctx, htab, hcov⟩ + · exact hm g' ent' tb' h + +/-! ## The specifications of the search functions -/ + +theorem Env.GroupCtx.facts {E : Env} (hE : E.WF) {g I O : Array Nat} (h : E.GroupCtx g I O) : + (∀ t ∈ g.toList, t ∈ E.cx.members.toList ∧ t < E.dag.size ∧ t ∉ I.toList ∧ t ∉ O.toList) ∧ + g.toList.Nodup ∧ I.toList.Nodup ∧ O.toList.Nodup := by + obtain ⟨hgs, hIs, hOs, hchk, _, _, _⟩ := h + have hdag : E.cx.up.prep.dag = E.dag := by rw [hE.cx.prep]; rfl + obtain ⟨ha, _⟩ := sepCheck_spec (cx := E.cx) (by rw [hdag]; exact hE.G.wf) + (by rw [hdag, hE.cx.closure]) + (by intro t ht; rw [hdag]; exact (hE.cx.mem t (Array.mem_toList_iff.mpr ht)).1) hchk + rw [hdag] at ha + refine ⟨fun t ht => ?_, strictInc_nodup hgs, strictInc_nodup hIs, strictInc_nodup hOs⟩ + obtain ⟨h1, h2, h3, h4⟩ := ha t (Array.mem_toList_iff.mp ht) + exact ⟨Array.mem_toList_iff.mpr h1, h2, fun h => h3 (Array.mem_toList_iff.mp h), + fun h => h4 (Array.mem_toList_iff.mp h)⟩ + +/-- The precondition of a search node of group `g` under `(I, O)`. -/ +structure Env.NodePre (E : Env) (g I O : Array Nat) (phi0 : Nat) (outAll localIn und : Array Nat) + (tb : CTable) (memo : Std.HashMap (Array Nat × Array Nat) CTable) : Prop where + ctx : E.GroupCtx g I O + phi0 : phi0 = scost E.cx E.dag I.toList + outO : ∀ t ∈ O.toList, t ∈ outAll.toList + outM : ∀ t ∈ outAll.toList, t ∈ E.cx.members.toList + outI : ∀ t ∈ outAll.toList, t ∉ I.toList + locG : ∀ t ∈ localIn.toList, t ∈ g.toList + undG : ∀ t ∈ und.toList, t ∈ g.toList + nodup : (localIn.toList ++ und.toList).Nodup + outLU : ∀ t ∈ outAll.toList, t ∉ localIn.toList ∧ t ∉ und.toList + locSorted : localIn.toList.Pairwise (· < ·) + cover : ∀ x ∈ g.toList, x ∈ localIn.toList ∨ x ∈ und.toList ∨ x ∈ outAll.toList + tab : E.TabOK g.toList I.toList tb + memo : E.MemoOK memo + +/-- The postcondition of a search node. -/ +def Env.NodePost (E : Env) (g I : Array Nat) (outAll localIn : Array Nat) (tb tb' : CTable) + (memo' : Std.HashMap (Array Nat × Array Nat) CTable) : Prop := + E.TabOK g.toList I.toList tb' ∧ ImprovesT tb tb' ∧ + (∀ Y, E.Cons Y (I.toList ++ localIn.toList) outAll.toList → + HasAtT tb' (partOf Y g.toList).length (E.delta I.toList (partOf Y g.toList)) + (partOf Y g.toList)) ∧ + E.MemoOK memo' + +def Env.SolvePSpec (E : Env) (limits : Limits) (fuel : Nat) : Prop := + ∀ (g inAll outAll : Array Nat) (st : SState) (tb : CTable) (st' : SState), + E.cx.solveP limits fuel g inAll outAll st = .ok (tb, st') → + (∀ t ∈ inAll.toList, t ∈ E.cx.members.toList) → (∀ t ∈ outAll.toList, t ∈ E.cx.members.toList) → + (∀ t ∈ inAll.toList, t ∉ outAll.toList) → E.MemoOK st.memo → + E.MemoOK st'.memo ∧ ∃ I O : Array Nat, (∀ t ∈ I.toList, t ∈ inAll.toList) ∧ + (∀ t ∈ O.toList, t ∈ outAll.toList) ∧ E.GroupCtx g I O ∧ E.TabOK g.toList I.toList tb ∧ + E.Covers g.toList I.toList O.toList tb + +def Env.SolveBodySpec (E : Env) (limits : Limits) (fuel : Nat) : Prop := + ∀ (g I O : Array Nat) (st : SState) (tb : CTable) (st' : SState), + E.cx.solveBody limits fuel g I O st = .ok (tb, st') → E.GroupCtx g I O → E.MemoOK st.memo → + E.MemoOK st'.memo ∧ E.TabOK g.toList I.toList tb ∧ E.Covers g.toList I.toList O.toList tb + +def Env.NodePSpec (E : Env) (limits : Limits) (fuel : Nat) : Prop := + ∀ (g I O : Array Nat) (phi0 : Nat) (outAll : Array Nat) (nOut : Nat) (localIn und : Array Nat) + (tb : CTable) (st : SState) (tb' : CTable) (st' : SState), + E.cx.nodeP limits fuel phi0 I outAll nOut localIn und tb st = .ok (tb', st') → + E.NodePre g I O phi0 outAll localIn und tb st.memo → + E.NodePost g I outAll localIn tb tb' st'.memo + +/-- The combinations of a split: each contains `L` and is within `L ∪ U`, with +its exact `Δ`. -/ +def Env.CombOK (E : Env) (I L U : List Nat) (comb : CTable) : Prop := + ∀ e, some e ∈ comb.toList → e.2.toList.Pairwise (· < ·) ∧ (∀ x ∈ L, x ∈ e.2.toList) ∧ + (∀ x ∈ e.2.toList, x ∈ L ∨ x ∈ U) ∧ e.1 = E.delta I e.2.toList + +/-- Every minimum respecting the node has a combination at its count. -/ +def Env.CombCov (E : Env) (I L U O : List Nat) (comb : CTable) : Prop := + ∀ Y, E.Cons Y (I ++ L) O → ∃ e, some e ∈ comb.toList ∧ e.2.size = (L ++ partOf Y U).length ∧ + (e.1 < E.delta I (L ++ partOf Y U) ∨ + (e.1 = E.delta I (L ++ partOf Y U) ∧ LeL e.2.toList (L ++ partOf Y U))) + +/-- The precondition of a split of a node of group `g` under `(I, O)`. -/ +structure Env.SplitPre (E : Env) (g I O : Array Nat) (L U : List Nat) (outAll : Array Nat) + (grps : List (Array Nat)) (comb : CTable) (memo : Std.HashMap (Array Nat × Array Nat) CTable) : + Prop where + ctx : E.GroupCtx g I O + outO : ∀ t ∈ O.toList, t ∈ outAll.toList + outM : ∀ t ∈ outAll.toList, t ∈ E.cx.members.toList + outI : ∀ t ∈ outAll.toList, t ∉ I.toList + sub : ∀ t ∈ L ++ U ++ grps.flatMap (·.toList), t ∈ g.toList ∧ t ∉ outAll.toList + nodup : (L ++ U ++ grps.flatMap (·.toList)).Nodup + combOK : E.CombOK I.toList L U comb + combCov : E.CombCov I.toList L U outAll.toList comb + memo : E.MemoOK memo + +def Env.SplitPSpec (E : Env) (limits : Limits) (fuel : Nat) : Prop := + ∀ (g I O : Array Nat) (L U : List Nat) (inAll outAll : Array Nat) (grps : List (Array Nat)) + (comb : CTable) (st : SState) (comb' : CTable) (st' : SState), + E.cx.splitP limits fuel inAll outAll grps comb st = .ok (comb', st') → + inAll.toList = I.toList ++ L → + E.SplitPre g I O L U outAll grps comb st.memo → + E.CombOK I.toList L (U ++ grps.flatMap (·.toList)) comb' ∧ + E.CombCov I.toList L (U ++ grps.flatMap (·.toList)) outAll.toList comb' ∧ E.MemoOK st'.memo + +/-! ## No fuel -/ + +theorem Env.specs_zero (E : Env) (limits : Limits) : + E.SolvePSpec limits 0 ∧ E.SolveBodySpec limits 0 ∧ E.NodePSpec limits 0 ∧ + E.SplitPSpec limits 0 := by + refine ⟨?_, ?_, ?_, ?_⟩ + · intro _ _ _ _ _ _ h; rw [SCtx.solveP] at h; cases h + · intro _ _ _ _ _ _ h; rw [SCtx.solveBody] at h; cases h + · intro _ _ _ _ _ _ _ _ _ _ _ _ h; rw [SCtx.nodeP] at h; cases h + · intro _ _ _ _ _ _ _ _ _ _ _ _ h; rw [SCtx.splitP.eq_1] at h; cases h + +/-! ## The group search -/ + +theorem empty_tabOK (E : Env) (g I : List Nat) : E.TabOK g I #[] := by + intro k e he + simp at he + +theorem Env.solveBody_step {E : Env} (hE : E.WF) {limits : Limits} {fuel : Nat} + (hnode : E.NodePSpec limits fuel) : E.SolveBodySpec limits (fuel + 1) := by + intro g I O st tb st' h hctx hmemo + rw [SCtx.solveBody] at h + obtain ⟨hgf, hgn, hIn, hOn⟩ := hctx.facts hE + obtain ⟨_, _, _, _, hIm, hOm, hIO⟩ := id hctx + have hphi := phiE_cost hE.G.wf hE.cx I hIm (fun t => (I.foldl (·.insert ·) + ({} : Std.HashSet Nat)).contains t) (fun t => hashSet_ofArray_contains I t) + generalize hpe : E.cx.phiE (fun t => (I.foldl (·.insert ·) ({} : Std.HashSet Nat)).contains t) I + = pw at h hphi + obtain ⟨phi0, work⟩ := pw + simp only at h hphi + obtain ⟨st1, hst1, h⟩ := bind_eq_ok h + obtain ⟨⟨tb0, st2⟩, hnd, h⟩ := bind_eq_ok h + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + have hpre : E.NodePre g I O phi0 O #[] g #[] st1.memo := + { ctx := hctx + phi0 := hphi + outO := fun t ht => ht + outM := hOm + outI := fun t ht hI => hIO t hI ht + locG := fun t ht => by simp at ht + undG := fun t ht => ht + nodup := by simpa using hgn + outLU := fun t ht => ⟨by simp, fun hg => (hgf t hg).2.2.2 ht⟩ + locSorted := by simp + cover := fun x hx => Or.inr (Or.inl hx) + tab := empty_tabOK E _ _ + memo := by rw [chargeP_memo hst1]; exact hmemo } + obtain ⟨htab, _, hcov, hmemo'⟩ := hnode g I O phi0 O O.size #[] g #[] st1 tb0 st2 hnd hpre + have hcov' : E.Covers g.toList I.toList O.toList tb0 := by + intro Y hY + exact hcov Y (by simpa using hY) + exact ⟨hmemo', trim_entries htab _, E.covers_trim hE hctx htab hcov'⟩ + +theorem Env.solveP_step {E : Env} (_hE : E.WF) {limits : Limits} {fuel : Nat} + (hbody : E.SolveBodySpec limits fuel) : E.SolvePSpec limits (fuel + 1) := by + intro g inAll outAll st tb st' h hinM houtM hio hmemo + rw [SCtx.solveP] at h + simp only at h + generalize hmk : E.cx.memoKey (fun x => (E.cx.opaqueArr inAll outAll)[x]!) + (inAll.foldl (·.insert ·) ∅) (outAll.foldl (·.insert ·) ∅) g = mk at h + obtain ⟨entries, rel⟩ := mk + generalize hkc : keyContext entries = kc at h + obtain ⟨inRed, outRed⟩ := kc + simp only at h + split at h + all_goals first | (cases h; done) | skip + rename_i hchk + have hchk' : (strictInc g && strictInc inRed && strictInc outRed && + inRed.all (inAll.foldl (·.insert ·) (∅ : Std.HashSet Nat)).contains && + outRed.all (outAll.foldl (·.insert ·) (∅ : Std.HashSet Nat)).contains) = true := by + simpa using hchk + simp only [Bool.and_eq_true] at hchk' + obtain ⟨⟨⟨⟨hgs, hIs⟩, hOs⟩, hIin⟩, hOout⟩ := hchk' + have hIsub : ∀ t ∈ inRed.toList, t ∈ inAll.toList := by + intro t ht + rw [Array.all_eq_true'] at hIin + have := hIin t (Array.mem_toList_iff.mp ht) + rw [hashSet_ofArray_contains] at this + simpa using this + have hOsub : ∀ t ∈ outRed.toList, t ∈ outAll.toList := by + intro t ht + rw [Array.all_eq_true'] at hOout + have := hOout t (Array.mem_toList_iff.mp ht) + rw [hashSet_ofArray_contains] at this + simpa using this + split at h + · -- memo hit + rename_i tb0 hget + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + obtain ⟨hctx, htab, hcov⟩ := hmemo g entries tb0 hget + rw [hkc] at hctx htab hcov + exact ⟨hmemo, inRed, outRed, hIsub, hOsub, hctx, htab, hcov⟩ + · -- memo miss + split at h + all_goals first | (cases h; done) | skip + rename_i hsep0 + have hsep : E.cx.sepCheck g inRed outRed = true := by simpa using hsep0 + obtain ⟨⟨tb0, st2⟩, hb, h⟩ := bind_eq_ok h + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + have hctx : E.GroupCtx g inRed outRed := + ⟨hgs, hIs, hOs, hsep, fun t ht => hinM t (hIsub t ht), fun t ht => houtM t (hOsub t ht), + fun t ht ht' => hio t (hIsub t ht) (hOsub t ht')⟩ + obtain ⟨hmemo2, htab, hcov⟩ := hbody g inRed outRed st tb0 st2 hb hctx hmemo + refine ⟨?_, inRed, outRed, hIsub, hOsub, hctx, htab, hcov⟩ + apply E.memoOK_insert hmemo2 <;> rw [hkc] + · exact hctx + · exact htab + · exact hcov + +/-! ## Splits -/ + +theorem Env.delta_append (E : Env) (I A B : List Nat) : + E.delta I (A ++ B) = E.delta I A + E.delta (I ++ A) B := by + unfold Env.delta + rw [List.append_assoc] + omega + +theorem partOf_append (Y A B : List Nat) : partOf Y (A ++ B) = partOf Y A ++ partOf Y B := by + unfold partOf; exact List.filter_append _ _ + +theorem partOf_sub {Y A : List Nat} : ∀ t ∈ partOf Y A, t ∈ A ∧ t ∈ Y := by + intro t ht + simp only [partOf, List.mem_filter, decide_eq_true_eq] at ht + exact ht + +theorem Env.splitP_step {E : Env} (hE : E.WF) {limits : Limits} {fuel : Nat} + (hsolve : E.SolvePSpec limits fuel) (hsplit : E.SplitPSpec limits fuel) : + E.SplitPSpec limits (fuel + 1) := by + intro g I O L U inAll outAll grps comb st comb' st' h hin hpre + cases grps with + | nil => + rw [SCtx.splitP.eq_2] at h + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + simp only [List.flatMap_nil, List.append_nil] + exact ⟨hpre.combOK, hpre.combCov, hpre.memo⟩ + | cons hg rest => + rw [SCtx.splitP.eq_3] at h + obtain ⟨⟨sub, st1⟩, hs, h⟩ := bind_eq_ok h + simp only at h + obtain ⟨hgf, hgn, hIn, hOn⟩ := hpre.ctx.facts hE + obtain ⟨_, _, _, _, hIm, hOm, hIO⟩ := id hpre.ctx + have hsubL : ∀ t ∈ L, t ∈ g.toList ∧ t ∉ outAll.toList := + fun t ht => hpre.sub t (by simp [ht]) + have hsubU : ∀ t ∈ U, t ∈ g.toList ∧ t ∉ outAll.toList := + fun t ht => hpre.sub t (by simp [ht]) + have hsubh : ∀ t ∈ hg.toList, t ∈ g.toList ∧ t ∉ outAll.toList := + fun t ht => hpre.sub t (by simp [ht]) + have hnd := hpre.nodup + simp only [List.flatMap_cons] at hnd + -- the parts are pairwise disjoint + have hLU_h : ∀ t, t ∈ L ∨ t ∈ U → t ∉ hg.toList := by + intro t ht hth + have := List.nodup_append.mp hnd + rcases ht with ht | ht + · exact this.2.2 t (by simp [ht]) t (by simp [hth]) rfl + · exact this.2.2 t (by simp [ht]) t (by simp [hth]) rfl + have hinM : ∀ t ∈ inAll.toList, t ∈ E.cx.members.toList := by + intro t ht + rw [hin, List.mem_append] at ht + rcases ht with ht | ht + · exact hIm t ht + · exact (hgf t (hsubL t ht).1).1 + have hio : ∀ t ∈ inAll.toList, t ∉ outAll.toList := by + intro t ht + rw [hin, List.mem_append] at ht + rcases ht with ht | ht + · exact fun h => hpre.outI t h ht + · exact (hsubL t ht).2 + obtain ⟨hmemo1, Ih, Oh, hIh, hOh, hctxh, htabh, hcovh⟩ := + hsolve hg inAll outAll st sub st1 hs hinM hpre.outM hio hpre.memo + obtain ⟨hhf, hhn, hIhn, hOhn⟩ := hctxh.facts hE + -- the shift to a base containing `I ++ L` + have hshift : ∀ (A : List Nat) (S : List Nat), A.Nodup → (∀ x ∈ L, x ∈ A) → + (∀ x ∈ A, x ∈ L ∨ x ∈ U) → (∀ x ∈ S, x ∈ hg.toList) → + E.delta (I.toList ++ A) S = E.delta Ih.toList S := by + intro A S hAn hLA hAsub hS + apply E.delta_shift hE hctxh + · apply nodup_app hIn hAn + intro x hx hxA + rcases hAsub x hxA with h | h + · exact (hgf x (hsubL x h).1).2.2.1 hx + · exact (hgf x (hsubU x h).1).2.2.1 hx + · intro t ht + have := hIh t ht + rw [hin, List.mem_append] at this + rcases this with h | h + · exact List.mem_append_left _ h + · exact List.mem_append_right _ (hLA t h) + · intro t ht + rcases List.mem_append.mp ht with h | h + · exact hIm t h + · rcases hAsub t h with h | h + · exact (hgf t (hsubL t h).1).1 + · exact (hgf t (hsubU t h).1).1 + · intro t ht hth + rcases List.mem_append.mp ht with h | h + · exact (hgf t (hsubh t hth).1).2.2.1 h + · exact hLU_h t (hAsub t h) hth + · intro t ht hto + have hto' := hOh t hto + rcases List.mem_append.mp ht with h | h + · exact hpre.outI t hto' h + · rcases hAsub t h with h | h + · exact (hsubL t h).2 hto' + · exact (hsubU t h).2 hto' + · exact hS + -- the new combinations + have hLUn : (L ++ U).Nodup := (List.nodup_append.mp hnd).1 + have hLn : L.Nodup := (List.nodup_append.mp hLUn).1 + have hUn : U.Nodup := (List.nodup_append.mp hLUn).2.1 + have hLUd : ∀ a ∈ L, ∀ b ∈ U, a ≠ b := (List.nodup_append.mp hLUn).2.2 + have hce := conv_entries (a := comb) (b := sub) (Pa := fun e => some e ∈ comb.toList) + (Pb := fun e => some e ∈ sub.toList) (fun e he => he) (fun e he => he) + have hcsorted : ∀ e, some e ∈ comb.toList → e.2.toList.Pairwise (· < ·) := + fun e he => (hpre.combOK e he).1 + have hssorted : ∀ e, some e ∈ sub.toList → e.2.toList.Pairwise (· < ·) := + fun e he => (htabh.mem he).1 + have hcsdisj : ∀ ea, some ea ∈ comb.toList → ∀ eb, some eb ∈ sub.toList → + ∀ x ∈ ea.2.toList, x ∉ eb.2.toList := + fun ea hea eb heb x hx hx' => hLU_h x ((hpre.combOK ea hea).2.2.1 x hx) ((htabh.mem heb).2.1 x hx') + obtain ⟨hconvSorted, hconvT⟩ := conv_tie hcsorted hssorted hcsdisj + have hcombOK : E.CombOK I.toList L (U ++ hg.toList) (comb.conv sub) := by + intro e he + obtain ⟨k, hk⟩ := mem_toList_getElem! he + obtain ⟨_, ec, es, hec, hes, rfl⟩ := hce k e hk + obtain ⟨hecn, hecL, hecs, hecv⟩ := hpre.combOK ec hec + obtain ⟨hesn, hesh, hesv⟩ := htabh.mem hes + have hperm := mergeSorted_perm ec.2 es.2 + have hdisj : ∀ x ∈ ec.2.toList, x ∉ es.2.toList := + fun x hx hx' => hLU_h x (hecs x hx) (hesh x hx') + refine ⟨mergeSorted_strict hecn hesn hdisj, + fun x hx => hperm.mem_iff.mpr (List.mem_append_left _ (hecL x hx)), fun x hx => ?_, ?_⟩ + · rcases List.mem_append.mp (hperm.mem_iff.mp hx) with h | h + · rcases hecs x h with h | h + · exact Or.inl h + · exact Or.inr (List.mem_append_left _ h) + · exact Or.inr (List.mem_append_right _ (hesh x h)) + · simp only + rw [E.delta_perm hperm, E.delta_append, hecv, hesv, + hshift ec.2.toList es.2.toList (hecn.imp Nat.ne_of_lt) hecL hecs hesh] + have hcombCov : E.CombCov I.toList L (U ++ hg.toList) outAll.toList (comb.conv sub) := by + intro Y hY + obtain ⟨ec, hec, hecsz, hecv⟩ := hpre.combCov Y hY + have hYc : E.Cons Y Ih.toList Oh.toList := + ⟨hY.1, fun t ht => hY.2.1 t (by have := hIh t ht; rw [hin] at this; exact this), + fun t ht => hY.2.2 t (hOh t ht)⟩ + obtain ⟨es, hes, hesv⟩ := hcovh Y hYc + have hesz := (htabh _ es hes).1 + obtain ⟨ecv, hecv', hle⟩ := hconvT ec hec es (getElem!_mem_toList hes) + have hecvsz := (hce _ ecv hecv').1 + have hpU : ∀ t ∈ partOf Y U, t ∈ U := fun t ht => (partOf_sub t ht).1 + have hpUn : (partOf Y U).Nodup := List.Nodup.sublist List.filter_sublist hUn + have hAn : (L ++ partOf Y U).Nodup := + nodup_app hLn hpUn (fun x hx hxU => hLUd x hx x (hpU x hxU) rfl) + have heq := hshift (L ++ partOf Y U) (partOf Y hg.toList) hAn + (fun x hx => List.mem_append_left _ hx) + (fun x hx => by + rcases List.mem_append.mp hx with h | h + · exact Or.inl h + · exact Or.inr (hpU x h)) + (fun x hx => (partOf_sub x hx).1) + have hval : E.delta I.toList (L ++ partOf Y (U ++ hg.toList)) = + E.delta I.toList (L ++ partOf Y U) + E.delta Ih.toList (partOf Y hg.toList) := by + rw [partOf_append, ← List.append_assoc, E.delta_append, heq] + refine ⟨ecv, getElem!_mem_toList hecv', ?_, ?_⟩ + · rw [hecvsz, hecsz, hesz, partOf_append] + simp only [List.length_append] + omega + · rw [hval] + -- the combination of the two entries against the minimum's parts + have hpair : (ec.1 + es.1 < E.delta I.toList (L ++ partOf Y U) + + E.delta Ih.toList (partOf Y hg.toList)) ∨ + (ec.1 + es.1 = E.delta I.toList (L ++ partOf Y U) + + E.delta Ih.toList (partOf Y hg.toList) ∧ + LeL (mergeSorted ec.2 es.2).toList (L ++ partOf Y U ++ partOf Y hg.toList)) := by + rcases hecv with h1 | ⟨h1, h1'⟩ <;> rcases hesv with h2 | ⟨h2, h2'⟩ + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · refine Or.inr ⟨by omega, ?_⟩ + have hm := (mergeSorted_perm ec.2 es.2) + apply precL_union (X1 := ec.2.toList) (Y1 := L ++ partOf Y U) (X2 := es.2.toList) + (Y2 := partOf Y hg.toList) + · intro a ha hb + have ha' : a ∈ L ∨ a ∈ U := by + rcases ha with ha | ha + · exact (hpre.combOK ec hec).2.2.1 a ha + · rcases List.mem_append.mp ha with h | h + · exact Or.inl h + · exact Or.inr (hpU a h) + have hb' : a ∈ hg.toList := by + rcases hb with hb | hb + · exact (htabh.mem (getElem!_mem_toList hes)).2.1 a hb + · exact (partOf_sub a hb).1 + exact hLU_h a ha' hb' + · intro u; rw [hm.mem_iff, List.mem_append] + · intro u; rw [List.mem_append] + · exact h1' + · exact h2' + rcases hle with h | ⟨h, h'⟩ <;> rcases hpair with hp | ⟨hp, hp'⟩ + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inr ⟨by omega, leL_congr (fun _ => Iff.rfl) + (fun u => by rw [partOf_append, List.append_assoc]) (leL_trans h' hp')⟩ + have hpre' : E.SplitPre g I O L (U ++ hg.toList) outAll rest (comb.conv sub) st1.memo := + { ctx := hpre.ctx, outO := hpre.outO, outM := hpre.outM, outI := hpre.outI + sub := fun t ht => hpre.sub t (by + simp only [List.flatMap_cons, List.mem_append] at ht ⊢ + rcases ht with (h | h | h) | h + · exact Or.inl (Or.inl h) + · exact Or.inl (Or.inr h) + · exact Or.inr (Or.inl h) + · exact Or.inr (Or.inr h)) + nodup := by + have := hpre.nodup + simp only [List.flatMap_cons, List.append_assoc] at this ⊢ + exact this + combOK := hcombOK + combCov := hcombCov + memo := hmemo1 } + obtain ⟨h1, h2, h3⟩ := + hsplit g I O L (U ++ hg.toList) inAll outAll rest (comb.conv sub) st1 comb' st' h hin hpre' + simp only [List.flatMap_cons, List.append_assoc] at h1 h2 ⊢ + exact ⟨h1, h2, h3⟩ + +/-! ## Search nodes -/ + +theorem Env.nodeP_step {E : Env} (hE : E.WF) {limits : Limits} {fuel : Nat} + (hnode : E.NodePSpec limits fuel) (hsplit : E.SplitPSpec limits fuel) : + E.NodePSpec limits (fuel + 1) := by + intro g I O phi0 outAll nOut localIn und tb st tb' st' h pre + rw [SCtx.nodeP] at h + obtain ⟨F, hLperm, hUperm, hF⟩ := reclassify_spec E.cx outAll localIn und + generalize hrc : E.cx.reclassify outAll localIn und = rc at h hLperm hUperm + obtain ⟨localIn', open_, b⟩ := rc + simp only at h hLperm hUperm + obtain ⟨hgf, hgn, hIn, hOn⟩ := pre.ctx.facts hE + obtain ⟨_, _, _, _, hIm, hOm, hIO⟩ := id pre.ctx + -- the node after reclassification + generalize hUn : open_.toList.map (·.1) = Un at hUperm + have hUnA : (open_.map (·.1)).toList = Un := by rw [← hUn, Array.toList_map] + have hFund : ∀ t ∈ F, t ∈ und.toList := fun t ht => hUperm.mem_iff.mpr (List.mem_append_left _ ht) + have hUnund : ∀ t ∈ Un, t ∈ und.toList := fun t ht => hUperm.mem_iff.mpr (List.mem_append_right _ ht) + have hpermLU : (localIn'.toList ++ Un).Perm (localIn.toList ++ und.toList) := by + refine (hLperm.append_right Un).trans ?_ + rw [List.append_assoc] + exact (hUperm.symm).append_left _ + have hLUn : (localIn'.toList ++ Un).Nodup := hpermLU.nodup_iff.mpr pre.nodup + have hL'n : localIn'.toList.Nodup := (List.nodup_append.mp hLUn).1 + have hL's : localIn'.toList.Pairwise (· < ·) := by + have hrs := reclassify_sorted E.cx outAll localIn und + rw [hrc] at hrs + simp only at hrs + rcases hrs with h | h + · rw [h]; exact pre.locSorted + · exact (List.Pairwise.and h hL'n).imp (fun h => Nat.lt_of_le_of_ne h.1 h.2) + have hUnn : Un.Nodup := (List.nodup_append.mp hLUn).2.1 + have hL'g : ∀ t ∈ localIn'.toList, t ∈ g.toList := by + intro t ht + rcases List.mem_append.mp (hLperm.mem_iff.mp ht) with h | h + · exact pre.locG t h + · exact pre.undG t (hFund t h) + have hUng : ∀ t ∈ Un, t ∈ g.toList := fun t ht => pre.undG t (hUnund t ht) + have hout' : ∀ t ∈ outAll.toList, t ∉ localIn'.toList ∧ t ∉ Un := by + intro t ht + obtain ⟨h1, h2⟩ := pre.outLU t ht + refine ⟨fun h => ?_, fun h => h2 (hUnund t h)⟩ + rcases List.mem_append.mp (hLperm.mem_iff.mp h) with h | h + · exact h1 h + · exact h2 (hFund t h) + have hcov' : ∀ x ∈ g.toList, x ∈ localIn'.toList ∨ x ∈ Un ∨ x ∈ outAll.toList := by + intro x hx + rcases pre.cover x hx with h | h | h + · exact Or.inl (hLperm.mem_iff.mpr (List.mem_append_left _ h)) + · rcases List.mem_append.mp (hUperm.mem_iff.mp h) with h | h + · exact Or.inl (hLperm.mem_iff.mpr (List.mem_append_right _ h)) + · exact Or.inr (Or.inl h) + · exact Or.inr (Or.inr h) + -- forced members are in every minimum respecting the node + have hforce : ∀ Y, E.Cons Y (I.toList ++ localIn.toList) outAll.toList → + E.Cons Y (I.toList ++ localIn'.toList) outAll.toList := by + intro Y hY + refine ⟨hY.1, fun t ht => ?_, hY.2.2⟩ + rcases List.mem_append.mp ht with h | h + · exact hY.2.1 t (List.mem_append_left _ h) + · rcases List.mem_append.mp (hLperm.mem_iff.mp h) with h | h + · exact hY.2.1 t (List.mem_append_right _ h) + · obtain ⟨h1, h2, h3⟩ := hF t h + exact forced_mem hE.G hE.cx hE.area hY.1 hY.2.2 (hgf t (pre.undG t (hFund t h))).1 h1 h2 h3 + -- a minimum's part of the group + have hpart : ∀ Y, E.Cons Y (I.toList ++ localIn'.toList) outAll.toList → + (partOf Y g.toList).Perm (localIn'.toList ++ partOf Y Un) := by + intro Y hY + apply (List.perm_ext_iff_of_nodup (List.Nodup.sublist List.filter_sublist hgn) + (List.Nodup.sublist (List.Sublist.append_left List.filter_sublist _) hLUn)).mpr + intro x + simp only [List.mem_append, List.mem_filter, decide_eq_true_eq] + constructor + · rintro ⟨hxg, hxY⟩ + rcases hcov' x hxg with h | h | h + · exact Or.inl h + · exact Or.inr ⟨h, hxY⟩ + · exact absurd hxY (hY.2.2 x h) + · rintro (h | ⟨h, hxY⟩) + · exact ⟨hL'g x h, hY.2.1 x (List.mem_append_right _ h)⟩ + · exact ⟨hUng x h, hxY⟩ + -- the node's lower bound + have hinAll : (I ++ localIn').toList = I.toList ++ localIn'.toList := Array.toList_append + have hinM : ∀ t ∈ (I ++ localIn').toList, t ∈ E.cx.members.toList := by + intro t ht + rw [hinAll, List.mem_append] at ht + rcases ht with h | h + · exact hIm t h + · exact (hgf t (hL'g t h)).1 + have havail : ∀ t, (((I ++ localIn').foldl (·.insert ·) (∅ : Std.HashSet Nat)).contains t || + ((open_.map (·.1)).foldl (·.insert ·) (∅ : Std.HashSet Nat)).contains t) = + decide (t ∈ (I ++ localIn').toList ∨ t ∈ Un) := by + intro t + rw [hashSet_ofArray_contains, hashSet_ofArray_contains, hUnA] + simp + have hlow := fun (X : List Nat) (hX : ∀ t ∈ X, t ∈ Un) => phiE_lower hE.G.wf hE.cx + (I ++ localIn') Un hinM (fun t ht => (hgf t (hUng t ht)).1) _ havail (X := X) hX + generalize hphi : E.cx.phiE (fun t => + ((I ++ localIn').foldl (·.insert ·) (∅ : Std.HashSet Nat)).contains t || + ((open_.map (·.1)).foldl (·.insert ·) (∅ : Std.HashSet Nat)).contains t) (I ++ localIn') + = pw at h hlow + obtain ⟨phi, work⟩ := pw + simp only at h hlow + have hbound : ∀ Y, E.Cons Y (I.toList ++ localIn'.toList) outAll.toList → + (phi : _root_.Int) - phi0 ≤ E.delta I.toList (partOf Y g.toList) := by + intro Y hY + have h1 := hlow (partOf Y Un) (fun t ht => (partOf_sub t ht).1) + rw [hinAll, List.append_assoc, ← scost_perm (List.Perm.append_left _ (hpart Y hY))] at h1 + unfold Env.delta + rw [pre.phi0] + omega + have hYcons : ∀ Y, E.Cons Y (I.toList ++ localIn.toList) outAll.toList → + E.Cons Y I.toList O.toList := fun Y hY => + ⟨hY.1, fun t ht => hY.2.1 t (List.mem_append_left _ ht), fun t ht => hY.2.2 t (pre.outO t ht)⟩ + obtain ⟨st1, hst1, h⟩ := bind_eq_ok h + have hm1 : st1.memo = st.memo := chargeP_memo hst1 + by_cases hemp : (open_.map (·.1)).isEmpty = true + · rw [if_pos hemp] at h + -- every undecided member is decided: one entry + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + have hUnnil : Un = [] := by + rw [← hUnA]; have := Array.isEmpty_iff.mp hemp; rw [this] + subst hUnnil + have hexact : phi = scost E.cx E.dag (I.toList ++ localIn'.toList) := by + have := phiE_cost hE.G.wf hE.cx (I ++ localIn') hinM (fun t => + ((I ++ localIn').foldl (·.insert ·) (∅ : Std.HashSet Nat)).contains t || + ((open_.map (·.1)).foldl (·.insert ·) (∅ : Std.HashSet Nat)).contains t) + (fun t => by rw [havail t]; simp) + rw [hphi] at this + rw [← hinAll]; exact this + have hval : (phi : _root_.Int) - phi0 = E.delta I.toList localIn'.toList := by + unfold Env.delta; rw [hexact, pre.phi0] + refine ⟨add_entries pre.tab ⟨hL's, hL'g, hval⟩, add_improvesT pre.tab.sorted hL's, ?_, + by rw [hm1]; exact pre.memo⟩ + intro Y hY + have hp := hpart Y (hforce Y hY) + have hnil : partOf Y ([] : List Nat) = [] := rfl + rw [hnil, List.append_nil] at hp + rw [hp.length_eq, E.delta_perm hp, ← hval, Array.length_toList] + exact (add_hasAtT pre.tab.sorted hL's (e := ((phi : _root_.Int) - phi0, localIn'))).congr + (fun u => hp.mem_iff.symm) + rw [if_neg hemp] at h + by_cases hpr : tb.prunes ((phi : _root_.Int) - phi0) E.cx.slack = true + · rw [if_pos hpr] at h + -- pruned: no minimum respects the node + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + refine ⟨pre.tab, improvesT_refl _, ?_, by rw [hm1]; exact pre.memo⟩ + intro Y hY + exfalso + have hb := hbound Y (hforce Y hY) + unfold CTable.prunes at hpr + split at hpr + · rename_i bd hbd + have := E.prune_ok hE pre.ctx pre.tab hbd (hYcons Y hY) + simp only [decide_eq_true_eq] at hpr + omega + · cases hpr + rw [if_neg hpr] at h + split at h + next hpc => + generalize hgr : E.cx.groups _ _ (Array.map (fun x => x.fst) open_) = groups at h hpc + have hgperm : (groups.toList.flatMap (·.toList)).Perm Un := by + rw [← hUnA]; exact partitionCheck_perm hpc + generalize hrt : (if groups.size > 1 then true else _ : Bool) = route at h + cases route + case true => + rw [if_pos rfl] at h + -- split into groups + have hphiN := phiE_cost hE.G.wf hE.cx (I ++ localIn') hinM + (fun t => ((I ++ localIn').foldl (·.insert ·) (∅ : Std.HashSet Nat)).contains t) + (fun t => by rw [hashSet_ofArray_contains]) + generalize hpn : E.cx.phiE (fun t => + ((I ++ localIn').foldl (·.insert ·) (∅ : Std.HashSet Nat)).contains t) (I ++ localIn') = pn + at h hphiN + obtain ⟨phiN, workN⟩ := pn + simp only at h hphiN + obtain ⟨st2, hst2, h⟩ := bind_eq_ok h + obtain ⟨⟨comb, st3⟩, hsp, h⟩ := bind_eq_ok h + simp only [pure, Except.pure, Except.ok.injEq, Prod.mk.injEq] at h + obtain ⟨rfl, rfl⟩ := h + have hbase : (phiN : _root_.Int) - phi0 = E.delta I.toList localIn'.toList := by + unfold Env.delta; rw [hphiN, pre.phi0, hinAll] + have hflat : ∀ t ∈ groups.toList.flatMap (·.toList), t ∈ Un := fun t ht => hgperm.mem_iff.mp ht + have hspre : E.SplitPre g I O localIn'.toList [] outAll groups.toList + #[some ((phiN : _root_.Int) - phi0, localIn')] st2.memo := + { ctx := pre.ctx, outO := pre.outO, outM := pre.outM, outI := pre.outI + sub := by + intro t ht + simp only [List.append_nil, List.mem_append] at ht + rcases ht with h | h + · exact ⟨hL'g t h, fun ho => (hout' t ho).1 h⟩ + · exact ⟨hUng t (hflat t h), fun ho => (hout' t ho).2 (hflat t h)⟩ + nodup := by + rw [List.append_nil] + exact (List.Perm.append_left _ hgperm).nodup_iff.mpr hLUn + combOK := by + intro e he + simp at he + subst he + refine ⟨hL's, fun x hx => hx, fun x hx => Or.inl hx, hbase⟩ + combCov := by + intro Y _ + refine ⟨((phiN : _root_.Int) - phi0, localIn'), by simp, ?_, ?_⟩ + · simp [partOf, Array.length_toList] + · simp only [partOf, List.filter_nil, List.append_nil]; rw [hbase] + exact Or.inr ⟨rfl, leL_refl _⟩ + memo := by rw [chargeP_memo hst2, hm1]; exact pre.memo } + obtain ⟨hcok, hccov, hmemo3⟩ := hsplit g I O localIn'.toList [] (I ++ localIn') outAll + groups.toList _ st2 comb st3 hsp hinAll hspre + simp only [List.nil_append] at hcok hccov + show E.NodePost g I outAll localIn tb (addAll tb comb) st3.memo + obtain ⟨_, hallImp, hallHas⟩ := addAll_tie pre.tab.sorted (fun e he => (hcok e he).1) + refine ⟨addAll_entries pre.tab (fun e he => ?_), hallImp, ?_, hmemo3⟩ + · obtain ⟨hn, _, hsub, hv⟩ := hcok e he + refine ⟨hn, fun x hx => ?_, hv⟩ + rcases hsub x hx with h | h + · exact hL'g x h + · exact hUng x (hflat x h) + · intro Y hY + have hY' := hforce Y hY + obtain ⟨e, he, hesz, hev⟩ := hccov Y hY' + have hpp : (localIn'.toList ++ partOf Y (groups.toList.flatMap (·.toList))).Perm + (partOf Y g.toList) := + ((List.Perm.append_left _ (hgperm.filter _))).trans (hpart Y hY').symm + have := hallHas e he + rw [hesz, hpp.length_eq] at this + refine (this.weakenT hev).congr (fun u => hpp.mem_iff) |>.weakenT ?_ + rw [E.delta_perm hpp] + exact Or.inr ⟨rfl, leL_refl _⟩ + case false => + rw [if_neg (by decide)] at h + split at h + · rename_i t gt hpick + have htU : t ∈ Un := by + rw [← hUn]; exact List.mem_map.mpr ⟨(t, gt), pickBranch_mem hpick, rfl⟩ + have hund2 : ((open_.map (·.1)).erase t).toList = Un.erase t := by + rw [toList_erase, hUnA] + have htg := hUng t htU + have htout : t ∉ outAll.toList := fun h => (hout' t h).2 htU + have htL : t ∉ localIn'.toList := fun h => + (List.nodup_append.mp hLUn).2.2 t h t htU rfl + have hmerge : (mergeSorted localIn' #[t]).toList.Perm (localIn'.toList ++ [t]) := + mergeSorted_perm _ _ + have hUe : ∀ x ∈ Un.erase t, x ∈ Un := fun x hx => List.erase_subset hx + have preA : ∀ (tbX : CTable) memoX, E.TabOK g.toList I.toList tbX → E.MemoOK memoX → + E.NodePre g I O phi0 outAll (mergeSorted localIn' #[t]) ((open_.map (·.1)).erase t) + tbX memoX := by + intro tbX memoX htX hmX + refine { ctx := pre.ctx, phi0 := pre.phi0, outO := pre.outO, outM := pre.outM, + outI := pre.outI, locG := ?_, undG := ?_, nodup := ?_, outLU := ?_, + cover := ?_, tab := htX, memo := hmX, + locSorted := mergeSorted_strict hL's (by simp) + (fun x hx hxt => htL (by simp at hxt; rw [← hxt]; exact hx)) } + · intro x hx + rcases List.mem_append.mp (hmerge.mem_iff.mp hx) with h | h + · exact hL'g x h + · rw [List.mem_singleton] at h; rw [h]; exact htg + · intro x hx; rw [hund2] at hx; exact hUng x (hUe x hx) + · rw [hund2] + refine ((hmerge.append_right _).trans ?_).nodup_iff.mpr hLUn + rw [List.append_assoc] + exact List.Perm.append_left _ (List.perm_cons_erase htU).symm + · intro x hx + refine ⟨fun h => ?_, fun h => ?_⟩ + · rcases List.mem_append.mp (hmerge.mem_iff.mp h) with h | h + · exact (hout' x hx).1 h + · rw [List.mem_singleton] at h; rw [h] at hx; exact htout hx + · rw [hund2] at h; exact (hout' x hx).2 (hUe x h) + · intro x hx + rcases hcov' x hx with h | h | h + · exact Or.inl (hmerge.mem_iff.mpr (List.mem_append_left _ h)) + · by_cases hxt : x = t + · exact Or.inl (hmerge.mem_iff.mpr (List.mem_append_right _ (by simp [hxt]))) + · exact Or.inr (Or.inl (by rw [hund2]; exact (List.mem_erase_of_ne hxt).mpr h)) + · exact Or.inr (Or.inr h) + have preB : ∀ (tbX : CTable) memoX, E.TabOK g.toList I.toList tbX → E.MemoOK memoX → + E.NodePre g I O phi0 (outAll.push t) localIn' ((open_.map (·.1)).erase t) + tbX memoX := by + intro tbX memoX htX hmX + have hpush : (outAll.push t).toList = outAll.toList ++ [t] := Array.toList_push + refine { ctx := pre.ctx, phi0 := pre.phi0, outO := ?_, outM := ?_, outI := ?_, + locG := hL'g, undG := ?_, nodup := ?_, outLU := ?_, cover := ?_, + tab := htX, memo := hmX, locSorted := hL's } + · intro x hx; rw [hpush]; exact List.mem_append_left _ (pre.outO x hx) + · intro x hx + rw [hpush, List.mem_append, List.mem_singleton] at hx + rcases hx with h | h + · exact pre.outM x h + · rw [h]; exact (hgf t htg).1 + · intro x hx + rw [hpush, List.mem_append, List.mem_singleton] at hx + rcases hx with h | h + · exact pre.outI x h + · rw [h]; exact (hgf t htg).2.2.1 + · intro x hx; rw [hund2] at hx; exact hUng x (hUe x hx) + · rw [hund2] + exact List.Nodup.sublist (List.Sublist.append_left List.erase_sublist _) hLUn + · intro x hx + rw [hpush, List.mem_append, List.mem_singleton] at hx + rw [hund2] + rcases hx with h | h + · exact ⟨(hout' x h).1, fun h' => (hout' x h).2 (hUe x h')⟩ + · rw [h]; exact ⟨htL, hUnn.not_mem_erase⟩ + · intro x hx + rw [hpush, hund2] + rcases hcov' x hx with h | h | h + · exact Or.inl h + · by_cases hxt : x = t + · exact Or.inr (Or.inr (by simp [hxt])) + · exact Or.inr (Or.inl ((List.mem_erase_of_ne hxt).mpr h)) + · exact Or.inr (Or.inr (List.mem_append_left _ h)) + have hcase : ∀ Y, E.Cons Y (I.toList ++ localIn.toList) outAll.toList → + E.Cons Y (I.toList ++ (mergeSorted localIn' #[t]).toList) outAll.toList ∨ + E.Cons Y (I.toList ++ localIn'.toList) (outAll.push t).toList := by + intro Y hY + have hY' := hforce Y hY + by_cases htY : t ∈ Y + · left + refine ⟨hY'.1, fun x hx => ?_, hY'.2.2⟩ + rcases List.mem_append.mp hx with h | h + · exact hY'.2.1 x (List.mem_append_left _ h) + · rcases List.mem_append.mp (hmerge.mem_iff.mp h) with h | h + · exact hY'.2.1 x (List.mem_append_right _ h) + · rw [List.mem_singleton] at h; rw [h]; exact htY + · right + refine ⟨hY'.1, hY'.2.1, fun x hx => ?_⟩ + rw [Array.toList_push, List.mem_append, List.mem_singleton] at hx + rcases hx with h | h + · exact hY'.2.2 x h + · rw [h]; exact htY + have hpre0 := pre.memo + rw [← hm1] at hpre0 + split at h + · -- stored first + obtain ⟨⟨tb1, st4⟩, h1, h⟩ := bind_eq_ok h + obtain ⟨tA, iA, cA, mA⟩ := hnode g I O phi0 outAll nOut _ _ tb st1 tb1 st4 h1 + (preA tb st1.memo pre.tab hpre0) + obtain ⟨tB, iB, cB, mB⟩ := hnode g I O phi0 (outAll.push t) nOut localIn' _ tb1 st4 tb' st' + h (preB tb1 st4.memo tA mA) + refine ⟨tB, improvesT_trans iA iB, fun Y hY => ?_, mB⟩ + rcases hcase Y hY with hA | hB + · exact (cA Y hA).mono iB + · exact cB Y hB + · -- unstored first + obtain ⟨⟨tb1, st4⟩, h1, h⟩ := bind_eq_ok h + obtain ⟨tB, iB, cB, mB⟩ := hnode g I O phi0 (outAll.push t) nOut localIn' _ tb st1 tb1 st4 + h1 (preB tb st1.memo pre.tab hpre0) + obtain ⟨tA, iA, cA, mA⟩ := hnode g I O phi0 outAll nOut _ _ tb1 st4 tb' st' h + (preA tb1 st4.memo tB mB) + refine ⟨tA, improvesT_trans iB iA, fun Y hY => ?_, mA⟩ + rcases hcase Y hY with hA | hB + · exact cA Y hA + · exact (cB Y hB).mono iA + · rename_i x hx + exfalso + have hne : open_.toList ≠ [] := by + intro hnil + apply hemp + rw [Array.isEmpty_iff] + apply Array.ext' + simp [hnil] + obtain ⟨⟨t, gt⟩, hpb⟩ := Option.ne_none_iff_exists'.mp (pickBranch_isSome hne) + exact hx t gt hpb + next => cases h + +/-! ## The search invariant -/ + +/-- **The search invariant** (all four functions, every fuel). -/ +theorem Env.search_spec {E : Env} (hE : E.WF) (limits : Limits) : + ∀ fuel, E.SolvePSpec limits fuel ∧ E.SolveBodySpec limits fuel ∧ E.NodePSpec limits fuel ∧ + E.SplitPSpec limits fuel := by + intro fuel + induction fuel with + | zero => exact E.specs_zero limits + | succ fuel ih => + obtain ⟨hs, hb, hn, hp⟩ := ih + exact ⟨E.solveP_step hE hb, E.solveBody_step hE hn, E.nodeP_step hE hn hp, + E.splitP_step hE hs hp⟩ + +theorem Env.memoOK_empty (E : Env) : E.MemoOK {} := by + intro g ent tb h + simp at h + +theorem toList_eq_nil_of_sub_empty {a : Array Nat} (h : ∀ t ∈ a.toList, t ∈ (#[] : Array Nat).toList) : + a.toList = [] := by + apply List.eq_nil_iff_forall_not_mem.mpr + intro t ht + simpa using h t ht + +/-- **The component's table.** The table the search returns for a component +is valid (every entry a duplicate-free set of members with its exact `Δ` from +nothing stored), and for every minimum it has an entry at the minimum's count +of the component, at most the minimum's `Δ`. -/ +theorem Env.component_table {E : Env} (hE : E.WF) {limits : Limits} {fuel : Nat} {st0 : SState} + {tb : CTable} {st : SState} + (h : E.cx.solveP limits fuel E.cx.members #[] #[] st0 = .ok (tb, st)) (hm0 : st0.memo = {}) : + E.TabOK E.cx.members.toList [] tb ∧ + ∀ Y, IsMinimum E.dag E.w E.roots Y → + HasAtT tb (partOf Y E.cx.members.toList).length (E.delta [] (partOf Y E.cx.members.toList)) + (partOf Y E.cx.members.toList) := by + obtain ⟨_, I, O, hI, hO, _, htab, hcov⟩ := (E.search_spec hE limits fuel).1 E.cx.members #[] #[] st0 + tb st h (fun t ht => by simp at ht) (fun t ht => by simp at ht) (fun t ht => by simp at ht) + (by rw [hm0]; exact E.memoOK_empty) + have hIn := toList_eq_nil_of_sub_empty hI + have hOn := toList_eq_nil_of_sub_empty hO + rw [hIn] at htab hcov + rw [hOn] at hcov + refine ⟨htab, fun Y hY => hcov Y ⟨hY, fun t ht => by simp at ht, fun t ht => by simp at ht⟩⟩ + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformTables.lean b/Ix/Compile/Verify/UniformTables.lean new file mode 100644 index 000000000..016013bc0 --- /dev/null +++ b/Ix/Compile/Verify/UniformTables.lean @@ -0,0 +1,765 @@ +import Ix.Compile.Verify.UniformTies + +/-! +# Stage 4: the search tables + +Count-indexed tables of `(Δ, set)` entries: what `add`, `best`, `trim`, +`conv` and folds of `add` keep and produce. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact +open Ix.Compile.Verify.SharingExact (setBang_getElem!) + +/-- A table entry. -/ +abbrev Entry := _root_.Int × Array Nat + +/-- `tb` has an entry at count `k` of value at most `v`. -/ +def HasAt (tb : CTable) (k : Nat) (v : _root_.Int) : Prop := ∃ e, tb[k]! = some e ∧ e.1 ≤ v + +/-- Every entry of `tb` lies at its count and satisfies `P`. -/ +def Entries (tb : CTable) (P : Entry → Prop) : Prop := + ∀ k e, tb[k]! = some e → e.2.size = k ∧ P e + +/-- `tb'` has an entry at least as good at every count where `tb` has one. -/ +def Improves (tb tb' : CTable) : Prop := ∀ k e, tb[k]! = some e → HasAt tb' k e.1 + +theorem improves_refl (tb : CTable) : Improves tb tb := fun _ e h => ⟨e, h, Int.le_refl _⟩ + +theorem improves_trans {a b c : CTable} (h1 : Improves a b) (h2 : Improves b c) : Improves a c := by + intro k e he + obtain ⟨e', he', hle⟩ := h1 k e he + obtain ⟨e'', he'', hle'⟩ := h2 k e' he' + exact ⟨e'', he'', Int.le_trans hle' hle⟩ + +theorem HasAt.mono {a b : CTable} {k : Nat} {v : _root_.Int} (h : HasAt a k v) + (hi : Improves a b) : HasAt b k v := by + obtain ⟨e, he, hle⟩ := h + obtain ⟨e', he', hle'⟩ := hi k e he + exact ⟨e', he', Int.le_trans hle' hle⟩ + +theorem HasAt.weaken {a : CTable} {k : Nat} {v v' : _root_.Int} (h : HasAt a k v) (hv : v ≤ v') : + HasAt a k v' := by + obtain ⟨e, he, hle⟩ := h + exact ⟨e, he, Int.le_trans hle hv⟩ + +theorem getElem!_mem_toList {tb : CTable} {k : Nat} {e : Entry} (h : tb[k]! = some e) : + some e ∈ tb.toList := by + by_cases hk : k < tb.size + · rw [getElem!_pos tb k hk] at h + rw [← h] + exact Array.mem_toList_iff.mpr (Array.getElem_mem hk) + · simp [hk] at h + +theorem mem_toList_getElem! {tb : CTable} {e : Entry} (h : some e ∈ tb.toList) : + ∃ k : Nat, tb[k]! = some e := by + obtain ⟨k, hk, he⟩ := List.mem_iff_getElem.mp h + simp only [Array.length_toList] at hk + refine ⟨k, ?_⟩ + rw [getElem!_pos tb k hk] + simpa using he + +theorem Entries.mem {tb : CTable} {P : Entry → Prop} (h : Entries tb P) {e : Entry} + (he : some e ∈ tb.toList) : P e := by + obtain ⟨k, hk⟩ := mem_toList_getElem! he + exact (h k e hk).2 + +theorem Entries.imp {tb : CTable} {P Q : Entry → Prop} (h : Entries tb P) (hPQ : ∀ e, P e → Q e) : + Entries tb Q := fun k e he => ⟨(h k e he).1, hPQ e (h k e he).2⟩ + +/-! ## Adding an entry -/ + +theorem ext_getElem! (tb : CTable) (m j : Nat) : + (tb ++ Array.replicate m none)[j]! = tb[j]! := by + by_cases hj : j < tb.size + · rw [getElem!_pos _ j (by simp; omega), getElem!_pos tb j hj, Array.getElem_append_left hj] + · by_cases hj' : j < tb.size + m + · rw [getElem!_pos _ j (by simp; omega), Array.getElem_append_right (by omega)] + simp [hj] + rfl + · simp [hj, hj'] + +theorem add_getElem! (tb : CTable) (e : Entry) (j : Nat) : + (tb.add e)[j]! = if j = e.2.size ∧ betterEntry e tb[e.2.size]! = true then some e else tb[j]! := by + unfold CTable.add + simp only + generalize hext : (if tb.size ≤ e.2.size then tb ++ Array.replicate (e.2.size + 1 - tb.size) none + else tb) = tb1 + have hget : ∀ j : Nat, tb1[j]! = tb[j]! := by + intro j; rw [← hext]; split + · exact ext_getElem! _ _ _ + · rfl + have hsz : e.2.size < tb1.size := by + rw [← hext]; split + · simp; omega + · omega + rw [hget] + by_cases hb : betterEntry e tb[e.2.size]! = true + · rw [if_pos hb, setBang_getElem!] + by_cases hj : j = e.2.size + · subst hj; simp [hsz, hb] + · rw [if_neg (fun h => hj h.1.symm), if_neg (fun h => hj h.1), hget] + · rw [if_neg hb, if_neg (fun h => hb h.2), hget] + +theorem add_hasAt (tb : CTable) (e : Entry) : HasAt (tb.add e) e.2.size e.1 := by + by_cases hb : betterEntry e tb[e.2.size]! = true + · exact ⟨e, by rw [add_getElem!, if_pos ⟨rfl, hb⟩], Int.le_refl _⟩ + · have hget : (tb.add e)[e.2.size]! = tb[e.2.size]! := by + rw [add_getElem!, if_neg (fun h => hb h.2)] + rw [Bool.not_eq_true] at hb + cases ho : tb[e.2.size]! with + | none => rw [ho] at hb; simp [betterEntry] at hb + | some x => + rw [ho] at hb + simp only [betterEntry, Bool.or_eq_false_iff, decide_eq_false_iff_not, Bool.and_eq_false_imp, + beq_iff_eq] at hb + refine ⟨x, by rw [hget, ho], ?_⟩ + omega + +theorem add_improves (tb : CTable) (e : Entry) : Improves tb (tb.add e) := by + intro j x hx + by_cases hj : j = e.2.size ∧ betterEntry e tb[e.2.size]! = true + · obtain ⟨rfl, hb⟩ := hj + refine ⟨e, by rw [add_getElem!, if_pos ⟨rfl, hb⟩], ?_⟩ + rw [hx] at hb + simp only [betterEntry, Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq] at hb + omega + · exact ⟨x, by rw [add_getElem!, if_neg hj, hx], Int.le_refl _⟩ + +theorem add_entries {tb : CTable} {P : Entry → Prop} (h : Entries tb P) {e : Entry} (he : P e) : + Entries (tb.add e) P := by + intro j x hx + rw [add_getElem!] at hx + split at hx + · rename_i hj; cases hx; exact ⟨hj.1.symm, he⟩ + · exact h j x hx + +/-! ## Folds of improving steps -/ + +theorem foldl_improves {α : Type} (f : CTable → α → CTable) (hf : ∀ acc x, Improves acc (f acc x)) : + ∀ (l : List α) (acc : CTable), Improves acc (l.foldl f acc) + | [], acc => improves_refl acc + | x :: xs, acc => improves_trans (hf acc x) (foldl_improves f hf xs (f acc x)) + +theorem foldl_hasAt {α : Type} (f : CTable → α → CTable) (hf : ∀ acc x, Improves acc (f acc x)) + {l : List α} {x : α} (hx : x ∈ l) {k : Nat} {v : _root_.Int} + (hstep : ∀ acc, HasAt (f acc x) k v) (acc : CTable) : HasAt (l.foldl f acc) k v := by + induction l generalizing acc with + | nil => exact absurd hx List.not_mem_nil + | cons y ys ih => + rw [List.foldl_cons] + rcases List.mem_cons.mp hx with rfl | hx + · exact (hstep acc).mono (foldl_improves f hf ys _) + · exact ih hx _ + +theorem foldl_entries {α : Type} (f : CTable → α → CTable) {P : Entry → Prop} {Q : α → Prop} + (hf : ∀ acc x, Q x → Entries acc P → Entries (f acc x) P) : + ∀ (l : List α) (acc : CTable), (∀ x ∈ l, Q x) → Entries acc P → Entries (l.foldl f acc) P + | [], _, _, h => h + | x :: xs, acc, hq, h => foldl_entries f hf xs _ (fun y hy => hq y (List.mem_cons_of_mem _ hy)) + (hf acc x (hq x List.mem_cons_self) h) + +/-- Adding the entries of `comb` to `tb`. -/ +def addAll (tb comb : CTable) : CTable := + comb.foldl (fun acc o => match o with + | some e => acc.add e + | none => acc) tb + +theorem addAll_step_improves (acc : CTable) (o : Option Entry) : + Improves acc (match o with + | some e => acc.add e + | none => acc) := by + cases o with + | none => exact improves_refl acc + | some e => exact add_improves acc e + +theorem addAll_improves (tb comb : CTable) : Improves tb (addAll tb comb) := by + unfold addAll + rw [← Array.foldl_toList] + exact foldl_improves _ addAll_step_improves _ _ + +theorem addAll_hasAt (tb comb : CTable) {e : Entry} (he : some e ∈ comb.toList) : + HasAt (addAll tb comb) e.2.size e.1 := by + unfold addAll + rw [← Array.foldl_toList] + exact foldl_hasAt _ addAll_step_improves he (fun acc => add_hasAt acc e) tb + +theorem addAll_entries {tb comb : CTable} {P : Entry → Prop} (h1 : Entries tb P) + (h2 : ∀ e, some e ∈ comb.toList → P e) : Entries (addAll tb comb) P := by + unfold addAll + rw [← Array.foldl_toList] + refine foldl_entries _ (Q := fun o => ∀ e, o = some e → P e) ?_ comb.toList tb ?_ h1 + · intro acc o hq hacc + cases o with + | none => exact hacc + | some e => exact add_entries hacc (hq e rfl) + · intro o ho e he + subst he + exact h2 _ ho + +/-! ## The best entry -/ + +/-- The step of `CTable.best`. -/ +def bestStep (acc : Option _root_.Int) (o : Option Entry) : Option _root_.Int := + match o, acc with + | none, _ => acc + | some (d, _), none => some d + | some (d, _), some b => some (min d b) + +theorem best_eq (tb : CTable) : tb.best = tb.toList.foldl bestStep none := by + unfold CTable.best + rw [← Array.foldl_toList] + rfl + +theorem bestFold_spec : ∀ (L : List (Option Entry)) (acc : Option _root_.Int), + (∀ e, some e ∈ L → ∃ b, L.foldl bestStep acc = some b ∧ b ≤ e.1) ∧ + (∀ a, acc = some a → ∃ b, L.foldl bestStep acc = some b ∧ b ≤ a) ∧ + (∀ b, L.foldl bestStep acc = some b → acc = some b ∨ ∃ e, some e ∈ L ∧ e.1 = b) + | [], acc => ⟨fun _ h => absurd h List.not_mem_nil, fun a h => ⟨a, h, Int.le_refl _⟩, + fun b h => Or.inl h⟩ + | o :: L, acc => by + obtain ⟨h1, h2, h3⟩ := bestFold_spec L (bestStep acc o) + rw [List.foldl_cons] + refine ⟨fun e he => ?_, fun a ha => ?_, fun b hb => ?_⟩ + · rcases List.mem_cons.mp he with rfl | he + · have : ∃ c, bestStep acc (some e) = some c ∧ c ≤ e.1 := by + obtain ⟨d, s⟩ := e + cases acc with + | none => exact ⟨d, rfl, Int.le_refl _⟩ + | some b => exact ⟨min d b, rfl, Int.min_le_left _ _⟩ + obtain ⟨c, hc, hce⟩ := this + obtain ⟨b, hb, hbc⟩ := h2 c hc + exact ⟨b, hb, Int.le_trans hbc hce⟩ + · exact h1 e he + · have : ∃ c, bestStep acc o = some c ∧ c ≤ a := by + subst ha + cases o with + | none => exact ⟨a, rfl, Int.le_refl _⟩ + | some e => obtain ⟨d, s⟩ := e; exact ⟨min d a, rfl, Int.min_le_right _ _⟩ + obtain ⟨c, hc, hca⟩ := this + obtain ⟨b, hb, hbc⟩ := h2 c hc + exact ⟨b, hb, Int.le_trans hbc hca⟩ + · rcases h3 b hb with h | ⟨e, he, heb⟩ + · cases o with + | none => exact Or.inl h + | some e => + obtain ⟨d, s⟩ := e + cases acc with + | none => + simp only [bestStep, Option.some.injEq] at h + exact Or.inr ⟨(d, s), List.mem_cons_self, h⟩ + | some a => + simp only [bestStep, Option.some.injEq] at h + rcases Int.le_total d a with hda | hda + · rw [Int.min_eq_left hda] at h + exact Or.inr ⟨(d, s), List.mem_cons_self, h⟩ + · rw [Int.min_eq_right hda] at h + exact Or.inl (by rw [h]) + · exact Or.inr ⟨e, List.mem_cons_of_mem _ he, heb⟩ + +theorem best_le {tb : CTable} {b : _root_.Int} (hb : tb.best = some b) {k : Nat} {e : Entry} + (he : tb[k]! = some e) : b ≤ e.1 := by + rw [best_eq] at hb + obtain ⟨b', hb', hle⟩ := (bestFold_spec tb.toList none).1 e (getElem!_mem_toList he) + rw [hb] at hb' + cases hb' + exact hle + +theorem best_attained {tb : CTable} {b : _root_.Int} (hb : tb.best = some b) : + ∃ (k : Nat) (e : Entry), tb[k]! = some e ∧ e.1 = b := by + rw [best_eq] at hb + rcases (bestFold_spec tb.toList none).2.2 b hb with h | ⟨e, he, heb⟩ + · cases h + · obtain ⟨k, hk⟩ := mem_toList_getElem! he + exact ⟨k, e, hk, heb⟩ + +theorem best_isSome {tb : CTable} {k : Nat} {e : Entry} (he : tb[k]! = some e) : + ∃ b, tb.best = some b := by + rw [best_eq] + obtain ⟨b, hb, _⟩ := (bestFold_spec tb.toList none).1 e (getElem!_mem_toList he) + exact ⟨b, hb⟩ + +/-! ## Trimming -/ + +theorem trim_getElem! (tb : CTable) (s : Nat) (k : Nat) : + (tb.trim s)[k]! = match tb.best with + | none => tb[k]! + | some b => match (tb[k]! : Option Entry) with + | some (e : Entry) => if e.1 > b + (s : _root_.Int) then none else some e + | none => none := by + unfold CTable.trim + cases hb : tb.best with + | none => rfl + | some b => + simp only + by_cases hk : k < tb.size + · rw [getElem!_pos _ k (by simp; exact hk), getElem!_pos tb k hk, Array.getElem_map] + cases tb[k] with + | none => rfl + | some e => obtain ⟨d, s'⟩ := e; rfl + · simp [hk] + rfl + +theorem trim_entries {tb : CTable} {P : Entry → Prop} (h : Entries tb P) (s : Nat) : + Entries (tb.trim s) P := by + intro k e he + rw [trim_getElem!] at he + cases hb : tb.best with + | none => rw [hb] at he; exact h k e he + | some b => + rw [hb] at he + simp only at he + cases hk : tb[k]! with + | none => rw [hk] at he; cases he + | some x => + rw [hk] at he + simp only at he + split at he + · cases he + · exact (Option.some.inj he) ▸ h k x hk + +theorem trim_hasAt {tb : CTable} {s k : Nat} {v : _root_.Int} (h : HasAt tb k v) + (hv : ∀ b, tb.best = some b → v ≤ b + (s : _root_.Int)) : HasAt (tb.trim s) k v := by + obtain ⟨e, he, hle⟩ := h + refine ⟨e, ?_, hle⟩ + rw [trim_getElem!] + cases hb : tb.best with + | none => exact he + | some b => + simp only + rw [he] + simp only + have := hv b hb + rw [if_neg (by omega)] + +/-! ## Convolution -/ + +theorem mergeSorted_size (a b : Array Nat) : (mergeSorted a b).size = a.size + b.size := by + rw [← Array.length_toList, (mergeSorted_perm a b).length_eq] + simp + +/-- The inner step of `CTable.conv`. -/ +def convIn (da : _root_.Int) (sa : Array Nat) (out : CTable) (ob : Option Entry) : CTable := + match ob with + | none => out + | some (db, sb) => out.add (da + db, mergeSorted sa sb) + +/-- The outer step of `CTable.conv`. -/ +def convOut (b : CTable) (out : CTable) (oa : Option Entry) : CTable := + match oa with + | none => out + | some (da, sa) => b.toList.foldl (convIn da sa) out + +theorem conv_eq (a b : CTable) : a.conv b = a.toList.foldl (convOut b) #[] := by + unfold CTable.conv + rw [← Array.foldl_toList] + congr 1 + funext out oa + cases oa with + | none => rfl + | some e => + obtain ⟨da, sa⟩ := e + simp only [convOut] + rw [← Array.foldl_toList] + rfl + +theorem convIn_improves (da : _root_.Int) (sa : Array Nat) (out : CTable) (ob : Option Entry) : + Improves out (convIn da sa out ob) := by + cases ob with + | none => exact improves_refl out + | some e => obtain ⟨db, sb⟩ := e; exact add_improves out _ + +theorem convOut_improves (b : CTable) (out : CTable) (oa : Option Entry) : + Improves out (convOut b out oa) := by + cases oa with + | none => exact improves_refl out + | some e => + obtain ⟨da, sa⟩ := e + exact foldl_improves _ (convIn_improves da sa) _ _ + +/-- **Convolution covers every pair of entries.** -/ +theorem conv_hasAt {a b : CTable} {ea eb : Entry} (ha : some ea ∈ a.toList) + (hb : some eb ∈ b.toList) : + HasAt (a.conv b) (ea.2.size + eb.2.size) (ea.1 + eb.1) := by + rw [conv_eq] + apply foldl_hasAt _ (convOut_improves b) ha _ #[] + intro acc + obtain ⟨da, sa⟩ := ea + simp only [convOut] + apply foldl_hasAt _ (convIn_improves da sa) hb _ acc + intro acc' + obtain ⟨db, sb⟩ := eb + simp only [convIn] + have := add_hasAt acc' (da + db, mergeSorted sa sb) + simp only [mergeSorted_size] at this + exact this + +/-- **Convolution entries are sums of pairs of entries.** -/ +theorem conv_entries {a b : CTable} {Pa Pb : Entry → Prop} (ha : ∀ e, some e ∈ a.toList → Pa e) + (hb : ∀ e, some e ∈ b.toList → Pb e) : + Entries (a.conv b) (fun e => ∃ ea eb, Pa ea ∧ Pb eb ∧ + e = (ea.1 + eb.1, mergeSorted ea.2 eb.2)) := by + rw [conv_eq] + refine foldl_entries _ (Q := fun o => ∀ e, o = some e → Pa e) ?_ a.toList #[] ?_ ?_ + · intro acc oa hq hacc + cases oa with + | none => exact hacc + | some ea => + obtain ⟨da, sa⟩ := ea + have hPa := hq (da, sa) rfl + simp only [convOut] + refine foldl_entries _ (Q := fun o => ∀ e, o = some e → Pb e) ?_ b.toList acc ?_ hacc + · intro acc' ob hq' hacc' + cases ob with + | none => exact hacc' + | some eb => + obtain ⟨db, sb⟩ := eb + exact add_entries hacc' ⟨(da, sa), (db, sb), hPa, hq' (db, sb) rfl, rfl⟩ + · intro ob hob e he + subst he + exact hb _ hob + · intro oa hoa e he + subst he + exact ha _ hoa + · intro k e he + simp at he + +/-! ## Tables with the tie order -/ + +/-- `e` is at least as good as `e'`: a smaller `Δ`, or the same and an earlier +or equal set. -/ +def TLe (e e' : Entry) : Prop := e.1 < e'.1 ∨ (e.1 = e'.1 ∧ LeL e.2.toList e'.2.toList) + +/-- `tb` has an entry at count `k` at least as good as `(v, S)`. -/ +def HasAtT (tb : CTable) (k : Nat) (v : _root_.Int) (S : List Nat) : Prop := + ∃ e, tb[k]! = some e ∧ (e.1 < v ∨ (e.1 = v ∧ LeL e.2.toList S)) + +/-- `tb'` has an entry at least as good at every count where `tb` has one. -/ +def ImprovesT (tb tb' : CTable) : Prop := + ∀ (k : Nat) (e : Entry), tb[k]! = some e → ∃ e', tb'[k]! = some e' ∧ TLe e' e + +/-- Every entry's set is strictly increasing. -/ +def SortedT (tb : CTable) : Prop := ∀ (k : Nat) (e : Entry), tb[k]! = some e → e.2.toList.Pairwise (· < ·) + +theorem tle_refl (e : Entry) : TLe e e := Or.inr ⟨rfl, leL_refl _⟩ + +theorem tle_trans {a b c : Entry} (h1 : TLe a b) (h2 : TLe b c) : TLe a c := by + rcases h1 with h1 | ⟨h1, h1'⟩ <;> rcases h2 with h2 | ⟨h2, h2'⟩ + · exact Or.inl (Int.lt_trans h1 h2) + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inr ⟨by omega, leL_trans h1' h2'⟩ + +theorem improvesT_refl (tb : CTable) : ImprovesT tb tb := fun _ e h => ⟨e, h, tle_refl e⟩ + +theorem improvesT_trans {a b c : CTable} (h1 : ImprovesT a b) (h2 : ImprovesT b c) : + ImprovesT a c := by + intro k e he + obtain ⟨e', he', h⟩ := h1 k e he + obtain ⟨e'', he'', h'⟩ := h2 k e' he' + exact ⟨e'', he'', tle_trans h' h⟩ + +theorem HasAtT.mono {a b : CTable} {k : Nat} {v : _root_.Int} {S : List Nat} (h : HasAtT a k v S) + (hi : ImprovesT a b) : HasAtT b k v S := by + obtain ⟨e, he, hv⟩ := h + obtain ⟨e', he', hle⟩ := hi k e he + refine ⟨e', he', ?_⟩ + rcases hle with hle | ⟨hle, hle'⟩ <;> rcases hv with hv | ⟨hv, hv'⟩ + · exact Or.inl (Int.lt_trans hle hv) + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inr ⟨by omega, leL_trans hle' hv'⟩ + +theorem HasAtT.congr {tb : CTable} {k : Nat} {v : _root_.Int} {S S' : List Nat} (h : HasAtT tb k v S) + (hS : ∀ u, u ∈ S ↔ u ∈ S') : HasAtT tb k v S' := by + obtain ⟨e, he, hv⟩ := h + refine ⟨e, he, ?_⟩ + rcases hv with hv | ⟨hv, hv'⟩ + · exact Or.inl hv + · exact Or.inr ⟨hv, leL_congr (fun _ => Iff.rfl) hS hv'⟩ + +theorem HasAtT.weakenT {tb : CTable} {k : Nat} {v v' : _root_.Int} {S S' : List Nat} + (h : HasAtT tb k v S) (hv : v < v' ∨ (v = v' ∧ LeL S S')) : HasAtT tb k v' S' := by + obtain ⟨e, he, hgood⟩ := h + refine ⟨e, he, ?_⟩ + rcases hgood with h1 | ⟨h1, h1'⟩ <;> rcases hv with h2 | ⟨h2, h2'⟩ + · exact Or.inl (Int.lt_trans h1 h2) + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inr ⟨by omega, leL_trans h1' h2'⟩ + +theorem HasAtT.toHasAt {tb : CTable} {k : Nat} {v : _root_.Int} {S : List Nat} (h : HasAtT tb k v S) : + HasAt tb k v := by + obtain ⟨e, he, hv⟩ := h + exact ⟨e, he, by rcases hv with hv | ⟨hv, _⟩ <;> omega⟩ + +theorem HasAtT.of_tle {tb : CTable} {k : Nat} {e : Entry} (he : tb[k]! = some e) {v : _root_.Int} + {S : List Nat} (hv : e.1 < v ∨ (e.1 = v ∧ LeL e.2.toList S)) : HasAtT tb k v S := + ⟨e, he, hv⟩ + +/-- An entry at least as good as `(v, S)` stays so under a no-worse entry. -/ +theorem tle_good {e' e : Entry} {v : _root_.Int} {S : List Nat} (h : TLe e' e) + (hv : e.1 < v ∨ (e.1 = v ∧ LeL e.2.toList S)) : e'.1 < v ∨ (e'.1 = v ∧ LeL e'.2.toList S) := by + rcases h with h | ⟨h, h'⟩ <;> rcases hv with hv | ⟨hv, hv'⟩ + · exact Or.inl (Int.lt_trans h hv) + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inr ⟨by omega, leL_trans h' hv'⟩ + +/-- `betterEntry` decides the tie order on sorted sets. -/ +theorem better_tle {e : Entry} {o : Entry} (he : e.2.toList.Pairwise (· < ·)) + (ho : o.2.toList.Pairwise (· < ·)) : + (betterEntry e (some o) = true → TLe e o) ∧ (betterEntry e (some o) = false → TLe o e) := by + obtain ⟨d, s⟩ := e + obtain ⟨d0, s0⟩ := o + simp only [betterEntry] + constructor + · intro h + simp only [Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq] at h + rcases h with h | ⟨h, h'⟩ + · exact Or.inl h + · exact Or.inr ⟨h, Or.inr ((setPrec_iff he ho).mp h')⟩ + · intro h + simp only [Bool.or_eq_false_iff, decide_eq_false_iff_not, Bool.and_eq_false_imp, beq_iff_eq] at h + obtain ⟨h1, h2⟩ := h + by_cases hd : d = d0 + · have hns := h2 hd + refine Or.inr ⟨hd.symm, ?_⟩ + rcases leL_total ho he with h | h + · exact h + · exact absurd ((setPrec_iff he ho).mpr h) (by simp [hns]) + · exact Or.inl (by simp only at h1 hd ⊢; omega) + +theorem add_improvesT {tb : CTable} {e : Entry} (hs : SortedT tb) (he : e.2.toList.Pairwise (· < ·)) : + ImprovesT tb (tb.add e) := by + intro j x hx + by_cases hj : j = e.2.size ∧ betterEntry e tb[e.2.size]! = true + · obtain ⟨rfl, hb⟩ := hj + refine ⟨e, by rw [add_getElem!, if_pos ⟨rfl, hb⟩], ?_⟩ + rw [hx] at hb + exact (better_tle he (hs _ x hx)).1 hb + · exact ⟨x, by rw [add_getElem!, if_neg hj, hx], tle_refl x⟩ + +theorem add_hasAtT {tb : CTable} {e : Entry} (hs : SortedT tb) (he : e.2.toList.Pairwise (· < ·)) : + HasAtT (tb.add e) e.2.size e.1 e.2.toList := by + by_cases hb : betterEntry e tb[e.2.size]! = true + · exact ⟨e, by rw [add_getElem!, if_pos ⟨rfl, hb⟩], Or.inr ⟨rfl, leL_refl _⟩⟩ + · have hget : (tb.add e)[e.2.size]! = tb[e.2.size]! := by + rw [add_getElem!, if_neg (fun h => hb h.2)] + cases ho : tb[e.2.size]! with + | none => rw [ho] at hb; simp [betterEntry] at hb + | some x => + rw [ho] at hb + have := (better_tle he (hs _ x ho)).2 (by simpa using hb) + exact ⟨x, by rw [hget, ho], tle_good this (Or.inr ⟨rfl, leL_refl _⟩)⟩ + +theorem add_sortedT {tb : CTable} {e : Entry} (hs : SortedT tb) (he : e.2.toList.Pairwise (· < ·)) : + SortedT (tb.add e) := by + intro j x hx + rw [add_getElem!] at hx + split at hx + · cases hx; exact he + · exact hs j x hx + +theorem foldl_improvesT_inv {α : Type} (f : CTable → α → CTable) (Inv : CTable → Prop) + (hinv : ∀ acc x, Inv acc → Inv (f acc x)) (hf : ∀ acc x, Inv acc → ImprovesT acc (f acc x)) : + ∀ (l : List α) (acc : CTable), Inv acc → ImprovesT acc (l.foldl f acc) + | [], acc, _ => improvesT_refl acc + | x :: xs, acc, h => improvesT_trans (hf acc x h) + (foldl_improvesT_inv f Inv hinv hf xs (f acc x) (hinv acc x h)) + +theorem foldl_inv {α : Type} (f : CTable → α → CTable) (Inv : CTable → Prop) + (hinv : ∀ acc x, Inv acc → Inv (f acc x)) : + ∀ (l : List α) (acc : CTable), Inv acc → Inv (l.foldl f acc) + | [], _, h => h + | x :: xs, acc, h => foldl_inv f Inv hinv xs _ (hinv acc x h) + +theorem foldl_hasAtT_inv {α : Type} (f : CTable → α → CTable) (Inv : CTable → Prop) + (hinv : ∀ acc x, Inv acc → Inv (f acc x)) (hf : ∀ acc x, Inv acc → ImprovesT acc (f acc x)) + {l : List α} {x : α} (hx : x ∈ l) (k : Nat) (v : _root_.Int) (S : List Nat) (acc : CTable) + (hacc : Inv acc) (hstep : ∀ acc, Inv acc → HasAtT (f acc x) k v S) : + HasAtT (l.foldl f acc) k v S := by + induction l generalizing acc with + | nil => exact absurd hx List.not_mem_nil + | cons y ys ih => + rw [List.foldl_cons] + rcases List.mem_cons.mp hx with rfl | hx + · exact (hstep acc hacc).mono (foldl_improvesT_inv f Inv hinv hf ys _ (hinv acc _ hacc)) + · exact ih hx _ (hinv acc y hacc) + +/-- The step of `addAll`. -/ +def addStep (acc : CTable) (o : Option Entry) : CTable := + match o with + | some e => acc.add e + | none => acc + +theorem addAll_eq (tb comb : CTable) : addAll tb comb = comb.toList.foldl addStep tb := by + unfold addAll; rw [← Array.foldl_toList]; rfl + +theorem addAll_tie {tb comb : CTable} (h1 : SortedT tb) + (h2 : ∀ e, some e ∈ comb.toList → e.2.toList.Pairwise (· < ·)) : + SortedT (addAll tb comb) ∧ ImprovesT tb (addAll tb comb) ∧ + ∀ e, some e ∈ comb.toList → HasAtT (addAll tb comb) e.2.size e.1 e.2.toList := by + rw [addAll_eq] + let Inv : CTable → Prop := SortedT + have hinv : ∀ acc (o : Option Entry), o ∈ comb.toList → Inv acc → Inv (addStep acc o) := by + intro acc o ho h + cases o with + | none => exact h + | some e => exact add_sortedT h (h2 e ho) + have key : ∀ (l : List (Option Entry)), (∀ o ∈ l, o ∈ comb.toList) → ∀ acc, Inv acc → + Inv (l.foldl addStep acc) ∧ ImprovesT acc (l.foldl addStep acc) ∧ + ∀ e, some e ∈ l → HasAtT (l.foldl addStep acc) e.2.size e.1 e.2.toList := by + intro l + induction l with + | nil => intro _ acc h; exact ⟨h, improvesT_refl _, fun e he => absurd he List.not_mem_nil⟩ + | cons o l ih => + intro hl acc h + rw [List.foldl_cons] + have hstep := hinv acc o (hl o List.mem_cons_self) h + obtain ⟨r1, r2, r3⟩ := ih (fun o' ho' => hl o' (List.mem_cons_of_mem _ ho')) _ hstep + have himp : ImprovesT acc (addStep acc o) := by + cases o with + | none => exact improvesT_refl _ + | some e => exact add_improvesT h (h2 e (hl _ List.mem_cons_self)) + refine ⟨r1, improvesT_trans himp r2, fun e he => ?_⟩ + rcases List.mem_cons.mp he with he | he + · subst he + exact (add_hasAtT h (h2 e (hl _ List.mem_cons_self))).mono r2 + · exact r3 e he + exact key comb.toList (fun o ho => ho) tb h1 + +theorem trim_tie {tb : CTable} (s : Nat) (hs : SortedT tb) : + SortedT (tb.trim s) ∧ ∀ {k : Nat} {v : _root_.Int} {S : List Nat}, HasAtT tb k v S → + (∀ b, tb.best = some b → v ≤ b + (s : _root_.Int)) → HasAtT (tb.trim s) k v S := by + have hsub : ∀ (k : Nat) (e : Entry), (tb.trim s)[k]! = some e → tb[k]! = some e := by + intro k e he + rw [trim_getElem!] at he + cases hb : tb.best with + | none => rw [hb] at he; exact he + | some b => + rw [hb] at he + simp only at he + cases hk : tb[k]! with + | none => rw [hk] at he; cases he + | some x => + rw [hk] at he + simp only at he + split at he + · cases he + · exact (Option.some.inj he) ▸ rfl + refine ⟨fun k e he => hs k e (hsub k e he), fun {k v S} h hv => ?_⟩ + obtain ⟨e, he, hgood⟩ := h + refine ⟨e, ?_, hgood⟩ + rw [trim_getElem!] + cases hb : tb.best with + | none => exact he + | some b => + simp only + rw [he] + simp only + have := hv b hb + rw [if_neg (by rcases hgood with h | ⟨h, _⟩ <;> omega)] + +theorem mergeSorted_strict {a b : Array Nat} (ha : a.toList.Pairwise (· < ·)) + (hb : b.toList.Pairwise (· < ·)) (hd : ∀ x ∈ a.toList, x ∉ b.toList) : + (mergeSorted a b).toList.Pairwise (· < ·) := by + have hn : (mergeSorted a b).toList.Nodup := + (mergeSorted_perm a b).nodup_iff.mpr (nodup_app (ha.imp Nat.ne_of_lt) (hb.imp Nat.ne_of_lt) hd) + have hle := mergeSorted_sorted a b + have : (mergeSorted a b).toList.Pairwise (fun x y => x ≤ y ∧ x ≠ y) := + List.Pairwise.and hle hn + exact this.imp (fun h => Nat.lt_of_le_of_ne h.1 h.2) + +/-- **Convolution with the tie order.** -/ +theorem conv_tie {a b : CTable} (ha : ∀ e, some e ∈ a.toList → e.2.toList.Pairwise (· < ·)) + (hb : ∀ e, some e ∈ b.toList → e.2.toList.Pairwise (· < ·)) + (hd : ∀ ea, some ea ∈ a.toList → ∀ eb, some eb ∈ b.toList → ∀ x ∈ ea.2.toList, x ∉ eb.2.toList) : + SortedT (a.conv b) ∧ ∀ ea, some ea ∈ a.toList → ∀ eb, some eb ∈ b.toList → + HasAtT (a.conv b) (ea.2.size + eb.2.size) (ea.1 + eb.1) (mergeSorted ea.2 eb.2).toList := by + rw [conv_eq] + -- the inner steps of one outer entry + have hin : ∀ (da : _root_.Int) (sa : Array Nat), some (da, sa) ∈ a.toList → ∀ acc (ob : Option Entry), + ob ∈ b.toList → SortedT acc → SortedT (convIn da sa acc ob) ∧ ImprovesT acc (convIn da sa acc ob) := by + intro da sa hsa acc ob hob hacc + cases ob with + | none => exact ⟨hacc, improvesT_refl _⟩ + | some eb => + obtain ⟨db, sb⟩ := eb + have hs := mergeSorted_strict (ha _ hsa) (hb _ hob) (hd _ hsa _ hob) + exact ⟨add_sortedT hacc hs, add_improvesT hacc hs⟩ + have hinner : ∀ (da : _root_.Int) (sa : Array Nat), some (da, sa) ∈ a.toList → + ∀ (l : List (Option Entry)), (∀ o ∈ l, o ∈ b.toList) → ∀ acc, SortedT acc → + SortedT (l.foldl (convIn da sa) acc) ∧ ImprovesT acc (l.foldl (convIn da sa) acc) := by + intro da sa hsa l + induction l with + | nil => intro _ acc h; exact ⟨h, improvesT_refl _⟩ + | cons o l ih => + intro hl acc h + rw [List.foldl_cons] + obtain ⟨h1, h2⟩ := hin da sa hsa acc o (hl o List.mem_cons_self) h + obtain ⟨h3, h4⟩ := ih (fun o' ho' => hl o' (List.mem_cons_of_mem _ ho')) _ h1 + exact ⟨h3, improvesT_trans h2 h4⟩ + have hout : ∀ acc (oa : Option Entry), oa ∈ a.toList → SortedT acc → + SortedT (convOut b acc oa) ∧ ImprovesT acc (convOut b acc oa) := by + intro acc oa hoa hacc + cases oa with + | none => exact ⟨hacc, improvesT_refl _⟩ + | some ea => + obtain ⟨da, sa⟩ := ea + exact hinner da sa hoa b.toList (fun o ho => ho) acc hacc + have houter : ∀ (l : List (Option Entry)), (∀ o ∈ l, o ∈ a.toList) → ∀ acc, SortedT acc → + SortedT (l.foldl (convOut b) acc) ∧ ImprovesT acc (l.foldl (convOut b) acc) := by + intro l + induction l with + | nil => intro _ acc h; exact ⟨h, improvesT_refl _⟩ + | cons o l ih => + intro hl acc h + rw [List.foldl_cons] + obtain ⟨h1, h2⟩ := hout acc o (hl o List.mem_cons_self) h + obtain ⟨h3, h4⟩ := ih (fun o' ho' => hl o' (List.mem_cons_of_mem _ ho')) _ h1 + exact ⟨h3, improvesT_trans h2 h4⟩ + have hsorted0 : SortedT (#[] : CTable) := fun k e he => by simp at he + refine ⟨(houter a.toList (fun o ho => ho) #[] hsorted0).1, fun ea hea eb heb => ?_⟩ + -- the pair's entry, then improvement by the rest + have key : ∀ (l : List (Option Entry)), (∀ o ∈ l, o ∈ a.toList) → some ea ∈ l → ∀ acc, SortedT acc → + HasAtT (l.foldl (convOut b) acc) (ea.2.size + eb.2.size) (ea.1 + eb.1) + (mergeSorted ea.2 eb.2).toList := by + intro l + induction l with + | nil => intro _ h; exact absurd h List.not_mem_nil + | cons o l ih => + intro hl hmem acc hacc + rw [List.foldl_cons] + obtain ⟨hs1, _⟩ := hout acc o (hl o List.mem_cons_self) hacc + rcases List.mem_cons.mp hmem with rfl | hmem + · have hrest := (houter l (fun o' ho' => hl o' (List.mem_cons_of_mem _ ho')) _ hs1).2 + refine HasAtT.mono ?_ hrest + obtain ⟨da, sa⟩ := ea + simp only [convOut] + -- inner: the pair's add, then the rest of the inner fold + have kin : ∀ (l' : List (Option Entry)), (∀ o ∈ l', o ∈ b.toList) → some eb ∈ l' → + ∀ acc', SortedT acc' → HasAtT (l'.foldl (convIn da sa) acc') ((da, sa).2.size + eb.2.size) + ((da, sa).1 + eb.1) (mergeSorted (da, sa).2 eb.2).toList := by + intro l' + induction l' with + | nil => intro _ h; exact absurd h List.not_mem_nil + | cons o' l' ih' => + intro hl' hmem' acc' hacc' + rw [List.foldl_cons] + obtain ⟨hs2, _⟩ := hin da sa hea acc' o' (hl' o' List.mem_cons_self) hacc' + rcases List.mem_cons.mp hmem' with rfl | hmem' + · have hrest' := (hinner da sa hea l' (fun o ho => hl' o (List.mem_cons_of_mem _ ho)) _ hs2).2 + refine HasAtT.mono ?_ hrest' + obtain ⟨db, sb⟩ := eb + have hs := mergeSorted_strict (ha _ hea) (hb _ heb) (hd _ hea _ heb) + have := add_hasAtT hacc' hs (e := (da + db, mergeSorted sa sb)) + simp only [mergeSorted_size] at this + exact this + · exact ih' (fun o ho => hl' o (List.mem_cons_of_mem _ ho)) hmem' _ hs2 + exact kin b.toList (fun o ho => ho) heb acc hacc + · exact ih (fun o' ho' => hl o' (List.mem_cons_of_mem _ ho')) hmem _ hs1 + exact key a.toList (fun o ho => ho) hea #[] hsorted0 + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformTies.lean b/Ix/Compile/Verify/UniformTies.lean new file mode 100644 index 000000000..822830c0d --- /dev/null +++ b/Ix/Compile/Verify/UniformTies.lean @@ -0,0 +1,210 @@ +import Ix.Compile.Verify.UniformRevisible + +/-! +# Stage 4: the tie order of sets + +`setPrec` on strictly increasing sets: `a` precedes `b` exactly when the +smallest term of their symmetric difference is in `b`. It is a strict total +order on such sets, and it is monotone under unions of sets from disjoint +universes. +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact + +/-- `z` is the first difference of `X` and `Y`, and it is in `Y`. -/ +def FirstIn (X Y : List Nat) (z : Nat) : Prop := + z ∈ Y ∧ z ∉ X ∧ ∀ u, u < z → (u ∈ X ↔ u ∈ Y) + +theorem lexLt_iff : ∀ (X Y : List Nat), X.Pairwise (· < ·) → Y.Pairwise (· < ·) → + (List.compareLex compareDesc X Y = .lt ↔ ∃ z, FirstIn X Y z) + | [], [], _, _ => by simp [List.compareLex_nil_nil, FirstIn] + | [], y :: ys, _, hY => by + rw [List.compareLex_nil_cons] + simp only [true_iff] + refine ⟨y, List.mem_cons_self, by simp, fun u hu => ?_⟩ + simp only [List.not_mem_nil, false_iff, List.mem_cons, not_or] + refine ⟨by omega, fun hm => ?_⟩ + have := (List.pairwise_cons.mp hY).1 u hm + omega + | x :: xs, [], _, _ => by + rw [List.compareLex_cons_nil] + simp [FirstIn] + | x :: xs, y :: ys, hX, hY => by + rw [List.compareLex_cons_cons] + have hXs := (List.pairwise_cons.mp hX) + have hYs := (List.pairwise_cons.mp hY) + rw [show compareDesc x y = compare y x from rfl] + rcases Nat.lt_trichotomy y x with hyx | rfl | hxy + · rw [Nat.compare_eq_lt.mpr hyx] + simp only [Ordering.lt_then, true_iff] + refine ⟨y, List.mem_cons_self, fun hm => ?_, fun u hu => ?_⟩ + · rcases List.mem_cons.mp hm with h | h + · omega + · have := hXs.1 y h; omega + · constructor + · intro hm + rcases List.mem_cons.mp hm with h | h + · omega + · have := hXs.1 u h; omega + · intro hm + rcases List.mem_cons.mp hm with h | h + · omega + · have := hYs.1 u h; omega + · rw [Nat.compare_eq_eq.mpr rfl, Ordering.eq_then, lexLt_iff xs ys hXs.2 hYs.2] + constructor + · rintro ⟨z, hz, hzx, hagree⟩ + refine ⟨z, List.mem_cons_of_mem _ hz, fun hm => ?_, fun u hu => ?_⟩ + · rcases List.mem_cons.mp hm with h | h + · have := hYs.1 z hz; omega + · exact hzx h + · simp only [List.mem_cons] + by_cases hux : u = y + · simp [hux] + · simp only [hux, false_or]; exact hagree u hu + · rintro ⟨z, hz, hzx, hagree⟩ + have hzy : z ≠ y := fun h => hzx (h ▸ List.mem_cons_self) + refine ⟨z, ?_, fun h => hzx (List.mem_cons_of_mem _ h), fun u hu => ?_⟩ + · rcases List.mem_cons.mp hz with h | h + · exact absurd h hzy + · exact h + · have := hagree u hu + simp only [List.mem_cons] at this + by_cases hux : u = y + · subst hux + constructor + · intro h; have := hXs.1 u h; omega + · intro h; have := hYs.1 u h; omega + · simpa [hux] using this + · rw [Nat.compare_eq_gt.mpr hxy] + simp only [Ordering.gt_then] + simp only [reduceCtorEq, false_iff, not_exists] + rintro z ⟨hz, hzx, hagree⟩ + have hyz : y ≤ z := by + rcases List.mem_cons.mp hz with h | h + · omega + · have := hYs.1 z h; omega + have := (hagree x (by omega)).mp List.mem_cons_self + rcases List.mem_cons.mp this with h | h + · omega + · have := hYs.1 x h; omega + +/-! ## The tie order on sorted sets -/ + +/-- `X` strictly precedes `Y`: the first difference is in `Y`. -/ +def PrecL (X Y : List Nat) : Prop := ∃ z, FirstIn X Y z + +/-- `X` precedes `Y` or has the same terms. -/ +def LeL (X Y : List Nat) : Prop := (∀ u, u ∈ X ↔ u ∈ Y) ∨ PrecL X Y + +/-- Sorted lists with the same terms are equal. -/ +theorem sorted_eq_of_mem {X Y : List Nat} (hX : X.Pairwise (· < ·)) (hY : Y.Pairwise (· < ·)) + (h : ∀ u, u ∈ X ↔ u ∈ Y) : X = Y := by + apply List.Perm.eq_of_pairwise (le := fun a b => a < b) (fun a b _ _ h1 h2 => by omega) hX hY + exact (List.perm_ext_iff_of_nodup (hX.imp Nat.ne_of_lt) (hY.imp Nat.ne_of_lt)).mpr h + +theorem precL_irrefl (X : List Nat) : ¬ PrecL X X := fun ⟨_, h1, h2, _⟩ => h2 h1 + +theorem precL_trans {X Y Z : List Nat} (h1 : PrecL X Y) (h2 : PrecL Y Z) : PrecL X Z := by + obtain ⟨a, haY, haX, hXY⟩ := h1 + obtain ⟨b, hbZ, hbY, hYZ⟩ := h2 + rcases Nat.lt_trichotomy a b with hab | rfl | hba + · refine ⟨a, (hYZ a hab).mp haY, haX, fun u hu => (hXY u hu).trans (hYZ u (by omega))⟩ + · exact absurd haY hbY + · refine ⟨b, hbZ, fun hbX => hbY ((hXY b hba).mp hbX), fun u hu => + (hXY u (by omega)).trans (hYZ u hu)⟩ + +theorem leL_refl (X : List Nat) : LeL X X := Or.inl fun _ => Iff.rfl + +/-- The tie order depends only on membership. -/ +theorem precL_congr {X X' Y Y' : List Nat} (hX : ∀ u, u ∈ X ↔ u ∈ X') (hY : ∀ u, u ∈ Y ↔ u ∈ Y') + (h : PrecL X Y) : PrecL X' Y' := by + obtain ⟨z, hzY, hzX, hag⟩ := h + exact ⟨z, (hY z).mp hzY, fun h => hzX ((hX z).mpr h), fun u hu => + ((hX u).symm.trans (hag u hu)).trans (hY u)⟩ + +theorem leL_trans {X Y Z : List Nat} (h1 : LeL X Y) (h2 : LeL Y Z) : LeL X Z := by + rcases h1 with h1 | h1 <;> rcases h2 with h2 | h2 + · exact Or.inl fun u => (h1 u).trans (h2 u) + · exact Or.inr (precL_congr (fun u => (h1 u).symm) (fun _ => Iff.rfl) h2) + · exact Or.inr (precL_congr (fun _ => Iff.rfl) h2 h1) + · exact Or.inr (precL_trans h1 h2) + +theorem leL_congr {X X' Y Y' : List Nat} (hX : ∀ u, u ∈ X ↔ u ∈ X') (hY : ∀ u, u ∈ Y ↔ u ∈ Y') + (h : LeL X Y) : LeL X' Y' := by + rcases h with h | h + · exact Or.inl fun u => ((hX u).symm.trans (h u)).trans (hY u) + · exact Or.inr (precL_congr hX hY h) + +/-- **The tie order is total** on sorted lists. -/ +theorem precL_total {X Y : List Nat} (hX : X.Pairwise (· < ·)) (hY : Y.Pairwise (· < ·)) + (hne : X ≠ Y) : PrecL X Y ∨ PrecL Y X := by + have hd : ∃ u, ¬ (u ∈ X ↔ u ∈ Y) := Classical.byContradiction fun h => by + apply hne + apply sorted_eq_of_mem hX hY + intro u + exact Classical.byContradiction fun hu => h ⟨u, hu⟩ + obtain ⟨z, hz, hmin⟩ := exists_min_nat (fun u => ¬ (u ∈ X ↔ u ∈ Y)) hd + have hagree : ∀ u, u < z → (u ∈ X ↔ u ∈ Y) := fun u hu => + Classical.byContradiction fun h => hmin u hu h + by_cases hzY : z ∈ Y + · left; exact ⟨z, hzY, fun hzX => hz ⟨fun _ => hzY, fun _ => hzX⟩, hagree⟩ + · right + have hzX : z ∈ X := Classical.byContradiction fun hzX => hz ⟨fun h => absurd h hzX, fun h => absurd h hzY⟩ + exact ⟨z, hzX, hzY, fun u hu => (hagree u hu).symm⟩ + +theorem leL_total {X Y : List Nat} (hX : X.Pairwise (· < ·)) (hY : Y.Pairwise (· < ·)) : + LeL X Y ∨ PrecL Y X := by + by_cases h : X = Y + · exact Or.inl (Or.inl fun u => by rw [h]) + · rcases precL_total hX hY h with h | h + · exact Or.inl (Or.inr h) + · exact Or.inr h + +/-- **Monotonicity under unions of disjoint universes.** -/ +theorem precL_union {X1 Y1 X2 Y2 X Y : List Nat} + (hdisj : ∀ a, (a ∈ X1 ∨ a ∈ Y1) → ¬ (a ∈ X2 ∨ a ∈ Y2)) + (hX : ∀ u, u ∈ X ↔ u ∈ X1 ∨ u ∈ X2) (hY : ∀ u, u ∈ Y ↔ u ∈ Y1 ∨ u ∈ Y2) + (h1 : (∀ u, u ∈ X1 ↔ u ∈ Y1) ∨ PrecL X1 Y1) (h2 : (∀ u, u ∈ X2 ↔ u ∈ Y2) ∨ PrecL X2 Y2) : + (∀ u, u ∈ X ↔ u ∈ Y) ∨ PrecL X Y := by + -- the first difference of a side, if any + have side1 : ∀ z, FirstIn X1 Y1 z → (∀ u, u < z → ((u ∈ X2 ↔ u ∈ Y2))) → FirstIn X Y z := by + intro z ⟨hzY, hzX, hag⟩ hag2 + refine ⟨(hY z).mpr (Or.inl hzY), fun h => ?_, fun u hu => ?_⟩ + · rcases (hX z).mp h with h | h + · exact hzX h + · exact hdisj z (Or.inr hzY) (Or.inl h) + · rw [hX, hY, hag u hu, hag2 u hu] + have side2 : ∀ z, FirstIn X2 Y2 z → (∀ u, u < z → ((u ∈ X1 ↔ u ∈ Y1))) → FirstIn X Y z := by + intro z ⟨hzY, hzX, hag⟩ hag1 + refine ⟨(hY z).mpr (Or.inr hzY), fun h => ?_, fun u hu => ?_⟩ + · rcases (hX z).mp h with h | h + · exact hdisj z (Or.inl h) (Or.inr hzY) + · exact hzX h + · rw [hX, hY, hag1 u hu, hag u hu] + rcases h1 with h1 | ⟨z1, hz1⟩ <;> rcases h2 with h2 | ⟨z2, hz2⟩ + · left; intro u; rw [hX, hY, h1 u, h2 u] + · right; exact ⟨z2, side2 z2 hz2 (fun u _ => h1 u)⟩ + · right; exact ⟨z1, side1 z1 hz1 (fun u _ => h2 u)⟩ + · right + rcases Nat.lt_or_ge z1 z2 with h | h + · exact ⟨z1, side1 z1 hz1 (fun u hu => hz2.2.2 u (by omega))⟩ + · rcases Nat.lt_or_ge z2 z1 with h' | h' + · exact ⟨z2, side2 z2 hz2 (fun u hu => hz1.2.2 u (by omega))⟩ + · have : z1 = z2 := by omega + subst this + exact absurd (Or.inr hz2.1) (hdisj z1 (Or.inr hz1.1)) + +/-! ## `setPrec` on sorted arrays -/ + +theorem setPrec_iff {a b : Array Nat} (ha : a.toList.Pairwise (· < ·)) (hb : b.toList.Pairwise (· < ·)) : + setPrec a b = true ↔ PrecL a.toList b.toList := by + unfold setPrec + rw [Array.compareLex_eq_compareLex_toList] + have h := lexLt_iff a.toList b.toList ha hb + unfold PrecL + rw [← h] + cases List.compareLex compareDesc a.toList b.toList <;> decide + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/Compile/Verify/UniformWritings.lean b/Ix/Compile/Verify/UniformWritings.lean new file mode 100644 index 000000000..683fc75c5 --- /dev/null +++ b/Ix/Compile/Verify/UniformWritings.lean @@ -0,0 +1,440 @@ +import Ix.Compile.Verify.UniformLength + +/-! +# Writings: the model as a minimum over encodings + +A `WTree` writes a term of the canonical DAG: as a Share, as an inline +non-telescope node over writings of its children, or as an inline +telescope of `j` spine nodes over writings of their side children, ending +in a Share of the next spine node or in a writing of the natural tail. Its +length `cost` prices Shares at `w` and telescopes by the merged-header rule. + +`uCost` and `uInl` are the minimum lengths of a writing and of an inline +writing of a term with the stored terms `S` (`valid_cost`), and both minima +are attained (`exists_opt`). +-/ + +namespace Ix.Compile.Verify.UniformModel + +open Ix.Sharing.Exact + +/-- A writing of a term. -/ +inductive WTree where + | share (x : Nat) + | node (x : Nat) (kids : List WTree) + | tele (x j : Nat) (sides : List WTree) (tail : WTree) + deriving Inhabited + +mutual +/-- Length of a writing (Shares at `w`). -/ +def WTree.cost (p : Prep) (w : Nat) : WTree → Nat + | .share _ => w + | .node x kids => (p.dag.node x).head.ownBytes + WTree.costs p w kids + | .tele x j sides tail => + tag4Size j + j * (p.dag.node x).sideExtra + WTree.costs p w sides + WTree.cost p w tail +/-- Total length of a list of writings. -/ +def WTree.costs (p : Prep) (w : Nat) : List WTree → Nat + | [] => 0 + | k :: ks => WTree.cost p w k + WTree.costs p w ks +end + +theorem WTree.costs_eq (p : Prep) (w : Nat) (l : List WTree) : + WTree.costs p w l = (l.map (WTree.cost p w)).sum := by + induction l with + | nil => rfl + | cons k ks ih => simp [WTree.costs, ih] + +/-- Whether a writing is a Share. -/ +def WTree.isShare : WTree → Bool + | .share _ => true + | _ => false + +/-- The side child of the `k`-th spine node of `x`. -/ +def sideAt (p : Prep) (x k : Nat) : Nat := (p.dag.node (spineAt p x k)).sideChild + +/-- `T` is a writing of term `x` using the stored terms `S`. -/ +inductive Valid (p : Prep) (S : Nat → Bool) : Nat → WTree → Prop + | share {x : Nat} : S x = true → Valid p S x (.share x) + | node {x : Nat} {kids : List WTree} : p.family[x]! = .none → + kids.length = (p.dag.node x).head.arity → + (∀ (i : Nat) (h : i < kids.length), Valid p S ((p.dag.node x).child i) kids[i]) → + Valid p S x (.node x kids) + | teleCut {x j : Nat} {sides : List WTree} : p.family[x]! ≠ .none → + 1 ≤ j → j < p.spineLen[x]! → sides.length = j → + (∀ (k : Nat) (h : k < sides.length), Valid p S (sideAt p x k) sides[k]) → + S (spineAt p x j) = true → + Valid p S x (.tele x j sides (.share (spineAt p x j))) + | teleFull {x : Nat} {sides : List WTree} {tail : WTree} : p.family[x]! ≠ .none → + sides.length = p.spineLen[x]! → + (∀ (k : Nat) (h : k < sides.length), Valid p S (sideAt p x k) sides[k]) → + Valid p S p.tail[x]! tail → + Valid p S x (.tele x p.spineLen[x]! sides tail) + +/-! ## Spine bookkeeping -/ + +theorem sideExtra_of_family {a b : Node} (h : a.head.family = b.head.family) : + a.sideExtra = b.sideExtra := by + unfold Node.sideExtra + cases ha : a.head <;> cases hb : b.head <;> simp_all [Head.family] + +theorem PrepWF.sideExtra_spine {p : Prep} (hp : PrepWF p) {x k : Nat} (hx : x < p.dag.size) + (hf : p.family[x]! ≠ .none) (hk : k < p.spineLen[x]!) : + (p.dag.node (spineAt p x k)).sideExtra = (p.dag.node x).sideExtra := by + obtain ⟨_, hsp, _, _, _⟩ := hp.spine x hx hf + obtain ⟨hle, hfam, _, _⟩ := hsp k hk + apply sideExtra_of_family + rw [← hp.family _ (by omega), ← hp.family _ hx, hfam] + +theorem sum_map_const_add {α : Type} (c : Nat) (f : α → Nat) : + ∀ (l : List α), (l.map fun a => c + f a).sum = l.length * c + (l.map f).sum := by + intro l + induction l with + | nil => simp + | cons x xs ih => simp only [List.map_cons, List.sum_cons, List.length_cons, ih]; rw [Nat.succ_mul]; omega + +theorem PrepWF.prefixSides_eq {p : Prep} (hp : PrepWF p) (cost : Nat → Nat) {x j : Nat} + (hx : x < p.dag.size) (hf : p.family[x]! ≠ .none) (hj : j ≤ p.spineLen[x]!) : + prefixSides p cost x j = + j * (p.dag.node x).sideExtra + ((List.range j).map fun k => cost (sideAt p x k)).sum := by + rw [prefixSides_eq_sum] + have : ∀ k ∈ List.range j, sideCost p cost (spineAt p x k) = + (p.dag.node x).sideExtra + cost (sideAt p x k) := by + intro k hk + rw [List.mem_range] at hk + unfold sideCost sideAt + rw [hp.sideExtra_spine hx hf (by omega)] + rw [List.map_congr_left this, sum_map_const_add] + simp + +theorem PrepWF.sideAt_lt {p : Prep} (hp : PrepWF p) {x k : Nat} (hx : x < p.dag.size) + (hf : p.family[x]! ≠ .none) (hk : k < p.spineLen[x]!) : sideAt p x k < x := by + obtain ⟨_, hsp, _, _, _⟩ := hp.spine x hx hf + obtain ⟨hle, hfam, _, _⟩ := hsp k hk + have := hp.sideChild_lt (t := spineAt p x k) (by omega) (by rw [hfam]; exact hf) + unfold sideAt + omega + +theorem costOf_le_inl (p : Prep) (w : Nat) (S : Nat → Bool) (f : Nat → Nat) (x : Nat) : + costOf p w S f x ≤ inlOf p w S f x := by + unfold costOf; split <;> omega + +theorem PrepWF.inl_node {p : Prep} (hp : PrepWF p) (w : Nat) (S : Nat → Bool) (f : Nat → Nat) + {x : Nat} (hx : x < p.dag.size) (hf : p.family[x]! = .none) : + inlOf p w S f x = (p.dag.node x).head.ownBytes + + ((List.range (p.dag.node x).head.arity).map fun i => f ((p.dag.node x).child i)).sum := by + unfold inlOf + rw [if_pos hf, ← Array.foldl_toList, foldl_add_eq_sum] + have har := hp.dag.arity x hx + rw [← dag_node_eq hx] at har + rw [children_toList har, List.map_map] + rfl + +theorem inl_tele {p : Prep} (w : Nat) (S : Nat → Bool) (f : Nat → Nat) + {x : Nat} (hf : p.family[x]! ≠ .none) : + inlOf p w S f x = (cutCosts p w S f x).foldl min (naturalCost p f x) := by + unfold inlOf + rw [if_neg hf] + +theorem cut_mem_cutCosts (p : Prep) (w : Nat) (S : Nat → Bool) (f : Nat → Nat) {x j : Nat} + (hj1 : 1 ≤ j) (hj : j < p.spineLen[x]!) (hS : S (spineAt p x j) = true) : + cutCost p w f x j ∈ cutCosts p w S f x := by + rw [cutCosts_eq] + unfold cutsFrom + apply List.mem_filterMap.mpr + refine ⟨j, List.mem_range'_1.mpr ⟨hj1, by omega⟩, ?_⟩ + rw [if_pos hS] + +theorem sum_le_sum_of_le {f g : Nat → Nat} : + ∀ (l : List Nat), (∀ k ∈ l, f k ≤ g k) → (l.map f).sum ≤ (l.map g).sum := by + intro l + induction l with + | nil => intro _; simp + | cons k ks ih => + intro h + simp only [List.map_cons, List.sum_cons] + have h1 := h k List.mem_cons_self + have h2 := ih (fun k' hk' => h k' (List.mem_cons_of_mem _ hk')) + omega + +theorem costs_eq_range (p : Prep) (w : Nat) (l : List WTree) : + WTree.costs p w l = ((List.range l.length).map fun k => (l[k]?.getD default).cost p w).sum := by + rw [WTree.costs_eq] + congr 1 + apply List.ext_getElem (by simp) + intro k h1 h2 + simp only [List.getElem_map, List.getElem_range] + rw [List.getElem?_eq_getElem (by simpa using h1)] + rfl + +/-- **Lower bound.** Every writing of `x` is at least `C_S(x)` long, and +every inline writing at least `inl_S(x)`. -/ +theorem PrepWF.valid_cost {p : Prep} (hp : PrepWF p) (w : Nat) (S : Nat → Bool) : + ∀ {x : Nat} {T : WTree}, Valid p S x T → x < p.dag.size → + uCost p w S x ≤ T.cost p w ∧ (T.isShare = false → uInl p w S x ≤ T.cost p w) := by + intro x T h + induction h with + | share hS => + intro hx + refine ⟨?_, fun h => by simp [WTree.isShare] at h⟩ + rw [hp.uCost_eq w S _ hx] + unfold costOf + simp only [hS, if_true, WTree.cost] + omega + | @node x kids hf hlen _ ih => + intro hx + have hinl : uInl p w S x ≤ (WTree.node x kids).cost p w := by + unfold uInl + rw [hp.inl_node w S _ hx hf] + simp only [WTree.cost] + rw [costs_eq_range, hlen] + have : ∀ i ∈ List.range (p.dag.node x).head.arity, + uCost p w S ((p.dag.node x).child i) ≤ (kids[i]?.getD default).cost p w := by + intro i hi + rw [List.mem_range] at hi + have hc := hp.dag.childAt_lt hx hi + rw [show kids[i]?.getD default = kids[i]'(by omega) by simp [hlen ▸ hi]] + exact (ih i (by omega) (by omega)).1 + have := sum_le_sum_of_le _ this + omega + refine ⟨?_, fun _ => hinl⟩ + rw [hp.uCost_eq w S _ hx] + exact Nat.le_trans (costOf_le_inl _ _ _ _ _) hinl + | @teleCut x j sides hf hj1 hj hlen _ hS ih => + intro hx + have hinl : uInl p w S x ≤ (WTree.tele x j sides (.share (spineAt p x j))).cost p w := by + unfold uInl + rw [inl_tele w S _ hf] + refine Nat.le_trans (foldl_min_le _ _ _ (List.mem_cons_of_mem _ + (cut_mem_cutCosts p w S _ hj1 hj hS))) ?_ + unfold cutCost + rw [hp.prefixSides_eq _ hx hf (by omega)] + simp only [WTree.cost] + rw [costs_eq_range, hlen] + have : ∀ k ∈ List.range j, uCost p w S (sideAt p x k) ≤ (sides[k]?.getD default).cost p w := by + intro k hk + rw [List.mem_range] at hk + rw [show sides[k]?.getD default = sides[k]'(by omega) by simp [hlen ▸ hk]] + exact (ih k (by omega) (by have := hp.sideAt_lt hx hf (k := k) (by omega); omega)).1 + have := sum_le_sum_of_le _ this + omega + refine ⟨?_, fun _ => hinl⟩ + rw [hp.uCost_eq w S _ hx] + exact Nat.le_trans (costOf_le_inl _ _ _ _ _) hinl + | @teleFull x sides tail hf hlen _ _ ih iht => + intro hx + obtain ⟨_, _, _, htl, _⟩ := hp.spine x hx hf + have hinl : uInl p w S x ≤ (WTree.tele x p.spineLen[x]! sides tail).cost p w := by + unfold uInl + rw [inl_tele w S _ hf] + refine Nat.le_trans (foldl_min_le _ _ _ List.mem_cons_self) ?_ + unfold naturalCost + rw [hp.prefixSides_eq _ hx hf (Nat.le_refl _)] + simp only [WTree.cost] + rw [costs_eq_range, hlen] + have : ∀ k ∈ List.range p.spineLen[x]!, + uCost p w S (sideAt p x k) ≤ (sides[k]?.getD default).cost p w := by + intro k hk + rw [List.mem_range] at hk + rw [show sides[k]?.getD default = sides[k]'(by omega) by simp [hlen ▸ hk]] + exact (ih k (by omega) (by have := hp.sideAt_lt hx hf (k := k) (by omega); omega)).1 + have := sum_le_sum_of_le _ this + have ht := (iht (by omega)).1 + omega + refine ⟨?_, fun _ => hinl⟩ + rw [hp.uCost_eq w S _ hx] + exact Nat.le_trans (costOf_le_inl _ _ _ _ _) hinl + +theorem mem_cutCosts {p : Prep} {w : Nat} {S : Nat → Bool} {f : Nat → Nat} {x c : Nat} + (h : c ∈ cutCosts p w S f x) : + ∃ j, 1 ≤ j ∧ j < p.spineLen[x]! ∧ S (spineAt p x j) = true ∧ c = cutCost p w f x j := by + rw [cutCosts_eq] at h + unfold cutsFrom at h + obtain ⟨j, hj, hjv⟩ := List.mem_filterMap.mp h + rw [List.mem_range'_1] at hj + split at hjv + · rename_i hS + simp only [Option.some.injEq] at hjv + exact ⟨j, hj.1, by omega, hS, hjv.symm⟩ + · cases hjv + +theorem costs_map_range (p : Prep) (w : Nat) (g : Nat → WTree) (n : Nat) : + WTree.costs p w ((List.range n).map g) = ((List.range n).map fun k => (g k).cost p w).sum := by + rw [WTree.costs_eq, List.map_map] + rfl + +/-- **Attainment.** Some writing of `x` has length `C_S(x)`, and some inline +writing has length `inl_S(x)`. -/ +theorem PrepWF.exists_opt {p : Prep} (hp : PrepWF p) (w : Nat) (S : Nat → Bool) : + ∀ x, x < p.dag.size → + (∃ T, Valid p S x T ∧ T.cost p w = uCost p w S x) ∧ + ∃ T, Valid p S x T ∧ T.isShare = false ∧ T.cost p w = uInl p w S x := by + intro x + induction x using Nat.strongRecOn with + | _ x ih => + intro hx + classical + let g : Nat → WTree := fun c => + if h : c < x ∧ c < p.dag.size then Classical.choose (ih c h.1 h.2).1 else default + have hg : ∀ c, c < x → Valid p S c (g c) ∧ (g c).cost p w = uCost p w S c := by + intro c hc + have hcn : c < p.dag.size := by omega + simp only [g, dif_pos (And.intro hc hcn)] + exact Classical.choose_spec (ih c hc hcn).1 + -- an optimal inline writing + have hinl : ∃ T, Valid p S x T ∧ T.isShare = false ∧ T.cost p w = uInl p w S x := by + by_cases hf : p.family[x]! = .none + · let ar := (p.dag.node x).head.arity + refine ⟨.node x ((List.range ar).map fun i => g ((p.dag.node x).child i)), ?_, rfl, ?_⟩ + · refine Valid.node hf (by simp [ar]) fun i hi => ?_ + simp only [List.length_map, List.length_range] at hi + simp only [List.getElem_map, List.getElem_range] + exact (hg _ (hp.dag.childAt_lt hx hi)).1 + · simp only [WTree.cost, costs_map_range] + unfold uInl + rw [hp.inl_node w S _ hx hf] + simp only [ar] + congr 2 + apply List.map_congr_left + intro i hi + rw [List.mem_range] at hi + exact (hg _ (hp.dag.childAt_lt hx hi)).2 + · obtain ⟨hl1, _, hend, htl, _⟩ := hp.spine x hx hf + have hmin := foldl_min_mem (cutCosts p w S (uCost p w S) x) + (naturalCost p (uCost p w S) x) + rw [← inl_tele w S _ hf] at hmin + have hsides : ∀ j, j ≤ p.spineLen[x]! → + WTree.costs p w ((List.range j).map fun k => g (sideAt p x k)) = + ((List.range j).map fun k => uCost p w S (sideAt p x k)).sum := by + intro j hj + rw [costs_map_range] + congr 1 + apply List.map_congr_left + intro k hk + rw [List.mem_range] at hk + exact (hg _ (hp.sideAt_lt hx hf (by omega))).2 + have hsv : ∀ j, j ≤ p.spineLen[x]! → ∀ (k : Nat) + (h : k < ((List.range j).map fun k => g (sideAt p x k)).length), + Valid p S (sideAt p x k) ((List.range j).map fun k => g (sideAt p x k))[k] := by + intro j hj k hk + simp only [List.length_map, List.length_range] at hk + simp only [List.getElem_map, List.getElem_range] + exact (hg _ (hp.sideAt_lt hx hf (by omega))).1 + rcases List.mem_cons.mp hmin with hnat | hcut + · refine ⟨.tele x p.spineLen[x]! ((List.range p.spineLen[x]!).map fun k => g (sideAt p x k)) + (g p.tail[x]!), Valid.teleFull hf (by simp) (hsv _ (Nat.le_refl _)) + (hg _ htl).1, rfl, ?_⟩ + simp only [WTree.cost] + rw [hsides _ (Nat.le_refl _), (hg _ htl).2] + unfold uInl + rw [hnat] + unfold naturalCost + rw [hp.prefixSides_eq _ hx hf (Nat.le_refl _)] + omega + · obtain ⟨j, hj1, hjl, hS, hc⟩ := mem_cutCosts hcut + refine ⟨.tele x j ((List.range j).map fun k => g (sideAt p x k)) + (.share (spineAt p x j)), Valid.teleCut hf hj1 hjl (by simp) (hsv _ (by omega)) hS, + rfl, ?_⟩ + simp only [WTree.cost] + rw [hsides _ (by omega)] + unfold uInl + rw [hc] + unfold cutCost + rw [hp.prefixSides_eq _ hx hf (by omega)] + omega + refine ⟨?_, hinl⟩ + obtain ⟨T, hT, hTs, hTc⟩ := hinl + rw [hp.uCost_eq w S x hx] + unfold costOf + by_cases hS : S x = true + · by_cases hle : w ≤ inlOf p w S (uCost p w S) x + · refine ⟨.share x, Valid.share hS, ?_⟩ + simp only [hS, if_true, WTree.cost] + omega + · refine ⟨T, hT, ?_⟩ + simp only [hS, if_true] + unfold uInl at hTc + omega + · refine ⟨T, hT, ?_⟩ + simp only [hS, Bool.false_eq_true, if_false] + exact hTc + +/-! ## Complete encodings -/ + +/-- The length of a complete encoding: the table count, an entry writing for +every table term, and a writing of every root. -/ +def encodingCost (p : Prep) (w : Nat) (table : List Nat) (entry : Nat → WTree) + (rootsW : List WTree) : Nat := + tag0Size table.length + (table.map fun s => (entry s).cost p w).sum + + (rootsW.map (WTree.cost p w)).sum + +/-- A complete encoding: every table term has an inline writing, every root +a writing, all using only the table's terms. -/ +def EncodingWF (p : Prep) (avail : Nat → Bool) (table : List Nat) (entry : Nat → WTree) + (roots : List Nat) (rootsW : List WTree) : Prop := + (∀ s ∈ table, Valid p avail s (entry s) ∧ (entry s).isShare = false) ∧ + List.Forall₂ (Valid p avail) roots rootsW + +theorem forall₂_sum_le {α β : Type} {R : α → β → Prop} {f : α → Nat} {g : β → Nat} : + ∀ {xs : List α} {ys : List β}, List.Forall₂ R xs ys → + (∀ a ∈ xs, ∀ b, R a b → f a ≤ g b) → (xs.map f).sum ≤ (ys.map g).sum + | _, _, .nil, _ => by simp + | _, _, .cons hr hs, hfg => by + simp only [List.map_cons, List.sum_cons] + have h1 := hfg _ List.mem_cons_self _ hr + have h2 := forall₂_sum_le hs (fun a ha b h => hfg a (List.mem_cons_of_mem _ ha) b h) + omega + +/-- **`uniformCost` is the minimum encoding length.** Every complete encoding +with table `S` is at least `uniformCost S` long. -/ +theorem PrepWF.uniformCost_le {p : Prep} (hp : PrepWF p) (w : Nat) (avail : Nat → Bool) + {table roots : List Nat} {entry : Nat → WTree} {rootsW : List WTree} + (htable : ∀ s ∈ table, s < p.dag.size) (hroots : ∀ r ∈ roots, r < p.dag.size) + (h : EncodingWF p avail table entry roots rootsW) : + uniformCost p w avail table roots ≤ encodingCost p w table entry rootsW := by + unfold uniformCost encodingCost + have he : (table.map (uInl p w avail)).sum ≤ (table.map fun s => (entry s).cost p w).sum := + sum_le_sum_of_le' fun s hs => (hp.valid_cost w avail (h.1 s hs).1 (htable s hs)).2 (h.1 s hs).2 + have hr : (roots.map (uCost p w avail)).sum ≤ (rootsW.map (WTree.cost p w)).sum := + forall₂_sum_le h.2 fun r hr T hT => (hp.valid_cost w avail hT (hroots r hr)).1 + omega +where + sum_le_sum_of_le' {f g : Nat → Nat} {l : List Nat} (h : ∀ k ∈ l, f k ≤ g k) : + (l.map f).sum ≤ (l.map g).sum := sum_le_sum_of_le l h + +/-- **… and it is attained.** -/ +theorem PrepWF.uniformCost_attained {p : Prep} (hp : PrepWF p) (w : Nat) (avail : Nat → Bool) + (table roots : List Nat) (htable : ∀ s ∈ table, s < p.dag.size) + (hroots : ∀ r ∈ roots, r < p.dag.size) : + ∃ entry rootsW, EncodingWF p avail table entry roots rootsW ∧ + encodingCost p w table entry rootsW = uniformCost p w avail table roots := by + classical + let entry : Nat → WTree := fun s => + if h : s < p.dag.size then Classical.choose (hp.exists_opt w avail s h).2 else default + have hentry : ∀ s, s < p.dag.size → Valid p avail s (entry s) ∧ (entry s).isShare = false ∧ + (entry s).cost p w = uInl p w avail s := by + intro s hs + simp only [entry, dif_pos hs] + exact Classical.choose_spec (hp.exists_opt w avail s hs).2 + let rootW : Nat → WTree := fun r => + if h : r < p.dag.size then Classical.choose (hp.exists_opt w avail r h).1 else default + have hrootW : ∀ r, r < p.dag.size → Valid p avail r (rootW r) ∧ + (rootW r).cost p w = uCost p w avail r := by + intro r hr + simp only [rootW, dif_pos hr] + exact Classical.choose_spec (hp.exists_opt w avail r hr).1 + refine ⟨entry, roots.map rootW, ⟨fun s hs => ⟨(hentry s (htable s hs)).1, + (hentry s (htable s hs)).2.1⟩, ?_⟩, ?_⟩ + · clear htable + induction roots with + | nil => exact .nil + | cons r rs ih => + exact .cons (hrootW r (hroots r List.mem_cons_self)).1 + (ih (fun r' h => hroots r' (List.mem_cons_of_mem _ h))) + · unfold encodingCost uniformCost + rw [List.map_congr_left fun s hs => (hentry s (htable s hs)).2.2, List.map_map] + congr 2 + apply List.map_congr_left + intro r hr + exact (hrootW r (hroots r hr)).2 + +end Ix.Compile.Verify.UniformModel diff --git a/Ix/CompileDriver.lean b/Ix/CompileDriver.lean index 827668ce3..7bb20c669 100644 --- a/Ix/CompileDriver.lean +++ b/Ix/CompileDriver.lean @@ -480,8 +480,9 @@ def assembleEnv (acc : DriverAcc) : Ixon.Env × Nat × CompileEnv := Id.run do def compileEnvAux (env : Ix.Environment) (blocks : Ix.CondensedBlocks) (dbg : Bool := false) (nameByHash : Std.HashMap Address Name := {}) + (sharingLimits : Ix.Sharing.Exact.Limits := compilerSharingLimits) : Except String (Ixon.Env × Nat × CompileEnv) := Id.run do - let mut acc : DriverAcc := { cenv := { CompileEnv.new env with nameByHash } } + let mut acc : DriverAcc := { cenv := { CompileEnv.new env with nameByHash, sharingLimits } } match precompileAuxGenPrereqs blocks acc with | .error e => return .error e | .ok a => acc := a @@ -840,8 +841,12 @@ def compileEnvParallelAux (env : Ix.Environment) (blocks : Ix.CondensedBlocks) (nameByHash : Std.HashMap Address Name := {}) : IO (Except String (Ixon.Env × Nat × CompileEnv)) := do let totalBlocks := blocks.blocks.size + -- The `IX_SHARING_LIMITS` override (`ix compile-lean --sharing-limits`). + let sharingLimits ← match ← compilerSharingLimitsFromEnv with + | .ok l => pure l + | .error e => return .error e - let mut acc : DriverAcc := { cenv := { CompileEnv.new env with nameByHash } } + let mut acc : DriverAcc := { cenv := { CompileEnv.new env with nameByHash, sharingLimits } } match precompileAuxGenPrereqs blocks acc with | .error e => return .error e | .ok a => acc := a diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean index 2ac918071..99c99cf60 100644 --- a/Ix/CompileM.lean +++ b/Ix/CompileM.lean @@ -18,7 +18,7 @@ public import Ix.IxonUniv public import Ix.Environment public import Ix.SemanticContract public import Ix.Compile.SourceContract.Transport -public import Ix.Sharing +public import Ix.Sharing.Exact public import Ix.Common public import Ix.Store public import Ix.Mutual @@ -109,6 +109,12 @@ structure CompileEnv where keys sees nothing there). Materialized-env callers leave this empty and keep the scan. -/ nameByHash : Std.HashMap Address Name := {} + /-- Resource limits of the canonical sharing construction + (`buildBlockConstant`, `finishMutualCompilation`): `compilerSharingLimits` + unless a driver sets the `IX_SHARING_LIMITS` override + (`compilerSharingLimitsFromEnv`). Limits decide only whether a block + compiles, never its bytes. -/ + sharingLimits : Ix.Sharing.Exact.Limits := {} /-- Initialize global state from canonicalization result. -/ def CompileEnv.new (env: Ix.Environment) : CompileEnv := @@ -252,7 +258,7 @@ structure BlockEnv where /-! ## Compilation Error -/ -/-- Compilation error type. Variant order matches Rust CompileError (tags 0–6). -/ +/-- Compilation error type. Variant order matches Rust CompileError (tags 0–7). -/ inductive CompileError where | missingConstant (name : String) | missingAddress (addr : Address) @@ -261,6 +267,9 @@ inductive CompileError where | unknownUnivParam (curr param : String) | serializeError (err : Ixon.SerializeError) | resourceLimit (reason : String) + /-- The sharing construction failed (other than by resource exhaustion, which is + `resourceLimit`). -/ + | sharingConstruction (reason : String) deriving Repr, BEq instance : ToString CompileError where @@ -272,6 +281,7 @@ instance : ToString CompileError where | .unknownUnivParam curr param => s!"unknownUnivParam: compiling {curr}, param {param}" | .serializeError err => s!"serializeError: {err}" | .resourceLimit reason => s!"resourceLimit: {reason}" + | .sharingConstruction reason => s!"sharingConstruction: {reason}" abbrev CompileM := ReaderT (CompileEnv × BlockEnv) (ExceptT CompileError (StateT BlockState Id)) @@ -583,31 +593,14 @@ def BlockState.compileNames (state : BlockState) def compileNames (names : Array Ix.Name) : CompileM Unit := modifyBlockState fun state => state.compileNames names -/-- Serialize a u64 in trimmed little-endian format (only necessary bytes). - Uses Ixon.u64ByteCount for the byte count calculation. -/ -def putU64TrimmedLE (x : UInt64) : ByteArray := Id.run do - let count := Ixon.u64ByteCount x - let mut bytes := ByteArray.empty - let mut v := x - for _ in [:count.toNat] do - bytes := bytes.push (v &&& 0xFF).toUInt8 - v := v >>> 8 - bytes - -/-- Serialize a Nat using Tag0 encoding (variable length, compact for small values). - Uses Ixon.u64ByteCount for the byte count calculation. -/ -def putTag0 (n : Nat) : ByteArray := - let x := n.toUInt64 - if x < 128 then - ByteArray.mk #[x.toUInt8] - else - let byteCount := Ixon.u64ByteCount x - ByteArray.mk #[0x80 ||| (byteCount - 1)] ++ putU64TrimmedLE x +/-- A Nat as a TagN (`f = 0`) integer (`Ixon.putTagN 0 0`). -/ +def tagN0Bytes (n : Nat) : ByteArray := + Ixon.runPut (Ixon.putTagN 0 0 n.toUInt64) /-- Serialize an Ix.Substring to bytes, storing strings as blobs. -/ def serializeIxSubstring (ss : Ix.Substring) : CompileM ByteArray := do let strAddr ← storeString ss.str - pure (strAddr.hash ++ putTag0 ss.startPos ++ putTag0 ss.stopPos) + pure (strAddr.hash ++ tagN0Bytes ss.startPos ++ tagN0Bytes ss.stopPos) /-- Serialize an Ix.SourceInfo to bytes, storing strings as blobs. -/ def serializeIxSourceInfo (si : Ix.SourceInfo) : CompileM ByteArray := do @@ -615,10 +608,10 @@ def serializeIxSourceInfo (si : Ix.SourceInfo) : CompileM ByteArray := do | .original leading leadingPos trailing trailingPos => let leadingBytes ← serializeIxSubstring leading let trailingBytes ← serializeIxSubstring trailing - pure (ByteArray.mk #[0] ++ leadingBytes ++ putTag0 leadingPos ++ - trailingBytes ++ putTag0 trailingPos) + pure (ByteArray.mk #[0] ++ leadingBytes ++ tagN0Bytes leadingPos ++ + trailingBytes ++ tagN0Bytes trailingPos) | .synthetic start stop canonical => - pure (ByteArray.mk #[1] ++ putTag0 start ++ putTag0 stop ++ + pure (ByteArray.mk #[1] ++ tagN0Bytes start ++ tagN0Bytes stop ++ ByteArray.mk #[if canonical then 1 else 0]) | .none => pure (ByteArray.mk #[2]) @@ -630,7 +623,7 @@ def serializeIxSyntaxPreresolved (sp : Ix.SyntaxPreresolved) : CompileM ByteArra pure (ByteArray.mk #[0] ++ name.getHash.hash) | .decl name aliases => compileName name - let header := ByteArray.mk #[1] ++ name.getHash.hash ++ putTag0 aliases.size + let header := ByteArray.mk #[1] ++ name.getHash.hash ++ tagN0Bytes aliases.size let aliasAddrs ← aliases.mapM storeString let aliasesBytes := aliasAddrs.foldl (fun bytes addr => bytes ++ addr.hash) ByteArray.empty @@ -647,7 +640,7 @@ def serializeIxSyntax (syn : Ix.Syntax) : CompileM ByteArray := do let header := ByteArray.mk #[1] let infoBytes ← serializeIxSourceInfo info let kindBytes := kind.getHash.hash - let lenBytes := putTag0 args.size + let lenBytes := tagN0Bytes args.size let serializedArgs ← args.attach.mapM fun arg => serializeIxSyntax arg.1 let argsBytes := serializedArgs.foldl (fun bytes arg => bytes ++ arg) ByteArray.empty @@ -662,7 +655,7 @@ def serializeIxSyntax (syn : Ix.Syntax) : CompileM ByteArray := do let infoBytes ← serializeIxSourceInfo info let rawBytes ← serializeIxSubstring rawVal let valBytes := val.getHash.hash - let lenBytes := putTag0 preresolved.size + let lenBytes := tagN0Bytes preresolved.size let serializedPres ← preresolved.mapM serializeIxSyntaxPreresolved let presBytes := serializedPres.foldl (fun bytes pr => bytes ++ pr) ByteArray.empty @@ -2357,68 +2350,8 @@ def sortConstsIsolated (sources : List MutConst) : /-! ## Constant Building -/ -/-- Count Share references in an expression (for debugging). -/ -partial def countShareRefs : Ixon.Expr → Nat - | .share _ => 1 - | .prj _ _ val => countShareRefs val - | .app f a => countShareRefs f + countShareRefs a - | .lam _ ty body => countShareRefs ty + countShareRefs body - | .all _ _ ty body => countShareRefs ty + countShareRefs body - | .letE _ ty val body => countShareRefs ty + countShareRefs val + countShareRefs body - | _ => 0 - -/-- Update recursor rules with rewritten expressions starting at given index. - Returns updated rules and next index. -/ -def updateRecursorRules (rules : Array Ixon.RecursorRule) (rewrittenExprs : Array Ixon.Expr) (startIdx : Nat) - : Array Ixon.RecursorRule × Nat := - let result := rules.mapIdx fun i rule => - { rule with rhs := rewrittenExprs[startIdx + i]?.getD rule.rhs } - (result, startIdx + rules.size) - -/-- Update inductive constructor types with rewritten expressions starting at given index. - Returns updated constructors and next index. -/ -def updateConstructorTypes (ctors : Array Ixon.Constructor) (rewrittenExprs : Array Ixon.Expr) (startIdx : Nat) - : Array Ixon.Constructor × Nat := - let result := ctors.mapIdx fun i ctor => - { ctor with typ := rewrittenExprs[startIdx + i]?.getD ctor.typ } - (result, startIdx + ctors.size) - -/-- State threaded while mutual members consume rewritten expressions. -/ -structure MutConstUpdateState where - result : Array Ixon.MutConst := #[] - nextIdx : Nat := 0 - -/-- Rewrite one mutual member and advance its expression cursor. -/ -def updateMutConst (rewrittenExprs : Array Ixon.Expr) - (state : MutConstUpdateState) (member : Ixon.MutConst) : - MutConstUpdateState := - match member with - | .indc ind => - let typ := rewrittenExprs[state.nextIdx]?.getD ind.typ - let (ctors, nextIdx) := - updateConstructorTypes ind.ctors rewrittenExprs (state.nextIdx + 1) - { result := state.result.push (.indc { ind with typ, ctors }) - nextIdx } - | .defn definition => - let typ := rewrittenExprs[state.nextIdx]?.getD definition.typ - let value := - rewrittenExprs[state.nextIdx + 1]?.getD definition.value - { result := state.result.push (.defn { definition with typ, value }) - nextIdx := state.nextIdx + 2 } - | .recr recursor => - let typ := rewrittenExprs[state.nextIdx]?.getD recursor.typ - let (rules, nextIdx) := - updateRecursorRules recursor.rules rewrittenExprs (state.nextIdx + 1) - { result := state.result.push (.recr { recursor with typ, rules }) - nextIdx } - -/-- Update Ixon MutConsts with rewritten expressions. -/ -def updateMutConsts (ms : Array Ixon.MutConst) (rewrittenExprs : Array Ixon.Expr) - : Array Ixon.MutConst := - (ms.foldl (init := {}) (updateMutConst rewrittenExprs)).result - /-- Expressions rewritten by production sharing for one mutual member, in -the exact cursor order consumed by `updateMutConst`. -/ +the cursor order `withRootExprs` writes them back. -/ def mutConstRootExprs : Ixon.MutConst → List Ixon.Expr | .defn definition => [definition.typ, definition.value] | .indc indInfo => @@ -2427,8 +2360,9 @@ def mutConstRootExprs : Ixon.MutConst → List Ixon.Expr recursor.typ :: recursor.rules.toList.map (·.rhs) /-- Canonical production sharing roots for a `ConstantInfo`. Projection -payloads contain no expressions, while mutual members are flattened in the -same order as `updateMutConsts`. -/ +payloads contain no expressions, while mutual members are flattened in member +order. This is the order of `Ix.Sharing.Exact.constantInfoRoots`, which +`withRootExprs` consumes. -/ def constantInfoRootExprs : Ixon.ConstantInfo → Array Ixon.Expr | .defn definition => (mutConstRootExprs (.defn definition)).toArray @@ -2440,34 +2374,82 @@ def constantInfoRootExprs : Ixon.ConstantInfo → Array Ixon.Expr | .muts members => (members.toList.flatMap mutConstRootExprs).toArray -/-- Apply sharing analysis to expressions and build a Constant. -/ -def buildConstantWithSharing (info : Ixon.ConstantInfo) (rootExprs : Array Ixon.Expr) - (refs : Array Address) (univs : Array Ixon.Univ) (dbg : Bool := false) : Ixon.Constant := Id.run do - let (rewrittenExprs, sharingVec) := Sharing.applySharing rootExprs dbg - -- Debug: count Share refs in rewritten expressions - if dbg && sharingVec.size > 0 then - let totalShareRefs := rewrittenExprs.foldl (fun acc e => acc + countShareRefs e) 0 - dbg_trace s!"[buildConstant] sharingVec.size={sharingVec.size}, totalShareRefs in rewritten={totalShareRefs}" - -- Update expressions in info with rewritten versions - let info' := match info with - | .defn d => - let typ := rewrittenExprs[0]?.getD d.typ - let value := rewrittenExprs[1]?.getD d.value - Ixon.ConstantInfo.defn { d with typ, value } - | .axio a => - let typ := rewrittenExprs[0]?.getD a.typ - Ixon.ConstantInfo.axio { a with typ } - | .quot q => - let typ := rewrittenExprs[0]?.getD q.typ - Ixon.ConstantInfo.quot { q with typ } - | .recr r => - let typ := rewrittenExprs[0]?.getD r.typ - let (rules, _) := updateRecursorRules r.rules rewrittenExprs 1 - Ixon.ConstantInfo.recr { r with typ, rules } - | .muts ms => - Ixon.ConstantInfo.muts (updateMutConsts ms rewrittenExprs) - | other => other - return { info := info', sharing := sharingVec, refs, univs } +/-! ## Canonical sharing + +The compiler builds every block Constant with the canonical sharing +construction `Ix.Sharing.Exact.canonicalSharingTiered .tagN` (Rust +`canonical_sharing_tiered`), under the limits of `CompileEnv.sharingLimits`. +There is no fallback: every construction failure is a compile error. -/ + +/-- Resource limits of the compiler's canonical sharing construction: the + library defaults (`Ix.Sharing.Exact.Limits`), a safety net far above every + corpus maximum. `CompileEnv.sharingLimits` carries the limits a compile + runs under. Mirrors Rust `compiler_sharing_limits`. -/ +def compilerSharingLimits : Ix.Sharing.Exact.Limits := {} + +/-- Environment variable carrying a sharing-limit override in the format of + `Ix.Sharing.Exact.Limits.withOverrides` (for example `states=2^44,depth=2^22` + or `unbounded`). `ix compile --sharing-limits` and `ix compile-lean + --sharing-limits` set it. `compilerSharingLimitsFromEnv` reads it, once per + run, in the Lean drivers `compileEnvParallelAux` and + `Ix.DecompileM.decompileEnvFullParallel`; Rust's `compiler_sharing_limits` + reads it once per compile or decompile entry point. -/ +def sharingLimitsEnvVar : String := "IX_SHARING_LIMITS" + +/-- `compilerSharingLimits` with the `IX_SHARING_LIMITS` override applied, or + the parse error. -/ +def compilerSharingLimitsFromEnv : IO (Except String Ix.Sharing.Exact.Limits) := do + match ← IO.getEnv sharingLimitsEnvVar with + | none => pure (.ok compilerSharingLimits) + | some spec => + pure ((compilerSharingLimits.withOverrides spec).mapError (s!"{sharingLimitsEnvVar}: " ++ ·)) + +/-- A sharing-construction failure as a compile error: resource exhaustion is + `resourceLimit` (naming the limit and its override), every other kind + `sharingConstruction`. Mirrors Rust `sharing_compile_error`. -/ +def sharingCompileError : Ix.Sharing.Exact.SharingError → CompileError + | .resourceExhausted r limit => + .resourceLimit s!"canonical sharing: resource exhausted: {r.key} (limit {limit}); \ + raise it with --sharing-limits {r.key}=N ({sharingLimitsEnvVar})" + | e => .sharingConstruction s!"canonical sharing: {e}" + +/-- Write `rewrittenExprs` back into the root slots of `info`, in + `constantInfoRootExprs` order: `Ix.Sharing.Exact.withRoots`, which fails + unless there is exactly one expression per root, so no slot keeps its old + value. -/ +def withRootExprs (info : Ixon.ConstantInfo) (rewrittenExprs : Array Ixon.Expr) : + Except CompileError Ixon.ConstantInfo := + (Ix.Sharing.Exact.withRoots info rewrittenExprs).mapError sharingCompileError + +/-- Build a block Constant with the canonical sharing of its payload: the + roots are `constantInfoRootExprs info`, shared by + `Ix.Sharing.Exact.canonicalSharingTiered .tagN` under `limits`, and written + back by `withRootExprs` (the construction must return one root per input + root). There is no fallback: every failure is a compile error. -/ +def buildConstantWithSharing (limits : Ix.Sharing.Exact.Limits) + (info : Ixon.ConstantInfo) (refs : Array Address) (univs : Array Ixon.Univ) : + Except CompileError Ixon.Constant := do + let roots := constantInfoRootExprs info + let r ← (Ix.Sharing.Exact.canonicalSharingTiered .tagN roots limits).mapError + sharingCompileError + unless r.result.roots.size == roots.size do + throw (.sharingConstruction + s!"canonical sharing: {r.result.roots.size} roots returned for {roots.size}") + let info ← withRootExprs info r.result.roots + pure { info, sharing := r.result.sharing, refs, univs } + +/-- Lift a sharing result into `CompileM`. -/ +def liftSharing (r : Except CompileError Ixon.Constant) : CompileM Ixon.Constant := + match r with + | .ok c => pure c + | .error e => throw e + +/-- Build a block Constant with the compiler's canonical sharing under + `CompileEnv.sharingLimits`. Every block the compiler emits goes through + here. -/ +def buildBlockConstant (info : Ixon.ConstantInfo) (refs : Array Address) + (univs : Array Ixon.Univ) : CompileM Ixon.Constant := do + liftSharing (buildConstantWithSharing (← read).1.sharingLimits info refs univs) /-! ## Individual Constant Compilation -/ @@ -3022,7 +3004,10 @@ def compileMutConstClasses : compileMutConstClasses rest state /-- Compile sorted equivalence classes of mutual constants. - Returns compiled constants, all root expressions, and metadata for each constant. -/ + Returns compiled constants, all root expressions, and metadata for each constant. + No caller uses the roots (`buildBlockConstant` derives them from the payload + with `constantInfoRootExprs`); they remain because the theorems of + `Ix.Compile.Verify.CompileMutualCodec` state their wire safety. -/ def compileMutConsts (classes : List (List MutConst)) : CompileM (Array Ixon.MutConst × Array Ixon.Expr × Array (Name × Ixon.ConstantMeta)) := do let state ← compileMutConstClasses classes {} @@ -3137,35 +3122,38 @@ def buildMutualProjections (classes : List (List MutConst)) idx := idx + 1 return projections -/-- Pure assembly of an already compiled mutual payload. Projection arrays -do not affect the serialized main-block codec but remain part of the exact +/-- Assembly of an already compiled mutual payload with the canonical sharing +under `limits`; fails exactly when the construction does. Projection arrays do +not affect the serialized main-block codec but remain part of the exact production result. -/ -def buildCompiledMutualBlock (classes : List (List MutConst)) - (payloads : Array Ixon.MutConst) (roots : Array Ixon.Expr) +def buildCompiledMutualBlock (limits : Ix.Sharing.Exact.Limits) + (classes : List (List MutConst)) (payloads : Array Ixon.MutConst) (metas : Array (Name × Ixon.ConstantMeta)) - (cache : BlockState) : BlockResult := + (cache : BlockState) : Except CompileError BlockResult := do if let some info := standaloneMutConstInfo? payloads then - let block := buildConstantWithSharing info roots cache.refs cache.univs - BlockResult.mk' block .empty - (buildStandaloneMutualProjections classes block metas) + let block ← buildConstantWithSharing limits info cache.refs cache.univs + pure (BlockResult.mk' block .empty + (buildStandaloneMutualProjections classes block metas)) else - let block := - buildConstantWithSharing (.muts payloads) roots cache.refs cache.univs - BlockResult.mk' block .empty - (buildMutualProjections classes (Address.blake3 (Ixon.ser block)) metas) + let block ← buildConstantWithSharing limits (.muts payloads) cache.refs cache.univs + pure (BlockResult.mk' block .empty + (buildMutualProjections classes (Address.blake3 (Ixon.ser block)) metas)) -/-- Read the finished table state and assemble a compiled mutual payload. -/ +/-- Read the finished table state and assemble a compiled mutual payload with +the compiler's canonical sharing (`CompileEnv.sharingLimits`). -/ def finishMutualCompilation (classes : List (List MutConst)) - (payloads : Array Ixon.MutConst) (roots : Array Ixon.Expr) + (payloads : Array Ixon.MutConst) (metas : Array (Name × Ixon.ConstantMeta)) : CompileM BlockResult := do - pure <| buildCompiledMutualBlock classes payloads roots metas - (← getBlockState) + let cache ← getBlockState + match buildCompiledMutualBlock (← read).1.sharingLimits classes payloads metas cache with + | .ok result => pure result + | .error e => throw e /-- Compile all mutual members and assemble their retained representatives. -/ def compileMutualPayload (classes : List (List MutConst)) : CompileM BlockResult := do - let (payloads, roots, metas) ← compileMutConsts classes - finishMutualCompilation classes payloads roots metas + let (payloads, _, metas) ← compileMutConsts classes + finishMutualCompilation classes payloads metas /-- Compile a mutual block and create projections for each constant. Returns the Muts block constant and projections for each name with metadata. -/ @@ -3227,11 +3215,10 @@ def buildInductiveProjections (i : InductiveVal) family. -/ def finishInductiveFamilyBlock (i : InductiveVal) (ind : Ixon.Inductive) (indMeta : Ixon.ConstantMeta) - (ctorMetaPairs : Array (Name × Ixon.ConstantMeta)) - (ctorExprs : Array Ixon.Expr) : CompileM BlockResult := do + (ctorMetaPairs : Array (Name × Ixon.ConstantMeta)) : CompileM BlockResult := do let cache ← getBlockState - let block := buildConstantWithSharing - (.muts #[.indc ind]) ctorExprs cache.refs cache.univs + let block ← buildBlockConstant + (.muts #[.indc ind]) cache.refs cache.univs let blockBytes := Ixon.ser block let blockAddr := Address.blake3 blockBytes let projections := @@ -3239,20 +3226,19 @@ def finishInductiveFamilyBlock (i : InductiveVal) pure (BlockResult.mk' block .empty projections) /-- Finish a compiled singleton payload using the current block tables, the -production sharing pass, and the canonical `BlockResult` serializer. -/ +compiler's canonical sharing (`buildBlockConstant`, roots derived from the +payload), and the canonical `BlockResult` serializer. -/ def finishConstantWithSharing (info : Ixon.ConstantInfo) - (rootExprs : Array Ixon.Expr) (blockMeta : Ixon.ConstantMeta := .empty) : - CompileM BlockResult := do + (blockMeta : Ixon.ConstantMeta := .empty) : CompileM BlockResult := do let cache ← getBlockState - let block := buildConstantWithSharing - info rootExprs cache.refs cache.univs + let block ← buildBlockConstant info cache.refs cache.univs pure (BlockResult.mk' block blockMeta) -/-- Finish a singleton declaration with the canonical sharing-root ordering -derived from its compiled `ConstantInfo`. -/ +/-- Finish a singleton declaration (`finishConstantWithSharing`; the sharing +roots are the payload's). -/ def finishConstantInfoWithSharing (info : Ixon.ConstantInfo) (blockMeta : Ixon.ConstantMeta := .empty) : CompileM BlockResult := - finishConstantWithSharing info (constantInfoRootExprs info) blockMeta + finishConstantWithSharing info blockMeta /-- Compile and finalize the payload of a singleton definition declaration. The outer singleton driver remains responsible for auditing and preseeding. -/ @@ -3328,9 +3314,9 @@ def compileRecursorInfo (recursorVal : RecursorVal) : CompileM BlockResult := do context and preseed have been installed. -/ def compileInductiveFamilyBlock (inductiveVal : InductiveVal) (ctorVals : Array ConstructorVal) : CompileM BlockResult := do - let (ind, indMeta, ctorMetaPairs, ctorExprs) ← + let (ind, indMeta, ctorMetaPairs, _) ← compileInductive inductiveVal ctorVals - finishInductiveFamilyBlock inductiveVal ind indMeta ctorMetaPairs ctorExprs + finishInductiveFamilyBlock inductiveVal ind indMeta ctorMetaPairs def compileInductiveFamilyInfo (inductiveVal : InductiveVal) (ctorVals : Array ConstructorVal) : CompileM BlockResult := do diff --git a/Ix/DecompileDriver.lean b/Ix/DecompileDriver.lean index 25430be8c..42deb39f5 100644 --- a/Ix/DecompileDriver.lean +++ b/Ix/DecompileDriver.lean @@ -466,6 +466,9 @@ structure Pass2Ctx where nameToAddr : Std.HashMap Ix.Name Address /-- Debug-track source env (Rust `stt.lean_env`). -/ origEnv? : Option (Std.HashMap Ix.Name Ix.ConstantInfo) + /-- Sharing limits of every recompile in the run (Rust + `stt.sharing_limits`). -/ + sharingLimits : Ix.Sharing.Exact.Limits /-- Mutable state threaded through Pass 2. -/ structure Pass2St where @@ -519,6 +522,7 @@ def Pass2Ctx.cenvFor (ctx : Pass2Ctx) { env := { consts := view } nameToNamed := ctx.ixonEnv.named nameToAddr := ctx.nameToAddr + sharingLimits := ctx.sharingLimits constants := {}, blobs := {}, totalBytes := 0 } /-- Run a `KBridgeM` action over the CURRENT work env, threading the @@ -649,7 +653,7 @@ def decompileBlockAuxGen (ctx : Pass2Ctx) (st₀ : Pass2St) let recMutConsts : List Ix.MutConst := (canonicalRecs.map fun (_, rv) => Ix.MutConst.recr rv).toList match roundtripBlock recMutConsts generatedConsts ctx.origEnv? - st.workEnv ctx.ixonEnv st.callSitePlans st.brecOnPlans st.belowPlans with + st.workEnv ctx.ixonEnv ctx.sharingLimits st.callSitePlans st.brecOnPlans st.belowPlans with | .ok roundtripped => for (n, ci) in roundtripped do if recMembers.contains n || st.workEnv.contains n then @@ -742,7 +746,7 @@ def decompileBlockAuxGen (ctx : Pass2Ctx) (st₀ : Pass2St) all := #[auxDef.name] } let allGen := baseGen.fold (fun m k v => m.insert k v) newGen match roundtripBlock [mc] allGen ctx.origEnv? st.workEnv ctx.ixonEnv - st.callSitePlans st.brecOnPlans st.belowPlans with + ctx.sharingLimits st.callSitePlans st.brecOnPlans st.belowPlans with | .ok roundtripped => if roundtripped.isEmpty then st := recoverOr ctx st auxDef.name allGen @@ -807,7 +811,7 @@ def decompileBlockAuxGen (ctx : Pass2Ctx) (st₀ : Pass2St) belowIndcMcs := [] if !belowIndcMcs.isEmpty then match roundtripBlock belowIndcMcs generatedConsts ctx.origEnv? - st.workEnv ctx.ixonEnv st.callSitePlans st.brecOnPlans st.belowPlans with + st.workEnv ctx.ixonEnv ctx.sharingLimits st.callSitePlans st.brecOnPlans st.belowPlans with | .ok roundtripped => st := insertAll st roundtripped | .error e => for bc in belowConsts do @@ -825,7 +829,7 @@ def decompileBlockAuxGen (ctx : Pass2Ctx) (st₀ : Pass2St) safety := if d.isUnsafe then .unsaf else .safe all := #[d.name] } match roundtripBlock [mc] generatedConsts ctx.origEnv? st.workEnv - ctx.ixonEnv st.callSitePlans st.brecOnPlans st.belowPlans with + ctx.ixonEnv ctx.sharingLimits st.callSitePlans st.brecOnPlans st.belowPlans with | .ok roundtripped => st := insertAll st roundtripped | .error e => st := recoverOr ctx st d.name generatedConsts @@ -854,7 +858,7 @@ def decompileBlockAuxGen (ctx : Pass2Ctx) (st₀ : Pass2St) if belowRecMembers.contains n then some (Ix.MutConst.recr rv) else none).toList match roundtripBlock mcs generatedConsts ctx.origEnv? st.workEnv - ctx.ixonEnv st.callSitePlans st.brecOnPlans st.belowPlans with + ctx.ixonEnv ctx.sharingLimits st.callSitePlans st.brecOnPlans st.belowPlans with | .ok roundtripped => st := insertAll st roundtripped | .error e => for (n, rv) in belowRecs do @@ -922,7 +926,7 @@ def decompileBlockAuxGen (ctx : Pass2Ctx) (st₀ : Pass2St) safety := if d.isUnsafe then .unsaf else .safe all := #[d.name] } match roundtripBlock [mc] generatedConsts ctx.origEnv? st.workEnv - ctx.ixonEnv st.callSitePlans st.brecOnPlans st.belowPlans with + ctx.ixonEnv ctx.sharingLimits st.callSitePlans st.brecOnPlans st.belowPlans with | .ok roundtripped => if roundtripped.isEmpty then match recoverAuxFromOriginal d.name ctx.ixonEnv st.workEnv @@ -949,9 +953,11 @@ def decompileBlockAuxGen (ctx : Pass2Ctx) (st₀ : Pass2St) return st /-- Pass 2 driver: group aux blocks, topo-sort by cross-block deps, and - regenerate each (decompile.rs:5060-5330 minus diagnostics). -/ + regenerate each (decompile.rs:5060-5330 minus diagnostics). Every + recompile runs under `sharingLimits`. -/ def decompileEnvPass2 (ixonEnv : Ixon.Env) (pass1 : Std.HashMap Ix.Name Ix.ConstantInfo) + (sharingLimits : Ix.Sharing.Exact.Limits) (origEnv? : Option (Std.HashMap Ix.Name Ix.ConstantInfo) := none) : Pass2St := Id.run do let mutsIndex := buildMutsPlanIndex ixonEnv @@ -961,7 +967,7 @@ def decompileEnvPass2 (ixonEnv : Ixon.Env) ixonEnv, mutsIndex nameToAddr := ixonEnv.named.fold (init := {}) fun m n named => m.insert n named.addr - origEnv? } + origEnv?, sharingLimits } -- name → block key (members + their ctors), then block deps -- (decompile.rs:5096-5133). let mut nameToBlock : Std.HashMap Ix.Name Ix.Name := {} @@ -1088,6 +1094,7 @@ def decompileEnvPass2 (ixonEnv : Ixon.Env) whole-env scale. -/ def decompileEnvPass2Parallel (ixonEnv : Ixon.Env) (pass1 : Std.HashMap Ix.Name Ix.ConstantInfo) + (sharingLimits : Ix.Sharing.Exact.Limits) (origEnv? : Option (Std.HashMap Ix.Name Ix.ConstantInfo) := none) (numWorkers : Nat := 16) : IO Pass2St := do @@ -1098,7 +1105,7 @@ def decompileEnvPass2Parallel (ixonEnv : Ixon.Env) ixonEnv, mutsIndex nameToAddr := ixonEnv.named.fold (init := {}) fun m n named => m.insert n named.addr - origEnv? } + origEnv?, sharingLimits } -- name → block key + block deps, exactly as the sequential driver. let mut nameToBlock : Std.HashMap Ix.Name Ix.Name := {} for (blockKey, (allNames, _)) in blocks do @@ -1285,10 +1292,12 @@ def decompileEnvPass2Parallel (ixonEnv : Ixon.Env) return st /-- Full decompile driver: Pass 1 (aux skipped) → Pass 1.5 flags → - Pass 2 regeneration/recovery. Returns the decompiled env, the - per-name errors from both passes, and the final Pass-2 state (plan - maps for callers that recompile). -/ + Pass 2 regeneration/recovery, whose recompiles run under + `sharingLimits`. Returns the decompiled env, the per-name errors from + both passes, and the final Pass-2 state (plan maps for callers that + recompile). -/ def decompileEnvFull (ixonEnv : Ixon.Env) + (sharingLimits : Ix.Sharing.Exact.Limits) (origEnv? : Option (Std.HashMap Ix.Name Ix.ConstantInfo) := none) : Std.HashMap Ix.Name Ix.ConstantInfo × Array (Ix.Name × String) × Pass2St := Id.run do let (pass1Raw, pass1Errs) := decompileAllParallel ixonEnv @@ -1297,18 +1306,24 @@ def decompileEnvFull (ixonEnv : Ixon.Env) let pass1 := match fixupInductiveFlags pass1Raw with | .ok fixed => fixed | .error _ => pass1Raw - let st := decompileEnvPass2 ixonEnv pass1 origEnv? + let st := decompileEnvPass2 ixonEnv pass1 sharingLimits origEnv? return (st.dstt, pass1Errs ++ st.errors, st) /-- `decompileEnvFull` with the wave-parallel Pass 2 (`decompileEnvPass2Parallel`). Same outputs — hash-identity is enforced by the whole-env decompile suites — with Pass-2 errors in - merge order rather than topo order. -/ + merge order rather than topo order. The recompiles run under the + compiler's sharing limits with the `IX_SHARING_LIMITS` override, read + once here (`Ix.CompileM.compilerSharingLimitsFromEnv`): an invalid + override fails the run before any work, as in Rust `rs_decompile_env`. -/ def decompileEnvFullParallel (ixonEnv : Ixon.Env) (origEnv? : Option (Std.HashMap Ix.Name Ix.ConstantInfo) := none) (numWorkers : Nat := 16) : IO (Std.HashMap Ix.Name Ix.ConstantInfo × Array (Ix.Name × String) × Pass2St) := do + let sharingLimits ← match ← Ix.CompileM.compilerSharingLimitsFromEnv with + | .ok l => pure l + | .error e => throw (IO.userError s!"decompileEnvFullParallel: {e}") -- `IX_DECOMPILE_WORKERS` overrides the worker count (memory/debug -- tuning); `0` selects the sequential Pass-2 driver. let numWorkers ← do @@ -1322,9 +1337,9 @@ def decompileEnvFullParallel (ixonEnv : Ixon.Env) | .ok fixed => fixed | .error _ => pass1Raw if numWorkers == 0 then - let st := decompileEnvPass2 ixonEnv pass1 origEnv? + let st := decompileEnvPass2 ixonEnv pass1 sharingLimits origEnv? return (st.dstt, pass1Errs ++ st.errors, st) - let st ← decompileEnvPass2Parallel ixonEnv pass1 origEnv? numWorkers + let st ← decompileEnvPass2Parallel ixonEnv pass1 sharingLimits origEnv? numWorkers return (st.dstt, pass1Errs ++ st.errors, st) end Ix.DecompileM diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean index 910c57500..1ad6a9ef4 100644 --- a/Ix/DecompileM.lean +++ b/Ix/DecompileM.lean @@ -38,7 +38,7 @@ def resolveIxName (names : Std.HashMap Address Ix.Name) (addr : Address) : Optio /-! ## Error Type -/ -/-- Decompilation error type. Variant order matches Rust DecompileError (tags 0–10). -/ +/-- Decompilation error type. Variant order matches Rust DecompileError (tags 0–11). -/ inductive DecompileError where | invalidRefIndex (idx : UInt64) (refsLen : Nat) (constant : String) | invalidUnivIndex (idx : UInt64) (univsLen : Nat) (constant : String) @@ -51,6 +51,13 @@ inductive DecompileError where | badBlobFormat (addr : Address) (expected : String) | badConstantFormat (msg : String) | serializeError (err : Ixon.SerializeError) + /-- `share idx` occurring in `metaSharing[entry]` outside that entry's + index space (`ConstantMeta.metaSharing`): with `primaryLen` primary + and `metaLen` metadata entries, the valid indices are + `idx < primaryLen + entry`. `idx ≥ primaryLen + metaLen` is out of + range; any other rejected index is a forward or self reference. -/ + | invalidMetaShareIndex (idx : UInt64) (entry : UInt64) (primaryLen : Nat) + (metaLen : Nat) (constant : String) deriving Repr, BEq def DecompileError.toString : DecompileError → String @@ -65,6 +72,14 @@ def DecompileError.toString : DecompileError → String | .badBlobFormat addr expected => s!"Bad blob format at {addr}, expected {expected}" | .badConstantFormat msg => s!"Bad constant format: {msg}" | .serializeError err => s!"Serialization error: {err}" + | .invalidMetaShareIndex idx entry p q c => + if idx.toNat ≥ p + q then + s!"Invalid metadata share index {idx} in metaSharing[{entry}] of '{c}': \ + out of range ({p} primary + {q} metadata entries)" + else + s!"Invalid metadata share index {idx} in metaSharing[{entry}] of '{c}': \ + forward or self reference (this entry may reference only indices below \ + {p + entry.toNat})" instance : ToString DecompileError := ⟨DecompileError.toString⟩ @@ -86,7 +101,9 @@ structure BlockCtx where /-- `ConstantMeta.metaSharing` of the constant being decompiled: collapsed call-site arguments (and rewritten original heads), indexed by `CallSiteEntry.collapsed.sharingIdx` / `origHead` — - distinct from the block's primary `sharing` table. -/ + distinct from the block's primary `sharing` table. A `share` inside + one of these expressions is read in the extended index space + (`ShareScope.metaEntry`). -/ metaSharing : Array Ixon.Expr := #[] /-- Level-spelling patches of the constant being decompiled, keyed by metadata-arena index (canonicity §10.6): a patched `sort`/`ref`/ @@ -98,9 +115,36 @@ structure BlockCtx where univPatches : Std.HashMap UInt64 (Array UInt64) := {} deriving Inhabited -/-- Per-block mutable state (caches). -/ +/-- The index space a `share i` node is read in: the extended index space + of `ConstantMeta.metaSharing`. With `p` primary entries + (`BlockCtx.sharing`) and `q` metadata entries (`BlockCtx.metaSharing`): + + * `primary`: a primary expression (a root or a primary table entry). + `share i` denotes `sharing[i]`; `i ≥ p` is `invalidShareIndex`. + Metadata never changes how a primary expression decodes. + * `metaEntry j`: an expression of `metaSharing[j]`. `share i` denotes + primary entry `i` when `i < p` (read in `primary`: shares nested in a + primary entry stay primary) and `metaSharing[i - p]` when + `p ≤ i < p + j` (read in `metaEntry (i - p)`). Any other index is + `invalidMetaShareIndex`: `i ≥ p + q` is out of range, + `p + j ≤ i < p + q` a forward or self reference. The entry index + strictly decreases along metadata-to-metadata resolution, so + expansion is well founded. + + Call-site references (`CallSiteEntry.collapsed sharingIdx`, + `origHead = some (sharingIdx, _)`) index `metaSharing` directly (no + offset by `p`) and read the entry in scope `metaEntry sharingIdx`. + Mirrors Rust `decompile::ShareScope`. -/ +inductive ShareScope where + | primary + | metaEntry (entry : Nat) + deriving BEq, Hashable, Repr, Inhabited + +/-- Per-block mutable state (caches). The expression cache is keyed by the + share scope too: the same Ixon expression may be valid in a metadata + scope and invalid in the primary scope. -/ structure BlockState where - exprCache : Std.HashMap (Ixon.Expr × UInt64) Ix.Expr := {} + exprCache : Std.HashMap (Ixon.Expr × UInt64 × ShareScope) Ix.Expr := {} univCache : Std.HashMap UInt64 Ix.Level := {} deriving Inhabited @@ -217,20 +261,11 @@ def BlobCursor.readByte (c : BlobCursor) : DecompileM (UInt8 × BlobCursor) := pure (c.bytes.get! c.pos, { c with pos := c.pos + 1 }) else throw (.badConstantFormat "BlobCursor: unexpected EOF") -def BlobCursor.readTag0 (c : BlobCursor) : DecompileM (UInt64 × BlobCursor) := do - let (head, c) ← c.readByte - if head < 128 then pure (head.toUInt64, c) - else - let extraBytes := (head % 128).toNat + 1 - if c.pos + extraBytes > c.bytes.size then - throw (.badConstantFormat "BlobCursor.readTag0: need more bytes") - let mut val : UInt64 := 0 - let mut cur := c - for i in [:extraBytes] do - let (b, c') ← cur.readByte - val := val ||| (b.toUInt64 <<< (i * 8).toUInt64) - cur := c' - pure (val, cur) +/-- A TagN (`f = 0`) integer, read by `Ixon.getTagN 0`. -/ +def BlobCursor.readTagN0 (c : BlobCursor) : DecompileM (UInt64 × BlobCursor) := + match (Ixon.getTagN 0).run { idx := c.pos, bytes := c.bytes } with + | .ok t s => pure (t.value, { c with pos := s.idx }) + | .error e _ => throw (.badConstantFormat s!"BlobCursor.readTagN0: {e}") def BlobCursor.readAddr (c : BlobCursor) : DecompileM (Address × BlobCursor) := if c.pos + 32 ≤ c.bytes.size then @@ -248,8 +283,8 @@ def resolveStringFromBlob (addr : Address) : DecompileM String := do def deserializeSubstring (c : BlobCursor) : DecompileM (Ix.Substring × BlobCursor) := do let (strAddr, c) ← c.readAddr let s ← resolveStringFromBlob strAddr - let (startPos, c) ← c.readTag0 - let (stopPos, c) ← c.readTag0 + let (startPos, c) ← c.readTagN0 + let (stopPos, c) ← c.readTagN0 pure (⟨s, startPos.toNat, stopPos.toNat⟩, c) def deserializeSourceInfo (c : BlobCursor) : DecompileM (Ix.SourceInfo × BlobCursor) := do @@ -257,13 +292,13 @@ def deserializeSourceInfo (c : BlobCursor) : DecompileM (Ix.SourceInfo × BlobCu match tag with | 0 => let (leading, c) ← deserializeSubstring c - let (leadingPos, c) ← c.readTag0 + let (leadingPos, c) ← c.readTagN0 let (trailing, c) ← deserializeSubstring c - let (trailingPos, c) ← c.readTag0 + let (trailingPos, c) ← c.readTagN0 pure (.original leading leadingPos.toNat trailing trailingPos.toNat, c) | 1 => - let (start, c) ← c.readTag0 - let (stop, c) ← c.readTag0 + let (start, c) ← c.readTagN0 + let (stop, c) ← c.readTagN0 let (canonical, c) ← c.readByte pure (.synthetic start.toNat stop.toNat (canonical != 0), c) | 2 => pure (.none, c) @@ -279,7 +314,7 @@ def deserializePreresolved (c : BlobCursor) : DecompileM (Ix.SyntaxPreresolved | 1 => let (nameAddr, c) ← c.readAddr let name ← resolveNameFromBlob nameAddr - let (count, c) ← c.readTag0 + let (count, c) ← c.readTagN0 let mut fields : Array String := #[] let mut cur := c for _ in [:count.toNat] do @@ -298,7 +333,7 @@ partial def deserializeSyntax (c : BlobCursor) : DecompileM (Ix.Syntax × BlobCu let (info, c) ← deserializeSourceInfo c let (kindAddr, c) ← c.readAddr let kind ← resolveNameFromBlob kindAddr - let (argCount, c) ← c.readTag0 + let (argCount, c) ← c.readTagN0 let mut args : Array Ix.Syntax := #[] let mut cur := c for _ in [:argCount.toNat] do @@ -316,7 +351,7 @@ partial def deserializeSyntax (c : BlobCursor) : DecompileM (Ix.Syntax × BlobCu let (rawVal, c) ← deserializeSubstring c let (valAddr, c) ← c.readAddr let val ← resolveNameFromBlob valAddr - let (prCount, c) ← c.readTag0 + let (prCount, c) ← c.readTagN0 let mut preresolved : Array Ix.SyntaxPreresolved := #[] let mut cur := c for _ in [:prCount.toNat] do @@ -360,42 +395,110 @@ def applyMdata (expr : Ix.Expr) (layers : Array (Array (Ix.Name × Ix.DataValue) def getArenaNode (idx : UInt64) : DecompileM ExprMetaData := do pure ((← getCtx).arena.nodes[idx.toNat]?.getD .leaf) +/-! ## Share Resolution (extended index space of `metaSharing`) -/ + +/-- Resolve `share idx` read in `scope` (see `ShareScope`): the target + expression and the scope its own `share` nodes are read in. `label` + names the reading site in errors. Mirrors Rust + `BlockCache::resolve_share`. -/ +def resolveShareIn (ctx : BlockCtx) (scope : ShareScope) (idx : UInt64) + (label : String := "") : Except DecompileError (Ixon.Expr × ShareScope) := + let p := ctx.sharing.size + let i := idx.toNat + match scope with + | .primary => + match ctx.sharing[i]? with + | some e => .ok (e, .primary) + | none => .error (.invalidShareIndex idx p label) + | .metaEntry entry => + if h : i < p then .ok (ctx.sharing[i], .primary) + else + let target := if i - p < entry then ctx.metaSharing[i - p]? else none + match target with + | some e => .ok (e, .metaEntry (i - p)) + | none => .error (.invalidMetaShareIndex idx entry.toUInt64 p + ctx.metaSharing.size label) + +/-- `resolveShareIn` against the current block context. -/ +def resolveShare (scope : ShareScope) (idx : UInt64) (label : String := "") : + DecompileM (Ixon.Expr × ShareScope) := do + match resolveShareIn (← getCtx) scope idx label with + | .ok r => pure r + | .error e => throw e + +/-- Pointer identity of an expression object (a visited-set key: equal + pointers are the same subterm). -/ +private def exprAddr (e : Ixon.Expr) : USize := unsafe ptrAddrUnsafe e + +/-- Well-foundedness of a `metaSharing` table against `p` primary entries: + every `share i` occurring in `metaSharing[j]` has `i < p + j` (a primary + entry, or a metadata entry BEFORE `j`). Checked when a block context is + built (`withFreshBlock`), so a malformed table is rejected even where + decompilation never reads it. The first violation in entry order, then + in left-to-right pre-order, is reported as `invalidMetaShareIndex` + (Rust `validate_meta_sharing` walks in the same order). Iterative; the + walk does not expand `share` nodes. Each shared node (by pointer) is + visited once across the table, so the walk is linear in the DAG size of + an in-memory table: a node seen before passed under a bound no larger + than the current one, so the first violation is unchanged. -/ +def validateMetaSharing (p : Nat) (metaSharing : Array Ixon.Expr) + (label : String := "metaSharing") : Except DecompileError Unit := do + let mut seen : Std.HashSet USize := {} + for h : j in [:metaSharing.size] do + let mut stack : Array Ixon.Expr := #[metaSharing[j]] + while !stack.isEmpty do + let e := stack.back! + stack := stack.pop + let ptr := exprAddr e + if seen.contains ptr then continue + seen := seen.insert ptr + match e with + | .share i => + if i.toNat ≥ p + j then + throw (.invalidMetaShareIndex i j.toUInt64 p metaSharing.size label) + | .app f a => stack := stack.push a |>.push f + | .lam _ t b | .all _ _ t b => stack := stack.push b |>.push t + | .letE _ t v b => stack := stack.push b |>.push v |>.push t + | .prj _ _ v => stack := stack.push v + | .sort _ | .var _ | .ref .. | .recur .. | .str _ | .nat _ => pure () + /-- Collect an Ixon App telescope for call-site replay, transparently expanding `.share` nodes along the SPINE (Rust - `collect_ixon_telescope_expanding_shares`, decompile.rs:745). - Arguments are returned in application order and are NOT - share-expanded — each is decompiled individually, where `.share` - handling applies as usual. -/ -def collectIxonTelescopeExpandingShares (e : Ixon.Expr) - : DecompileM (Ixon.Expr × Array Ixon.Expr) := do - let ctx ← getCtx - let mut args : Array Ixon.Expr := #[] + `collect_ixon_telescope_expanding_shares`). `scope` is the share scope + of `e`. Arguments are returned in application order, each with the + scope it is read in (a spine `share` can lead from a metadata + expression into a primary entry), and are NOT share-expanded — each is + decompiled individually, where `.share` handling applies as usual. -/ +def collectIxonTelescopeExpandingShares (scope : ShareScope) (e : Ixon.Expr) + : DecompileM (Ixon.Expr × Array (Ixon.Expr × ShareScope)) := do + let mut args : Array (Ixon.Expr × ShareScope) := #[] let mut cur := e + let mut curScope := scope repeat match cur with | .share idx => - match ctx.sharing[idx.toNat]? with - | some s => cur := s - | none => throw (.invalidShareIndex idx ctx.sharing.size "callSite telescope") + let (s, sScope) ← resolveShare curScope idx "callSite telescope" + cur := s + curScope := sScope | .app f a => - args := args.push a + args := args.push (a, curScope) cur := f | _ => break return (cur, args.reverse) -/-- Decompile an expression to Ix.Expr with arena-based metadata. -/ -partial def decompileExpr (e : Ixon.Expr) (arenaIdx : UInt64) : DecompileM Ix.Expr := do - -- 1. Expand Share transparently +/-- Decompile an expression read in share scope `scope` to Ix.Expr with + arena-based metadata. -/ +partial def decompileExprIn (scope : ShareScope) (e : Ixon.Expr) (arenaIdx : UInt64) : + DecompileM Ix.Expr := do + -- 1. Expand Share transparently (same arena index, target's scope) match e with | .share idx => - let ctx ← getCtx - match ctx.sharing[idx.toNat]? with - | some sharedExpr => decompileExpr sharedExpr arenaIdx - | none => throw (.invalidShareIndex idx ctx.sharing.size "") + let (sharedExpr, sharedScope) ← resolveShare scope idx + decompileExprIn sharedScope sharedExpr arenaIdx | _ => -- Check cache - let cacheKey := (e, arenaIdx) + let cacheKey := (e, arenaIdx, scope) if let some cached := (← get).exprCache.get? cacheKey then return cached -- 2. Follow mdata chain @@ -418,9 +521,10 @@ partial def decompileExpr (e : Ixon.Expr) (arenaIdx : UInt64) : DecompileM Ix.Ex match node with | .callSite .. | .etaCallSite .. => let ctx ← getCtx - let annotated ← match Ix.SemanticContract.containsIxon ctx.sharing e with + let annotated ← match Ix.SemanticContract.containsIxon + (fun s idx => resolveShareIn ctx s idx "semantic scan") scope e with | .ok annotated => pure annotated - | .error error => throw (.badConstantFormat error) + | .error error => throw error if annotated then throw (.badConstantFormat "optional call-site replay would rewrite a semantic contract") | _ => pure () @@ -436,20 +540,22 @@ partial def decompileExpr (e : Ixon.Expr) (arenaIdx : UInt64) : DecompileM Ix.Ex | .etaCallSite nSynth nameAddr entries canonMeta _wrapperMeta, _ => do let ctx ← getCtx let mut body := e + let mut bodyScope := scope for _ in [0:nSynth.toNat] do repeat match body with | .share idx => - match ctx.sharing[idx.toNat]? with - | some shared => body := shared - | none => throw (.invalidShareIndex idx ctx.sharing.size - "etaCallSite wrapper") + let (shared, sharedScope) ← resolveShare bodyScope idx + "etaCallSite wrapper" + body := shared + bodyScope := sharedScope | _ => break match body with | .lam _ _ b => body := b | _ => throw (.badConstantFormat s!"EtaCallSite: expected \ {nSynth} synthesized lambdas") - let (headIxon, canonicalArgs) ← collectIxonTelescopeExpandingShares body + let (headIxon, canonicalArgs) ← + collectIxonTelescopeExpandingShares bodyScope body if canonMeta.size != canonicalArgs.size then throw (.badConstantFormat s!"EtaCallSite: {canonMeta.size} canonical \ metadata entries but body telescope has {canonicalArgs.size} args") @@ -466,13 +572,15 @@ metadata entries but body telescope has {canonicalArgs.size} args") let arg ← match entry with | .kept canonIdx metaIdx => match canonicalArgs[canonIdx.toNat]? with - | some argIxon => decompileExpr argIxon metaIdx + | some (argIxon, argScope) => decompileExprIn argScope argIxon metaIdx | none => throw (.badConstantFormat s!"EtaCallSite: Kept \ canonIdx {canonIdx} out of bounds (body telescope has \ {canonicalArgs.size} args)") | .collapsed sharingIdx metaIdx => + -- Direct `metaSharing` index (no offset by the primary length); + -- the entry's own shares are read in its metadata scope. match ctx.metaSharing[sharingIdx.toNat]? with - | some shared => decompileExpr shared metaIdx + | some shared => decompileExprIn (.metaEntry sharingIdx.toNat) shared metaIdx | none => throw (.invalidShareIndex sharingIdx ctx.metaSharing.size "etaCallSite collapsed") spine := Ix.Expr.mkApp spine @@ -481,17 +589,18 @@ canonIdx {canonIdx} out of bounds (body telescope has \ -- Call-site surgery replay: reconstruct the SOURCE-order application -- spine from the canonical Ixon spine plus the metadata extension - -- tables (Rust decompile.rs:975-1120). Entries walk in source order: - -- Kept entries index the canonical telescope by `canonIdx`; Collapsed - -- entries index `ConstantMeta.metaSharing` (NOT the block's primary - -- sharing table). `origHead` restores the pre-rewrite head of - -- evaporated-aux sites; otherwise the head is rebuilt from the + -- tables (Rust `decompile_expr`, CallSite arm). Entries walk in source + -- order: Kept entries index the canonical telescope by `canonIdx`; + -- Collapsed entries index `ConstantMeta.metaSharing` directly (NOT the + -- block's primary sharing table, no offset by its length) and are read + -- in that entry's metadata scope. `origHead` restores the pre-rewrite + -- head of evaporated-aux sites; otherwise the head is rebuilt from the -- CallSite name plus the canonical head's level args. Mdata wraps the -- WHOLE reassembled spine, matching how the compiler produced the -- node. | .callSite nameAddr entries _canonMeta origHead, _ => do let ctx ← getCtx - let (headIxon, canonicalArgs) ← collectIxonTelescopeExpandingShares e + let (headIxon, canonicalArgs) ← collectIxonTelescopeExpandingShares scope e -- Most CallSites have one Kept entry per canonical arg; split-SCC -- minor adaptation stores a synthesized wrapper canonically with the -- source arg Collapsed, so canonical args may OUTNUMBER Kept @@ -508,7 +617,7 @@ but canonical telescope has only {canonicalArgs.size} args") -- Head-rewritten site: the ORIGINAL head expression (source -- name + source level args) lives in metaSharing. match ctx.metaSharing[sharingIdx.toNat]? with - | some shared => decompileExpr shared headMetaIdx + | some shared => decompileExprIn (.metaEntry sharingIdx.toNat) shared headMetaIdx | none => throw (.invalidShareIndex sharingIdx ctx.metaSharing.size "callSite origHead") @@ -531,8 +640,8 @@ but canonical telescope has only {canonicalArgs.size} args") match entry with | .kept canonIdx metaIdx => match canonicalArgs[canonIdx.toNat]? with - | some argIxon => - spine := Ix.Expr.mkApp spine (← decompileExpr argIxon metaIdx) + | some (argIxon, argScope) => + spine := Ix.Expr.mkApp spine (← decompileExprIn argScope argIxon metaIdx) | none => throw (.badConstantFormat s!"CallSite: Kept canonIdx \ {canonIdx} out of bounds (canonical telescope has \ @@ -540,7 +649,8 @@ but canonical telescope has only {canonicalArgs.size} args") | .collapsed sharingIdx metaIdx => match ctx.metaSharing[sharingIdx.toNat]? with | some shared => - spine := Ix.Expr.mkApp spine (← decompileExpr shared metaIdx) + spine := Ix.Expr.mkApp spine + (← decompileExprIn (.metaEntry sharingIdx.toNat) shared metaIdx) | none => throw (.invalidShareIndex sharingIdx ctx.metaSharing.size "callSite collapsed") @@ -602,62 +712,62 @@ but canonical telescope has only {canonicalArgs.size} args") -- App with arena metadata | .app funIdx argIdx, .app fn arg => do - let fnExpr ← decompileExpr fn funIdx - let argExpr ← decompileExpr arg argIdx + let fnExpr ← decompileExprIn scope fn funIdx + let argExpr ← decompileExprIn scope arg argIdx pure (applyMdata (Ix.Expr.mkApp fnExpr argExpr) mdataLayers) | _, .app fn arg => do - let fnExpr ← decompileExpr fn UInt64.MAX - let argExpr ← decompileExpr arg UInt64.MAX + let fnExpr ← decompileExprIn scope fn UInt64.MAX + let argExpr ← decompileExprIn scope arg UInt64.MAX pure (applyMdata (Ix.Expr.mkApp fnExpr argExpr) mdataLayers) -- Lam with arena metadata | .binder nameAddr info tyChild bodyChild, .lam _ ty body => do let binderName ← lookupNameAddrOrAnon nameAddr - let tyExpr ← decompileExpr ty tyChild - let bodyExpr ← decompileExpr body bodyChild + let tyExpr ← decompileExprIn scope ty tyChild + let bodyExpr ← decompileExprIn scope body bodyChild pure (applyMdata (Ix.Expr.mkLam binderName tyExpr bodyExpr info) mdataLayers) | _, .lam _ ty body => do - let tyExpr ← decompileExpr ty UInt64.MAX - let bodyExpr ← decompileExpr body UInt64.MAX + let tyExpr ← decompileExprIn scope ty UInt64.MAX + let bodyExpr ← decompileExprIn scope body UInt64.MAX pure (applyMdata (Ix.Expr.mkLam Ix.Name.mkAnon tyExpr bodyExpr .default) mdataLayers) -- ForallE with arena metadata | .binder nameAddr info tyChild bodyChild, .all _ _ ty body => do let binderName ← lookupNameAddrOrAnon nameAddr - let tyExpr ← decompileExpr ty tyChild - let bodyExpr ← decompileExpr body bodyChild + let tyExpr ← decompileExprIn scope ty tyChild + let bodyExpr ← decompileExprIn scope body bodyChild pure (applyMdata (Ix.Expr.mkForallE binderName tyExpr bodyExpr info) mdataLayers) | _, .all _ _ ty body => do - let tyExpr ← decompileExpr ty UInt64.MAX - let bodyExpr ← decompileExpr body UInt64.MAX + let tyExpr ← decompileExprIn scope ty UInt64.MAX + let bodyExpr ← decompileExprIn scope body UInt64.MAX pure (applyMdata (Ix.Expr.mkForallE Ix.Name.mkAnon tyExpr bodyExpr .default) mdataLayers) -- Let with arena metadata | .letBinder nameAddr tyChild valChild bodyChild, .letE nonDep ty val body => do let letName ← lookupNameAddrOrAnon nameAddr - let tyExpr ← decompileExpr ty tyChild - let valExpr ← decompileExpr val valChild - let bodyExpr ← decompileExpr body bodyChild + let tyExpr ← decompileExprIn scope ty tyChild + let valExpr ← decompileExprIn scope val valChild + let bodyExpr ← decompileExprIn scope body bodyChild pure (applyMdata (Ix.Expr.mkLetE letName tyExpr valExpr bodyExpr nonDep.nonDep) mdataLayers) | _, .letE nonDep ty val body => do - let tyExpr ← decompileExpr ty UInt64.MAX - let valExpr ← decompileExpr val UInt64.MAX - let bodyExpr ← decompileExpr body UInt64.MAX + let tyExpr ← decompileExprIn scope ty UInt64.MAX + let valExpr ← decompileExprIn scope val UInt64.MAX + let bodyExpr ← decompileExprIn scope body UInt64.MAX pure (applyMdata (Ix.Expr.mkLetE Ix.Name.mkAnon tyExpr valExpr bodyExpr nonDep.nonDep) mdataLayers) -- Prj with arena metadata | .prj structNameAddr child, .prj _typeRefIdx fieldIdx val => do let typeName ← lookupNameAddr structNameAddr - let valExpr ← decompileExpr val child + let valExpr ← decompileExprIn scope val child pure (applyMdata (Ix.Expr.mkProj typeName fieldIdx.toNat valExpr) mdataLayers) | _, .prj typeRefIdx fieldIdx val => do let typeName ← getRef typeRefIdx >>= lookupConstName - let valExpr ← decompileExpr val UInt64.MAX + let valExpr ← decompileExprIn scope val UInt64.MAX pure (applyMdata (Ix.Expr.mkProj typeName fieldIdx.toNat valExpr) mdataLayers) | _, .share _ => throw (.badConstantFormat "unexpected Share in decompileExpr") @@ -665,6 +775,11 @@ but canonical telescope has only {canonicalArgs.size} args") modify fun s => { s with exprCache := s.exprCache.insert cacheKey result } pure result +/-- Decompile a primary expression (a constant's root) to Ix.Expr with + arena-based metadata. -/ +def decompileExpr (e : Ixon.Expr) (arenaIdx : UInt64) : DecompileM Ix.Expr := + decompileExprIn .primary e arenaIdx + /-! ## Type Conversion Helpers -/ def toIxSafety : DefinitionSafety → Lean.DefinitionSafety @@ -739,8 +854,10 @@ def decompileMetaCtx (cMeta : ConstantMeta) : DecompileM (Array Ix.Name) := do wrapper. `metaRefs`/`metaUnivs` extend the primary tables — the documented virtual-address contract (mirrors Rust `load_meta_extensions`); `metaSharing` rides its own dedicated field - for surgery replay. The context is rebuilt per constant, so - extensions never leak across sibling constants of a block. -/ + for surgery replay, and `share` nodes inside it are read in the + extended index space (`ShareScope`), never appended to `sharing`. The + context is rebuilt per constant, so extensions never leak across + sibling constants of a block. -/ def mkBlockCtx (cnst : Constant) (mutCtx : Array Ix.Name) (univParams : Array Ix.Name) (arena : ExprMetaArena) (cMeta : ConstantMeta := {}) : BlockCtx := @@ -751,15 +868,22 @@ def mkBlockCtx (cnst : Constant) (mutCtx : Array Ix.Name) univPatches := cMeta.univPatches.foldl (init := {}) fun m p => m.insert p.arenaIdx p.univIdxs } -/-- Run with fresh block context and state. -/ -def withFreshBlock (cnst : Constant) (mutCtx : Array Ix.Name) +/-- Run with fresh block context and state. The constant's `metaSharing` + is checked against its primary table first (`validateMetaSharing`, whose + errors name the constant `name`), mirroring Rust + `BlockCache::load_meta_extensions`. -/ +def withFreshBlock (name : Ix.Name) (cnst : Constant) (mutCtx : Array Ix.Name) (univParams : Array Ix.Name) (arena : ExprMetaArena) (cMeta : ConstantMeta := {}) (m : DecompileM α) : DecompileM α := do let env ← getEnv - match DecompileM.run env (mkBlockCtx cnst mutCtx univParams arena cMeta) {} m with - | .ok (a, _) => pure a + let ctx := mkBlockCtx cnst mutCtx univParams arena cMeta + match validateMetaSharing ctx.sharing.size ctx.metaSharing name.pretty with | .error e => throw e + | .ok () => + match DecompileM.run env ctx {} m with + | .ok (a, _) => pure a + | .error e => throw e /-! ## Constant Decompilers → Ix.ConstantInfo -/ @@ -785,7 +909,7 @@ def decompileDefinition (d : Ixon.Definition) (cnst : Constant) (cMeta : Constan | some named => named.hints.getD .opaque | none => .opaque let (arena, typeRoot) := getArenaAndTypeRoot cMeta - withFreshBlock cnst mutCtx univParams arena (cMeta := cMeta) do + withFreshBlock name cnst mutCtx univParams arena (cMeta := cMeta) do let typeExpr ← decompileExpr d.typ typeRoot let valueExpr ← decompileExpr d.value valueRoot let cv : Ix.ConstantVal := { name, levelParams := univParams, type := typeExpr } @@ -799,7 +923,7 @@ def decompileAxiom (a : Ixon.Axiom) (cnst : Constant) (cMeta : ConstantMeta) let name ← decompileMetaName cMeta let univParams ← decompileMetaLevels cMeta let (arena, typeRoot) := getArenaAndTypeRoot cMeta - withFreshBlock cnst #[] univParams arena (cMeta := cMeta) do + withFreshBlock name cnst #[] univParams arena (cMeta := cMeta) do let typeExpr ← decompileExpr a.typ typeRoot pure (.axiomInfo { cnst := { name, levelParams := univParams, type := typeExpr }, isUnsafe := a.isUnsafe }) @@ -808,7 +932,7 @@ def decompileQuotient (q : Ixon.Quotient) (cnst : Constant) (cMeta : ConstantMet let name ← decompileMetaName cMeta let univParams ← decompileMetaLevels cMeta let (arena, typeRoot) := getArenaAndTypeRoot cMeta - withFreshBlock cnst #[] univParams arena (cMeta := cMeta) do + withFreshBlock name cnst #[] univParams arena (cMeta := cMeta) do let typeExpr ← decompileExpr q.typ typeRoot pure (.quotInfo { cnst := { name, levelParams := univParams, type := typeExpr }, kind := toIxQuotKind q.kind }) @@ -818,7 +942,7 @@ def decompileConstructor (ctor : Ixon.Constructor) (cnst : Constant) let name ← decompileMetaName cMeta let univParams ← decompileMetaLevels cMeta let (arena, typeRoot) := getArenaAndTypeRoot cMeta - withFreshBlock cnst #[] univParams arena (cMeta := cMeta) do + withFreshBlock name cnst #[] univParams arena (cMeta := cMeta) do let typeExpr ← decompileExpr ctor.typ typeRoot pure { cnst := { name, levelParams := univParams, type := typeExpr }, induct := inductName, cidx := ctor.cidx.toNat, @@ -835,7 +959,7 @@ def decompileRecursor (rec : Ixon.Recursor) (cnst : Constant) (cMeta : ConstantM | .recr _ _ rules _ _ _ _ ruleRoots => (ruleRoots, rules) | _ => (#[], #[]) let (arena, typeRoot) := getArenaAndTypeRoot cMeta - withFreshBlock cnst mutCtx univParams arena (cMeta := cMeta) do + withFreshBlock name cnst mutCtx univParams arena (cMeta := cMeta) do let typeExpr ← decompileExpr rec.typ typeRoot let ruleNames ← ruleAddrs.mapM lookupNameAddr let mut rules : Array Ix.RecursorRule := #[] @@ -859,7 +983,7 @@ def decompileInductive (ind : Ixon.Inductive) (cnst : Constant) (cMeta : Constan let ctorNameAddrs := match cMeta.info with | .indc _ _ ctors .. => ctors | _ => #[] let (arena, typeRoot) := getArenaAndTypeRoot cMeta - let typeExpr ← withFreshBlock cnst mutCtx univParams arena (cMeta := cMeta) do + let typeExpr ← withFreshBlock name cnst mutCtx univParams arena (cMeta := cMeta) do decompileExpr ind.typ typeRoot let env ← getEnv let mut ctors : Array Ix.ConstructorVal := #[] diff --git a/Ix/DecompileRoundtrip.lean b/Ix/DecompileRoundtrip.lean index eb3b29701..a4799ccdf 100644 --- a/Ix/DecompileRoundtrip.lean +++ b/Ix/DecompileRoundtrip.lean @@ -196,7 +196,9 @@ private def decompileIndcEntries (denv : DecompileEnv) Parameter mapping (see the Rust signature at decompile.rs:2692-2698): where Rust reads `stt.env.named` / `stt.env.get_const` this uses `ixonEnv.named` / `ixonEnv.getConst?`; where it reads `dstt.env` this - uses `workEnv`; `orig_env` (the debug-track source env) is `origEnv?`. + uses `workEnv`; `orig_env` (the debug-track source env) is `origEnv?`; + `stt.sharing_limits` (the run's sharing limits, read once by the + driver) is `sharingLimits`. The trailing optional plan maps mirror `stt.call_site_plans` / `stt.brec_on_call_site_plans` / `stt.below_call_site_plans`, which in Rust ride along inside `stt` (populated by plan rehydration); @@ -215,6 +217,7 @@ def roundtripBlock (consts : List Ix.MutConst) (origEnv? : Option (Std.HashMap Ix.Name Ix.ConstantInfo)) (workEnv : Std.HashMap Ix.Name Ix.ConstantInfo) (ixonEnv : Ixon.Env) + (sharingLimits : Ix.Sharing.Exact.Limits) (callSitePlans : Std.HashMap Ix.Name Ix.AuxGen.CallSitePlan := {}) (brecOnCallSitePlans : Std.HashMap Ix.Name Ix.AuxGen.BRecOnCallSitePlan := {}) (belowCallSitePlans : Std.HashMap Ix.Name Ix.AuxGen.BRecOnCallSitePlan := {}) @@ -230,6 +233,7 @@ def roundtripBlock (consts : List Ix.MutConst) let cenv : Ix.CompileM.CompileEnv := { Ix.CompileM.CompileEnv.new { consts := workEnv } with nameToNamed := ixonEnv.named + sharingLimits nameToAddr := ixonEnv.named.fold (init := {}) fun m n named => m.insert n named.addr callSitePlans := callSitePlans diff --git a/Ix/IxVM/FunctionGroups.lean b/Ix/IxVM/FunctionGroups.lean index d21f786c3..4b42b2200 100644 --- a/Ix/IxVM/FunctionGroups.lean +++ b/Ix/IxVM/FunctionGroups.lean @@ -134,8 +134,8 @@ def functionGroups : Array (String × Array String) := #[ "rbtree_map_insert.G" ]), ("ixvm_group_11", #[ - "put_tag0", - "put_tag4", + "put_tagn0", + "put_tagn4", "put_definition_proj", "convert_definition", "level_reduce", @@ -147,7 +147,7 @@ def functionGroups : Array (String × Array String) := #[ "list_reverse.G" ]), ("ixvm_group_12", #[ - "put_tag2", + "put_tagn2", "univ_succ_base", "put_recursor_rule", "put_mut_const", @@ -339,7 +339,7 @@ def functionGroups : Array (String × Array String) := #[ "peel_n_foralls" ]), ("ixvm_group_25", #[ - "get_tag2", + "get_tagn2", "get_constructor_proj", "level_max", "whnf_iota_major", diff --git a/Ix/IxVM/Ixon.lean b/Ix/IxVM/Ixon.lean index 744784aad..30a38234d 100644 --- a/Ix/IxVM/Ixon.lean +++ b/Ix/IxVM/Ixon.lean @@ -6,7 +6,7 @@ public section namespace IxVM def ixon := ⟦ - -- Ixon v3 keeps usage, ownership, and locality independent. + -- Ixon keeps usage, ownership, and locality independent. enum Uses { Erased, Linear, diff --git a/Ix/IxVM/IxonDeserialize.lean b/Ix/IxVM/IxonDeserialize.lean index 6956d2375..a1dce3bfe 100644 --- a/Ix/IxVM/IxonDeserialize.lean +++ b/Ix/IxVM/IxonDeserialize.lean @@ -29,84 +29,102 @@ def ixonDeserialize := ⟦ } -- ============================================================================ - -- Tag parsing + -- TagN integers (`Ixon.getTagN`) -- ============================================================================ - -- Tag0: [large:1][size:7] - fn get_tag0(stream: ByteStream) -> (U64, ByteStream) { + -- Every integer of the wire format is a TagN integer: one header byte + -- `[flag : f bits][payload : r = 8 - f bits]` (f = 4 for expression, + -- constant and claim headers, 2 for universes, 0 for counts and indices) + -- followed by 0, 1, 2, 3, 4 or 8 little-endian bytes. With L the top + -- payload bit, M the next one, c the low r - 2 bits and h = 2^(r - 2): + -- L = 0 rung 1: the low r - 1 payload bits, [0, R1), R1 = 2h + -- L = 1, M = 0 rung 2: R1 + 256 c + one byte, [R1, R2), R2 = 258h + -- L = 1, M = 1 code c = 0, 1, 2, 3 selects 2, 3, 4, 8 bytes x, and the + -- value is R(c + 2) + x, with R3 = R2 + 2^16, + -- R4 = R3 + 2^24, R5 = R4 + 2^32. + -- Each rung starts where the previous one ends, so every value has exactly + -- one encoding and there is no non-canonical form to reject. A reader + -- rejects only invalid codes (c >= 4, possible for f = 0 and 2), values + -- reaching 2^64 on the 8-byte rung, and truncation. + -- + -- The three readers keep rung 1, the common case, on one narrow row; the + -- other rungs share `get_tagn_tail`, parameterised by h. R2's bytes are + -- [2h, h], so the readers need no other constant. + + -- TagN, f = 4: [flag:4][L][M][c:2]. + fn get_tagn4(stream: ByteStream) -> ((G, U64), ByteStream) { let ListNode.Cons(byte, s) = load(stream); - let bits = u8_bit_decomposition(byte); - let [b0, b1, b2, b3, b4, b5, b6, b7] = bits; - let small_size = b0 + 2 * b1 + 4 * b2 + 8 * b3 + 16 * b4 + 32 * b5 + 64 * b6; - match b7 { - 0 => - ([u8_from_field_unsafe(small_size), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], s), - _ => - let num_bytes = small_size + 1; - -- A u64 payload is at most 8 bytes. `small` is 7 bits here, so - -- `num_bytes` reaches 128 and `get_u64_le` would consume the - -- surplus and DISCARD it, silently accepting bytes no host will: - -- Rust rejects `len > 8`, and the Lean host folds the extra bytes - -- back in (its shift is mod 64), reading a different value from - -- the same address. Reject instead, so the accepted language - -- matches the format. - assert_eq!(u8_less_than(u8_from_field_unsafe(num_bytes), 9u8), 1, - "tag0: payload width exceeds 8 bytes"); - let (size, s2) = get_u64_le(s, num_bytes); - assert_eq!(to_field(u64_byte_count(size)), num_bytes, "nonminimal tag0 width"); - match num_bytes { - 1 => assert_eq!(u8_less_than(size[0], 128u8), 0, "nonminimal tag0 value"); (); (), - _ => (), - }; - (size, s2), + let [b0, b1, b2, b3, b4, b5, b6, b7] = u8_bit_decomposition(byte); + let flag = b4 + 2 * b5 + 4 * b6 + 8 * b7; + let low = b0 + 2 * b1 + 4 * b2; + match b3 { + 0 => ((flag, [u8_from_field_unsafe(low), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), s), + 1 => + let (value, rest) = get_tagn_tail(low, 4, s); + ((flag, value), rest), } } - -- Tag2: [flag:2][large:1][size:5] - fn get_tag2(stream: ByteStream) -> ((G, U64), ByteStream) { + -- TagN, f = 2: [flag:2][L][M][c:4]. + fn get_tagn2(stream: ByteStream) -> ((G, U64), ByteStream) { let ListNode.Cons(byte, s) = load(stream); - let bits = u8_bit_decomposition(byte); - let [b0, b1, b2, b3, b4, b5, b6, b7] = bits; + let [b0, b1, b2, b3, b4, b5, b6, b7] = u8_bit_decomposition(byte); let flag = b6 + 2 * b7; - let small_size = b0 + 2 * b1 + 4 * b2 + 8 * b3 + 16 * b4; + let low = b0 + 2 * b1 + 4 * b2 + 8 * b3 + 16 * b4; match b5 { - 0 => - ((flag, [u8_from_field_unsafe(small_size), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), s), - _ => - let num_bytes = small_size + 1; - -- Same bound as `get_tag0`; `small` is 5 bits here, so - -- `num_bytes` reaches 32. - assert_eq!(u8_less_than(u8_from_field_unsafe(num_bytes), 9u8), 1, - "tag2: payload width exceeds 8 bytes"); - let (size, s2) = get_u64_le(s, num_bytes); - assert_eq!(to_field(u64_byte_count(size)), num_bytes, "nonminimal tag2 width"); - match num_bytes { - 1 => assert_eq!(u8_less_than(size[0], 32u8), 0, "nonminimal tag2 value"); (); (), - _ => (), - }; - ((flag, size), s2), + 0 => ((flag, [u8_from_field_unsafe(low), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), s), + 1 => + let (value, rest) = get_tagn_tail(low, 16, s); + ((flag, value), rest), } } - -- Tag4: [flag:4][large:1][size:3] - fn get_tag4(stream: ByteStream) -> ((G, U64), ByteStream) { + -- TagN, f = 0: [L][M][c:6]. No flag, so one comparison replaces the bit + -- decomposition, and a rung-1 value is the header byte itself. + fn get_tagn0(stream: ByteStream) -> (U64, ByteStream) { let ListNode.Cons(byte, s) = load(stream); - let bits = u8_bit_decomposition(byte); - let [b0, b1, b2, b3, b4, b5, b6, b7] = bits; - let flag = b4 + 2 * b5 + 4 * b6 + 8 * b7; - let small_size = b0 + 2 * b1 + 4 * b2; - match b3 { + match u8_less_than(byte, 128u8) { + 1 => ([byte, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], s), + 0 => get_tagn_tail(to_field(byte) - 128, 64, s), + } + } + + -- Rungs 2 to 6. `q` is the payload below L (M then c) and `h` the weight + -- of M, so `q < h` is rung 2 and `q - h` is the code otherwise. + fn get_tagn_tail(q: G, h: G, stream: ByteStream) -> (U64, ByteStream) { + match u8_less_than(u8_from_field_unsafe(q), u8_from_field_unsafe(h)) { + -- R1 + 256 q + lo, with q < h <= 64: the high byte absorbs the carry. + 1 => + let ListNode.Cons(lo, s) = load(stream); + let (v0, carry) = u8_add(lo, u8_from_field_unsafe(2 * h)); + ([v0, u8_from_field_unsafe(q + to_field(carry)), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], s), + 0 => get_tagn_wide(q - h, h, stream), + } + } + + -- Rungs 3 to 6: code c reads 2, 3, 4 or 8 bytes and adds R(c + 2). Codes + -- 4 and up (f = 0 and 2) have no arm, so the match rejects them. + fn get_tagn_wide(c: G, h: G, stream: ByteStream) -> (U64, ByteStream) { + let r0 = u8_from_field_unsafe(2 * h); + let r1 = u8_from_field_unsafe(h); + match c { 0 => - ((flag, [u8_from_field_unsafe(small_size), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), s), - _ => - let num_bytes = small_size + 1; - let (size, s2) = get_u64_le(s, num_bytes); - assert_eq!(to_field(u64_byte_count(size)), num_bytes, "nonminimal tag4 width"); - match num_bytes { - 1 => assert_eq!(u8_less_than(size[0], 8u8), 0, "nonminimal tag4 value"); (); (), - _ => (), - }; - ((flag, size), s2), + let (x, s) = get_u64_le(stream, 2); + let (value, _) = u64_add(x, [r0, r1, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + (value, s), + 1 => + let (x, s) = get_u64_le(stream, 3); + let (value, _) = u64_add(x, [r0, r1, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + (value, s), + 2 => + let (x, s) = get_u64_le(stream, 4); + let (value, _) = u64_add(x, [r0, r1, 1u8, 1u8, 0u8, 0u8, 0u8, 0u8]); + (value, s), + 3 => + let (x, s) = get_u64_le(stream, 8); + let (value, carry) = u64_add(x, [r0, r1, 1u8, 1u8, 1u8, 0u8, 0u8, 0u8]); + assert_eq!(to_field(carry), 0, "TagN value exceeds UInt64"); + (value, s), } } @@ -119,7 +137,7 @@ def ixonDeserialize := ⟦ match is_zero { 1 => (store(ListNode.Nil), stream), 0 => - let (val, s) = get_tag0(stream); + let (val, s) = get_tagn0(stream); let (rest, s2) = get_u64_list(s, relaxed_u64_pred(count)); (store(ListNode.Cons(val, rest)), s2), } @@ -174,7 +192,7 @@ def ixonDeserialize := ⟦ } -- Lam telescope: read count (contract, type) binders then body, wrap as nested - -- Lams. The base may not itself be a Lam: the v3 encoding requires maximal + -- Lams. The base may not itself be a Lam: the encoding requires maximal -- telescope compression. fn get_lam_telescope(stream: ByteStream, count: U64) -> (&Expr, ByteStream) { let is_zero = u64_is_zero(count); @@ -218,40 +236,40 @@ def ixonDeserialize := ⟦ } fn get_expr(stream: ByteStream) -> (&Expr, ByteStream) { - let (tag, s) = get_tag4(stream); + let (tag, s) = get_tagn4(stream); let (flag, size) = tag; match flag { - -- Srt: Tag4(0x0, univ_idx) + -- Srt: TagN4(0x0, univ_idx) 0x0 => (store(Expr.Srt(size)), s), - -- Var: Tag4(0x1, idx) + -- Var: TagN4(0x1, idx) 0x1 => (store(Expr.Var(size)), s), - -- Ref: Tag4(0x2, len) + Tag0(ref_idx) + univ_list + -- Ref: TagN4(0x2, len) + TagN0(ref_idx) + univ_list 0x2 => - let (ref_idx, s2) = get_tag0(s); + let (ref_idx, s2) = get_tagn0(s); let (univ_list, s3) = get_u64_list(s2, size); (store(Expr.Ref(ref_idx, univ_list)), s3), - -- Rec: Tag4(0x3, len) + Tag0(rec_idx) + univ_list + -- Rec: TagN4(0x3, len) + TagN0(rec_idx) + univ_list 0x3 => - let (rec_idx, s2) = get_tag0(s); + let (rec_idx, s2) = get_tagn0(s); let (univ_list, s3) = get_u64_list(s2, size); (store(Expr.Rec(rec_idx, univ_list)), s3), - -- Prj: Tag4(0x4, field_idx) + Tag0(type_ref_idx) + expr(val) + -- Prj: TagN4(0x4, field_idx) + TagN0(type_ref_idx) + expr(val) 0x4 => - let (type_ref_idx, s2) = get_tag0(s); + let (type_ref_idx, s2) = get_tagn0(s); let (val, s3) = get_expr(s2); (store(Expr.Prj(type_ref_idx, size, val)), s3), - -- Str: Tag4(0x5, ref_idx) + -- Str: TagN4(0x5, ref_idx) 0x5 => (store(Expr.Str(size)), s), - -- Nat: Tag4(0x6, ref_idx) + -- Nat: TagN4(0x6, ref_idx) 0x6 => (store(Expr.Nat(size)), s), - -- App: Tag4(0x7, count) + func + args... + -- App: TagN4(0x7, count) + func + args... -- -- A zero count is not a legal encoding — an `App` with no -- arguments, or a binder telescope with no binders, is not an @@ -277,20 +295,20 @@ def ixonDeserialize := ⟦ _ => get_app_telescope(func, s2, size), }, - -- Lam: Tag4(0x8, count) + (contract, type)... + body + -- Lam: TagN4(0x8, count) + (contract, type)... + body 0x8 => assert_eq!(u64_is_zero(size), 0, "Lam with zero binders"); get_lam_telescope(s, size), - -- All: Tag4(0x9, count) + (input|result<<4, type)... + body + -- All: TagN4(0x9, count) + (input|result<<4, type)... + body 0x9 => assert_eq!(u64_is_zero(size), 0, "All with zero binders"); get_all_telescope(s, size), - -- Let: Tag4(0xA, flags) + binder + expr(ty) + expr(val) + expr(body) + -- Let: TagN4(0xA, flags) + binder + expr(ty) + expr(val) + expr(body) 0xA => get_expr_let(s, size), - -- Share: Tag4(0xB, idx) + -- Share: TagN4(0xB, idx) 0xB => (store(Expr.Share(size)), s), } } @@ -328,10 +346,10 @@ def ixonDeserialize := ⟦ } fn get_univ(stream: ByteStream) -> (Univ, ByteStream) { - let (tag, s) = get_tag2(stream); + let (tag, s) = get_tagn2(stream); let (flag, size) = tag; match flag { - -- Zero/Succ: Tag2(0, count) + -- Zero/Succ: TagN2(0, count) 0 => let is_zero = u64_is_zero(size); match is_zero { @@ -341,19 +359,19 @@ def ixonDeserialize := ⟦ (build_succ_chain(base, size), s2), }, - -- Max: Tag2(1, 0) + univ(a) + univ(b) + -- Max: TagN2(1, 0) + univ(a) + univ(b) 1 => let (a, s2) = get_univ(s); let (b, s3) = get_univ(s2); (Univ.Max(store(a), store(b)), s3), - -- IMax: Tag2(2, 0) + univ(a) + univ(b) + -- IMax: TagN2(2, 0) + univ(a) + univ(b) 2 => let (a, s2) = get_univ(s); let (b, s3) = get_univ(s2); (Univ.IMax(store(a), store(b)), s3), - -- Var: Tag2(3, idx) + -- Var: TagN2(3, idx) 3 => (Univ.Var(size), s), } } @@ -450,17 +468,17 @@ def ixonDeserialize := ⟦ -- ============================================================================ fn get_sharing(stream: ByteStream) -> (List‹&Expr›, ByteStream) { - let (len, s) = get_tag0(stream); + let (len, s) = get_tagn0(stream); get_expr_list(s, len) } fn get_refs(stream: ByteStream) -> (List‹Addr›, ByteStream) { - let (len, s) = get_tag0(stream); + let (len, s) = get_tagn0(stream); get_address_list(s, len) } fn get_univs(stream: ByteStream) -> (List‹&Univ›, ByteStream) { - let (len, s) = get_tag0(stream); + let (len, s) = get_tagn0(stream); get_univ_list(s, len) } @@ -486,19 +504,19 @@ def ixonDeserialize := ⟦ } } - -- Definition: byte(packed_kind_safety) + Tag0(lvls) + expr(typ) + expr(value) + -- Definition: byte(packed_kind_safety) + TagN0(lvls) + expr(typ) + expr(value) fn get_definition(stream: ByteStream) -> (Definition, ByteStream) { let (packed, s) = read_byte(stream); let (kind, safety) = unpack_def_kind_safety(packed); - let (lvls, s2) = get_tag0(s); + let (lvls, s2) = get_tagn0(s); let (typ, s3) = get_expr(s2); let (value, s4) = get_expr(s3); (Definition.Mk(kind, safety, lvls, typ, value), s4) } - -- RecursorRule: Tag0(fields) + expr(rhs) + -- RecursorRule: TagN0(fields) + expr(rhs) fn get_recursor_rule(stream: ByteStream) -> (RecursorRule, ByteStream) { - let (fields, s) = get_tag0(stream); + let (fields, s) = get_tagn0(stream); let (rhs, s2) = get_expr(s); (RecursorRule.Mk(fields, rhs), s2) } @@ -514,26 +532,26 @@ def ixonDeserialize := ⟦ } } - -- Recursor: byte(bools) + Tag0(lvls) + Tag0(params) + Tag0(indices) + - -- Tag0(motives) + Tag0(minors) + expr(typ) + Tag0(rules_len) + rules... + -- Recursor: byte(bools) + TagN0(lvls) + TagN0(params) + TagN0(indices) + + -- TagN0(motives) + TagN0(minors) + expr(typ) + TagN0(rules_len) + rules... fn get_recursor(stream: ByteStream) -> (Recursor, ByteStream) { let (bools_byte, s) = read_byte(stream); assert_eq!(u8_less_than(bools_byte, 4u8), 1, "invalid recursor flags"); let bits = u8_bit_decomposition(bools_byte); let k = bits[0]; let is_unsafe = bits[1]; - let (lvls, s2) = get_tag0(s); - let (params, s3) = get_tag0(s2); - let (indices, s4) = get_tag0(s3); - let (motives, s5) = get_tag0(s4); - let (minors, s6) = get_tag0(s5); + 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_tag0(s7); + let (rules_len, s8) = get_tagn0(s7); let (rules, s9) = get_recursor_rule_list(s8, rules_len); (Recursor.Mk(k, is_unsafe, lvls, params, indices, motives, minors, typ, rules), s9) } - -- Axiom: byte(is_unsafe) + Tag0(lvls) + expr(typ) + -- Axiom: byte(is_unsafe) + TagN0(lvls) + expr(typ) -- A wire byte standing for a Bool must be 0 or 1, as Rust's `get_bool` -- requires (`crates/ixon/src/serialize.rs:55-61`). -- @@ -551,7 +569,7 @@ def ixonDeserialize := ⟦ fn get_axiom(stream: ByteStream) -> (Axiom, ByteStream) { let (is_unsafe, s) = read_byte(stream); assert_wire_bool(is_unsafe); - let (lvls, s2) = get_tag0(s); + let (lvls, s2) = get_tagn0(s); let (typ, s3) = get_expr(s2); (Axiom.Mk(to_field(is_unsafe), lvls, typ), s3) } @@ -566,24 +584,24 @@ def ixonDeserialize := ⟦ } } - -- Quotient: byte(kind) + Tag0(lvls) + expr(typ) + -- Quotient: byte(kind) + TagN0(lvls) + expr(typ) fn get_quotient(stream: ByteStream) -> (Quotient, ByteStream) { let (kind_byte, s) = read_byte(stream); let kind = get_quot_kind(kind_byte); - let (lvls, s2) = get_tag0(s); + let (lvls, s2) = get_tagn0(s); let (typ, s3) = get_expr(s2); (Quotient.Mk(kind, lvls, typ), s3) } - -- Constructor: byte(is_unsafe) + Tag0(lvls) + Tag0(cidx) + Tag0(params) + - -- Tag0(fields) + expr(typ) + -- Constructor: byte(is_unsafe) + TagN0(lvls) + TagN0(cidx) + TagN0(params) + + -- TagN0(fields) + expr(typ) fn get_constructor(stream: ByteStream) -> (Constructor, ByteStream) { let (is_unsafe, s) = read_byte(stream); assert_wire_bool(is_unsafe); - let (lvls, s2) = get_tag0(s); - let (cidx, s3) = get_tag0(s2); - let (params, s4) = get_tag0(s3); - let (fields, s5) = get_tag0(s4); + 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); (Constructor.Mk(to_field(is_unsafe), lvls, cidx, params, fields, typ), s6) } @@ -599,18 +617,18 @@ def ixonDeserialize := ⟦ } } - -- Inductive: byte(bools) + Tag0(lvls) + Tag0(params) + Tag0(indices) + - -- expr(typ) + Tag0(ctors_len) + ctors... + -- Inductive: byte(bools) + TagN0(lvls) + TagN0(params) + TagN0(indices) + + -- expr(typ) + TagN0(ctors_len) + ctors... fn get_inductive(stream: ByteStream) -> (Inductive, ByteStream) { let (bools_byte, s) = read_byte(stream); assert_wire_bool(bools_byte); let bits = u8_bit_decomposition(bools_byte); let is_unsafe = bits[0]; - let (lvls, s2) = get_tag0(s); - let (params, s3) = get_tag0(s2); - let (indices, s4) = get_tag0(s3); + 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_tag0(s5); + let (ctors_len, s6) = get_tagn0(s5); let (ctors, s7) = get_constructor_list(s6, ctors_len); (Inductive.Mk(is_unsafe, lvls, params, indices, typ, ctors), s7) } @@ -619,31 +637,31 @@ def ixonDeserialize := ⟦ -- Projection deserialization -- ============================================================================ - -- InductiveProj: Tag0(idx) + address(block) + -- InductiveProj: TagN0(idx) + address(block) fn get_inductive_proj(stream: ByteStream) -> (InductiveProj, ByteStream) { - let (idx, s) = get_tag0(stream); + let (idx, s) = get_tagn0(stream); let (block, s2) = get_address(s); (InductiveProj.Mk(idx, block), s2) } - -- ConstructorProj: Tag0(idx) + Tag0(cidx) + address(block) + -- ConstructorProj: TagN0(idx) + TagN0(cidx) + address(block) fn get_constructor_proj(stream: ByteStream) -> (ConstructorProj, ByteStream) { - let (idx, s) = get_tag0(stream); - let (cidx, s2) = get_tag0(s); + let (idx, s) = get_tagn0(stream); + let (cidx, s2) = get_tagn0(s); let (block, s3) = get_address(s2); (ConstructorProj.Mk(idx, cidx, block), s3) } - -- RecursorProj: Tag0(idx) + address(block) + -- RecursorProj: TagN0(idx) + address(block) fn get_recursor_proj(stream: ByteStream) -> (RecursorProj, ByteStream) { - let (idx, s) = get_tag0(stream); + let (idx, s) = get_tagn0(stream); let (block, s2) = get_address(s); (RecursorProj.Mk(idx, block), s2) } - -- DefinitionProj: Tag0(idx) + address(block) + -- DefinitionProj: TagN0(idx) + address(block) fn get_definition_proj(stream: ByteStream) -> (DefinitionProj, ByteStream) { - let (idx, s) = get_tag0(stream); + let (idx, s) = get_tagn0(stream); let (block, s2) = get_address(s); (DefinitionProj.Mk(idx, block), s2) } @@ -722,12 +740,11 @@ def ixonDeserialize := ⟦ (ConstantInfo.Muts(mutuals), s), -- Non-Muts: flag=0xD, size[0] is the variant number. -- - -- Dispatch on the FULL tag4 size, matching Rust `ConstantInfo::get` + -- Dispatch on the FULL TagN size, matching Rust `ConstantInfo::get` -- which matches `tag.size: u64` and errors on anything outside - -- 0-7 (`crates/ixon/src/serialize.rs:968-980`). The variant is only - -- ever 0-7, so the high 7 bytes must be zero; without this - -- `0xD9 0x00 0x01 …` is size 0x100, whose low byte is 0, and the - -- circuit parses a `Defn` from a buffer Rust rejects outright. + -- 0-7. The variant is only ever 0-7, so the high 7 bytes must be + -- zero; without this `0xD8 0xF8` (size 0x100) has low byte 0, and + -- the circuit parses a `Defn` from a buffer Rust rejects outright. -- Same guard, same reasoning as `run_claim`'s (Kernel/Claim.lean). -- Sum is 0 iff every high byte is 0 (7 bytes, max sum 1785, no wrap). 0xD => @@ -735,7 +752,7 @@ def ixonDeserialize := ⟦ assert_eq!(((((((to_field(sz1) + to_field(sz2)) + to_field(sz3)) + to_field(sz4)) + to_field(sz5)) + to_field(sz6)) + to_field(sz7)), 0, - "constant info: tag4 size exceeds a single byte"); + "constant info: TagN size exceeds a single byte"); get_constant_info_by_variant(to_field(size[0]), stream), } } @@ -745,7 +762,7 @@ def ixonDeserialize := ⟦ -- ============================================================================ fn get_constant(stream: ByteStream) -> (Constant, ByteStream) { - let (tag, s) = get_tag4(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); diff --git a/Ix/IxVM/IxonSerialize.lean b/Ix/IxVM/IxonSerialize.lean index 85c183e56..76145f6c1 100644 --- a/Ix/IxVM/IxonSerialize.lean +++ b/Ix/IxVM/IxonSerialize.lean @@ -8,56 +8,56 @@ namespace IxVM def ixonSerialize := ⟦ fn put_expr(expr: Expr, rest: ByteStream) -> ByteStream { match expr { - -- Srt: Tag4(0x0, univ_idx) - Expr.Srt(univ_idx) => put_tag4(0x0, univ_idx, rest), + -- Srt: TagN4(0x0, univ_idx) + Expr.Srt(univ_idx) => put_tagn4(0x0, univ_idx, rest), - -- Var: Tag4(0x1, idx) - Expr.Var(idx) => put_tag4(0x1, idx, rest), + -- Var: TagN4(0x1, idx) + Expr.Var(idx) => put_tagn4(0x1, idx, rest), - -- Ref: Tag4(0x2, len) + Tag0(ref_idx) + univ_list + -- Ref: TagN4(0x2, len) + TagN0(ref_idx) + univ_list Expr.Ref(ref_idx, univ_list) => let len = list_length_u64(univ_list); - put_tag4(0x2, len, put_tag0(ref_idx, put_u64_list(univ_list, rest))), + put_tagn4(0x2, len, put_tagn0(ref_idx, put_u64_list(univ_list, rest))), - -- Rec: Tag4(0x3, len) + Tag0(rec_idx) + univ_list + -- Rec: TagN4(0x3, len) + TagN0(rec_idx) + univ_list Expr.Rec(rec_idx, univ_list) => let len = list_length_u64(univ_list); - put_tag4(0x3, len, put_tag0(rec_idx, put_u64_list(univ_list, rest))), + put_tagn4(0x3, len, put_tagn0(rec_idx, put_u64_list(univ_list, rest))), - -- Prj: Tag4(0x4, field_idx) + Tag0(type_ref_idx) + put_expr(val) + -- Prj: TagN4(0x4, field_idx) + TagN0(type_ref_idx) + put_expr(val) Expr.Prj(type_ref_idx, field_idx, &val) => - put_tag4(0x4, field_idx, put_tag0(type_ref_idx, put_expr(val, rest))), + put_tagn4(0x4, field_idx, put_tagn0(type_ref_idx, put_expr(val, rest))), - -- Str: Tag4(0x5, ref_idx) - Expr.Str(ref_idx) => put_tag4(0x5, ref_idx, rest), + -- Str: TagN4(0x5, ref_idx) + Expr.Str(ref_idx) => put_tagn4(0x5, ref_idx, rest), - -- Nat: Tag4(0x6, ref_idx) - Expr.Nat(ref_idx) => put_tag4(0x6, ref_idx, rest), + -- Nat: TagN4(0x6, ref_idx) + Expr.Nat(ref_idx) => put_tagn4(0x6, ref_idx, rest), - -- App: Tag4(0x7, count) + telescope + -- App: TagN4(0x7, count) + telescope Expr.App(_, _) => let count = app_telescope_count(expr); - put_tag4(0x7, count, put_app_telescope(expr, rest)), + put_tagn4(0x7, count, put_app_telescope(expr, rest)), - -- Lam: Tag4(0x8, count) + telescope + -- Lam: TagN4(0x8, count) + telescope Expr.Lam(_, _, _) => let count = lam_telescope_count(expr); - put_tag4(0x8, count, put_lam_telescope(expr, rest)), + put_tagn4(0x8, count, put_lam_telescope(expr, rest)), - -- All: Tag4(0x9, count) + telescope + -- All: TagN4(0x9, count) + telescope Expr.All(_, _, _, _) => let count = all_telescope_count(expr); - put_tag4(0x9, count, put_all_telescope(expr, rest)), + put_tagn4(0x9, count, put_all_telescope(expr, rest)), - -- Let: flags in Tag4 size, then the binder byte and three children. + -- Let: flags in the TagN4 value, then the binder byte and three children. Expr.Let(LetContract.Mk(non_dep, kind, contract), &ty, &val, &body) => let kind_bit = match kind { LetKind.Value => 0, LetKind.BorrowShared => 1, }; let flags = [u8_from_field_unsafe(non_dep + 2 * kind_bit), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]; - put_tag4(0xA, flags, put_lam_mode(contract, + put_tagn4(0xA, flags, put_lam_mode(contract, put_expr(ty, put_expr(val, put_expr(body, rest))))), - -- Share: Tag4(0xB, idx) - Expr.Share(idx) => put_tag4(0xB, idx, rest), + -- Share: TagN4(0xB, idx) + Expr.Share(idx) => put_tagn4(0xB, idx, rest), } } @@ -71,53 +71,111 @@ def ixonSerialize := ⟦ } } - fn put_tag0(bs: U64, rest: ByteStream) -> ByteStream { - let byte_count = u64_byte_count(bs); - let small = u8_less_than(bs[0], 128u8); - match (byte_count, small) { - (1, 1) => store(ListNode.Cons(bs[0], rest)), - _ => - let head = u8_from_field_unsafe(128 + (to_field(byte_count) - 1)); - store(ListNode.Cons(head, put_u64_le(bs, to_field(byte_count), rest))), + -- ============================================================================ + -- TagN integers (`Ixon.putTagN`; layout in IxonDeserialize.lean) + -- ============================================================================ + + -- Rung 1 (value < R1 = 2h) is the header byte alone; every larger value + -- goes through `put_tagn_tail`. `base` is the flag in the header's high + -- bits. The values written here are range-checked bytes (decoded fields, + -- list lengths), so the sum of the high seven is zero only when each is. + + -- TagN, f = 4. + fn put_tagn4(flag: G, v: U64, rest: ByteStream) -> ByteStream { + let [v0, v1, v2, v3, v4, v5, v6, v7] = v; + match to_field(v1) + to_field(v2) + to_field(v3) + to_field(v4) + + to_field(v5) + to_field(v6) + to_field(v7) { + 0 => + match u8_less_than(v0, 8u8) { + 1 => store(ListNode.Cons(u8_from_field_unsafe(16 * flag + to_field(v0)), rest)), + 0 => put_tagn_tail(16 * flag, 4, v, rest), + }, + _ => put_tagn_tail(16 * flag, 4, v, rest), } } - -- Tag2: 2-bit flag, variable size - -- Format: [flag:2][large:1][size:5] or [flag:2][large:1][size_bytes...] - fn put_tag2(flag: G, size: U64, rest: ByteStream) -> ByteStream { - let byte_count = u64_byte_count(size); - let small = u8_less_than(size[0], 32u8); - match (byte_count, small) { - (1, 1) => - -- Single byte: flag in bits 6-7, size in bits 0-4 - let head = u8_from_field_unsafe(flag * 64 + to_field(size[0])); - store(ListNode.Cons(head, rest)), - _ => - -- Multi-byte: flag in bits 6-7, large=1 in bit 5, size_bytes-1 in bits 0-4 - let head = u8_from_field_unsafe(flag * 64 + 32 + (to_field(byte_count) - 1)); - store(ListNode.Cons(head, put_u64_le(size, to_field(byte_count), rest))), + -- TagN, f = 2. + fn put_tagn2(flag: G, v: U64, rest: ByteStream) -> ByteStream { + let [v0, v1, v2, v3, v4, v5, v6, v7] = v; + match to_field(v1) + to_field(v2) + to_field(v3) + to_field(v4) + + to_field(v5) + to_field(v6) + to_field(v7) { + 0 => + match u8_less_than(v0, 32u8) { + 1 => store(ListNode.Cons(u8_from_field_unsafe(64 * flag + to_field(v0)), rest)), + 0 => put_tagn_tail(64 * flag, 16, v, rest), + }, + _ => put_tagn_tail(64 * flag, 16, v, rest), } } - fn put_tag4(flag: G, bs: U64, rest: ByteStream) -> ByteStream { - let byte_count = u64_byte_count(bs); - let small = u8_less_than(bs[0], 8u8); - match (byte_count, small) { - (1, 1) => - let head = u8_from_field_unsafe(flag * 16 + to_field(bs[0])); - store(ListNode.Cons(head, rest)), - _ => - let head = u8_from_field_unsafe(flag * 16 + 8 + (to_field(byte_count) - 1)); - store(ListNode.Cons(head, put_u64_le(bs, to_field(byte_count), rest))), + -- TagN, f = 0. + fn put_tagn0(v: U64, rest: ByteStream) -> ByteStream { + let [v0, v1, v2, v3, v4, v5, v6, v7] = v; + match to_field(v1) + to_field(v2) + to_field(v3) + to_field(v4) + + to_field(v5) + to_field(v6) + to_field(v7) { + 0 => + match u8_less_than(v0, 128u8) { + 1 => store(ListNode.Cons(v0, rest)), + 0 => put_tagn_tail(0, 64, v, rest), + }, + _ => put_tagn_tail(0, 64, v, rest), + } + } + + -- Rungs 2 to 6 of `v >= R1 = 2h`. Subtracting R2 = [2h, h] is adding its + -- two's complement; the carry is set exactly when v >= R2. + fn put_tagn_tail(base: G, h: G, v: U64, rest: ByteStream) -> ByteStream { + let (d, at_least_r2) = u64_add(v, [u8_from_field_unsafe(256 - 2 * h), + u8_from_field_unsafe(255 - h), 255u8, 255u8, 255u8, 255u8, 255u8, 255u8]); + match to_field(at_least_r2) { + -- Rung 2: v - R1 = 256 hi + lo with hi < h, and v < R2 < 2^16. + 0 => + let (lo, no_borrow) = u8_add(v[0], u8_from_field_unsafe(256 - 2 * h)); + let hi = to_field(v[1]) + to_field(no_borrow) - 1; + store(ListNode.Cons(u8_from_field_unsafe(base + 2 * h + hi), + store(ListNode.Cons(lo, rest)))), + 1 => put_tagn_wide(base + 3 * h, 0, d, rest), + } + } + + -- Rungs 3 to 6: `d = v - R(c + 2)`. Code c (0, 1, 2) holds d below 2^16, + -- 2^24, 2^32 in 2, 3, 4 bytes; otherwise d moves to the next rung, whose + -- start is 2^16, 2^24, 2^32 further. Code 3 holds the rest in 8 bytes. + fn put_tagn_wide(header: G, c: G, d: U64, rest: ByteStream) -> ByteStream { + let [_, _, d2, d3, d4, d5, d6, d7] = d; + match c { + 0 => + match to_field(d2) + to_field(d3) + to_field(d4) + to_field(d5) + + to_field(d6) + to_field(d7) { + 0 => store(ListNode.Cons(u8_from_field_unsafe(header), put_u64_le(d, 2, rest))), + _ => + let (next, _) = u64_add(d, [0u8, 0u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8]); + put_tagn_wide(header, 1, next, rest), + }, + 1 => + match to_field(d3) + to_field(d4) + to_field(d5) + to_field(d6) + to_field(d7) { + 0 => store(ListNode.Cons(u8_from_field_unsafe(header + 1), put_u64_le(d, 3, rest))), + _ => + let (next, _) = u64_add(d, [0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8, 255u8]); + put_tagn_wide(header, 2, next, rest), + }, + 2 => + match to_field(d4) + to_field(d5) + to_field(d6) + to_field(d7) { + 0 => store(ListNode.Cons(u8_from_field_unsafe(header + 2), put_u64_le(d, 4, rest))), + _ => + let (next, _) = u64_add(d, [0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]); + put_tagn_wide(header, 3, next, rest), + }, + 3 => store(ListNode.Cons(u8_from_field_unsafe(header + 3), put_u64_le(d, 8, rest))), } } - -- Serialize field list (each element as Tag0) + -- Serialize field list (each element as TagN0) fn put_u64_list(list: List‹U64›, rest: ByteStream) -> ByteStream { match load(list) { ListNode.Nil => rest, ListNode.Cons(idx, rest_list) => - put_tag0(idx, put_u64_list(rest_list, rest)), + put_tagn0(idx, put_u64_list(rest_list, rest)), } } @@ -272,7 +330,7 @@ def ixonSerialize := ⟦ fn put_univ(u: Univ, rest: ByteStream) -> ByteStream { match u { Univ.Zero => - -- Tag2(FLAG_ZERO_SUCC=0, size=0) + -- TagN2(FLAG_ZERO_SUCC=0, size=0) store(ListNode.Cons(0u8, rest)), Univ.Succ(_) => @@ -280,20 +338,20 @@ def ixonSerialize := ⟦ let count = univ_succ_count(u); -- Find the base (non-Succ) universe let base = univ_succ_base(u); - -- Tag2(FLAG_ZERO_SUCC=0, size=count) + base - put_tag2(0, count, put_univ(base, rest)), + -- TagN2(FLAG_ZERO_SUCC=0, size=count) + base + put_tagn2(0, count, put_univ(base, rest)), Univ.Max(&a, &b) => - -- Tag2(FLAG_MAX=1, size=0) - put_tag2(1, [0u8; 8], put_univ(a, put_univ(b, rest))), + -- TagN2(FLAG_MAX=1, size=0) + put_tagn2(1, [0u8; 8], put_univ(a, put_univ(b, rest))), Univ.IMax(&a, &b) => - -- Tag2(FLAG_IMAX=2, size=0) - put_tag2(2, [0u8; 8], put_univ(a, put_univ(b, rest))), + -- TagN2(FLAG_IMAX=2, size=0) + put_tagn2(2, [0u8; 8], put_univ(a, put_univ(b, rest))), Univ.Var(idx) => - -- Tag2(FLAG_VAR=3, size=idx) - put_tag2(3, idx, rest), + -- TagN2(FLAG_VAR=3, size=idx) + put_tagn2(3, idx, rest), } } @@ -342,14 +400,14 @@ def ixonSerialize := ⟦ match defn { Definition.Mk(kind, safety, lvls, &typ, &value) => let packed = pack_def_kind_safety(kind, safety); - store(ListNode.Cons(u8_from_field_unsafe(packed), put_tag0(lvls, put_expr(typ, put_expr(value, rest))))), + store(ListNode.Cons(u8_from_field_unsafe(packed), put_tagn0(lvls, put_expr(typ, put_expr(value, rest))))), } } fn put_recursor_rule(rule: RecursorRule, rest: ByteStream) -> ByteStream { match rule { RecursorRule.Mk(fields, &rhs) => - put_tag0(fields, put_expr(rhs, rest)), + put_tagn0(fields, put_expr(rhs, rest)), } } @@ -367,13 +425,13 @@ def ixonSerialize := ⟦ let bools = k + 2 * is_unsafe; let rules_len = list_length_u64(rules); store(ListNode.Cons(u8_from_field_unsafe(bools), - put_tag0(lvls, - put_tag0(params, - put_tag0(indices, - put_tag0(motives, - put_tag0(minors, + put_tagn0(lvls, + put_tagn0(params, + put_tagn0(indices, + put_tagn0(motives, + put_tagn0(minors, put_expr(typ, - put_tag0(rules_len, + put_tagn0(rules_len, put_recursor_rule_list(rules, rest)))))))))), } } @@ -381,14 +439,14 @@ def ixonSerialize := ⟦ fn put_axiom(axim: Axiom, rest: ByteStream) -> ByteStream { match axim { Axiom.Mk(is_unsafe, lvls, &typ) => - store(ListNode.Cons(u8_from_field_unsafe(is_unsafe), put_tag0(lvls, put_expr(typ, rest)))), + store(ListNode.Cons(u8_from_field_unsafe(is_unsafe), put_tagn0(lvls, put_expr(typ, rest)))), } } fn put_quotient(quot: Quotient, rest: ByteStream) -> ByteStream { match quot { Quotient.Mk(kind, lvls, &typ) => - put_quot_kind(kind, put_tag0(lvls, put_expr(typ, rest))), + put_quot_kind(kind, put_tagn0(lvls, put_expr(typ, rest))), } } @@ -396,10 +454,10 @@ def ixonSerialize := ⟦ match ctor { Constructor.Mk(is_unsafe, lvls, cidx, params, fields, &typ) => store(ListNode.Cons(u8_from_field_unsafe(is_unsafe), - put_tag0(lvls, - put_tag0(cidx, - put_tag0(params, - put_tag0(fields, + put_tagn0(lvls, + put_tagn0(cidx, + put_tagn0(params, + put_tagn0(fields, put_expr(typ, rest))))))), } } @@ -417,11 +475,11 @@ def ixonSerialize := ⟦ Inductive.Mk(is_unsafe, lvls, params, indices, &typ, ctors) => let ctors_len = list_length_u64(ctors); store(ListNode.Cons(u8_from_field_unsafe(is_unsafe), - put_tag0(lvls, - put_tag0(params, - put_tag0(indices, + put_tagn0(lvls, + put_tagn0(params, + put_tagn0(indices, put_expr(typ, - put_tag0(ctors_len, + put_tagn0(ctors_len, put_constructor_list(ctors, rest)))))))), } } @@ -429,28 +487,28 @@ def ixonSerialize := ⟦ fn put_inductive_proj(prj: InductiveProj, rest: ByteStream) -> ByteStream { match prj { InductiveProj.Mk(idx, block) => - put_tag0(idx, put_address(block, rest)), + put_tagn0(idx, put_address(block, rest)), } } fn put_constructor_proj(prj: ConstructorProj, rest: ByteStream) -> ByteStream { match prj { ConstructorProj.Mk(idx, cidx, block) => - put_tag0(idx, put_tag0(cidx, put_address(block, rest))), + put_tagn0(idx, put_tagn0(cidx, put_address(block, rest))), } } fn put_recursor_proj(prj: RecursorProj, rest: ByteStream) -> ByteStream { match prj { RecursorProj.Mk(idx, block) => - put_tag0(idx, put_address(block, rest)), + put_tagn0(idx, put_address(block, rest)), } } fn put_definition_proj(prj: DefinitionProj, rest: ByteStream) -> ByteStream { match prj { DefinitionProj.Mk(idx, block) => - put_tag0(idx, put_address(block, rest)), + put_tagn0(idx, put_address(block, rest)), } } @@ -488,17 +546,17 @@ def ixonSerialize := ⟦ fn put_sharing(list: List‹&Expr›, rest: ByteStream) -> ByteStream { let len = list_length_u64(list); - put_tag0(len, put_expr_list(list, rest)) + put_tagn0(len, put_expr_list(list, rest)) } fn put_refs(list: List‹Addr›, rest: ByteStream) -> ByteStream { let len = list_length_u64(list); - put_tag0(len, put_address_list(list, rest)) + put_tagn0(len, put_address_list(list, rest)) } fn put_univs(list: List‹&Univ›, rest: ByteStream) -> ByteStream { let len = list_length_u64(list); - put_tag0(len, put_univ_list(list, rest)) + put_tagn0(len, put_univ_list(list, rest)) } fn put_constant(cnst: Constant, rest: ByteStream) -> ByteStream { @@ -507,26 +565,26 @@ def ixonSerialize := ⟦ let up_to_sharing = put_sharing(sharing, put_refs(refs, put_univs(univs, rest))); match info { ConstantInfo.Muts(mutuals) => - -- Use FLAG_MUTS (0xC) with entry count in size field + -- Use FLAG_MUTS (0xC) with the entry count as the TagN value let count = list_length_u64(mutuals); - put_tag4(0xC, count, put_mut_const_list(mutuals, up_to_sharing)), - -- Use FLAG (0xD) with variant in size field + put_tagn4(0xC, count, put_mut_const_list(mutuals, up_to_sharing)), + -- Use FLAG (0xD) with the variant as the TagN value ConstantInfo.Defn(_) => - put_tag4(0xD, [0u8; 8], put_constant_info(info, up_to_sharing)), + put_tagn4(0xD, [0u8; 8], put_constant_info(info, up_to_sharing)), ConstantInfo.Recr(_) => - put_tag4(0xD, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), + put_tagn4(0xD, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), ConstantInfo.Axio(_) => - put_tag4(0xD, [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), + put_tagn4(0xD, [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), ConstantInfo.Quot(_) => - put_tag4(0xD, [3u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), + put_tagn4(0xD, [3u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), ConstantInfo.CPrj(_) => - put_tag4(0xD, [4u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), + put_tagn4(0xD, [4u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), ConstantInfo.RPrj(_) => - put_tag4(0xD, [5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), + put_tagn4(0xD, [5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), ConstantInfo.IPrj(_) => - put_tag4(0xD, [6u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), + put_tagn4(0xD, [6u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), ConstantInfo.DPrj(_) => - put_tag4(0xD, [7u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), + put_tagn4(0xD, [7u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], put_constant_info(info, up_to_sharing)), }, } } diff --git a/Ix/IxVM/Kernel/Claim.lean b/Ix/IxVM/Kernel/Claim.lean index 6d490bf03..b4ba5fca3 100644 --- a/Ix/IxVM/Kernel/Claim.lean +++ b/Ix/IxVM/Kernel/Claim.lean @@ -331,10 +331,10 @@ def claim := ⟦ -- Establish finiteness before parsing: a Merkle-root equality cannot -- bind arbitrary returns from a cyclic lookup chain. let bytes = read_finite_byte_stream(1, idx, len); - let (tag, s) = get_tag4(bytes); - let (flag, size) = tag; - assert_eq!(flag, 0xE, "assumption tree: wrong tag4 flag"); - assert_eq!(to_field(size[0]), 2, "assumption tree: wrong tag4 variant"); + -- The header is TagN4(0xE, 2), a rung-1 value: exactly the byte 0xE2, + -- as the hosts and the aggregator read it. + let (tag, s) = read_byte(bytes); + assert_eq!(tag, 0xE2u8, "assumption tree: wrong TagN header"); let (computed_root, leaves, rest) = parse_atree_body(s); assert_eq!(load(rest), ListNode.Nil, "assumption tree: trailing bytes after tree body"); @@ -628,7 +628,7 @@ def claim := ⟦ match mb { 0 => (Option.None, stream), _ => - let (n, s) = get_tag0(stream); + let (n, s) = get_tagn0(stream); (Option.Some(n), s), } } @@ -697,10 +697,10 @@ def claim := ⟦ } -- RevealRecursorRule list parser. - -- Wire: `Tag0(count) + count × (Tag0(idx) + Tag0(fields) + Address)`. + -- Wire: `TagN0(count) + count × (TagN0(idx) + TagN0(fields) + Address)`. fn get_reveal_rule(stream: ByteStream) -> (RevealRecursorRule, ByteStream) { - let (rule_idx, s) = get_tag0(stream); - let (fields, s) = get_tag0(s); + 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) } @@ -721,7 +721,7 @@ def claim := ⟦ match mb { 0 => (Option.None, stream), _ => - let (count, s) = get_tag0(stream); + let (count, s) = get_tagn0(stream); let (rules, s2) = get_reveal_rule_list_inner(s, count); (Option.Some(rules), s2), } @@ -730,7 +730,7 @@ def claim := ⟦ -- RevealConstructorInfo parser. 6 optional fields, mask bits 0..5. fn get_reveal_ctor_info(stream: ByteStream) -> (RevealConstructorInfo, ByteStream) { - let (mask, s) = get_tag0(stream); + 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); @@ -744,7 +744,7 @@ def claim := ⟦ fn get_ctor_entry(stream: ByteStream) -> ((U64, RevealConstructorInfo), ByteStream) { - let (idx, s) = get_tag0(stream); + let (idx, s) = get_tagn0(stream); let (info, s) = get_reveal_ctor_info(s); ((idx, info), s) } @@ -765,7 +765,7 @@ def claim := ⟦ match mb { 0 => (Option.None, stream), _ => - let (count, s) = get_tag0(stream); + let (count, s) = get_tagn0(stream); let (list, s2) = get_ctor_entry_list_inner(s, count); (Option.Some(list), s2), } @@ -775,7 +775,7 @@ def claim := ⟦ fn get_reveal_mut_const_info(stream: ByteStream) -> (RevealMutConstInfo, ByteStream) { let (variant, s) = read_byte(stream); - let (mask, s) = get_tag0(s); + 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]); @@ -814,7 +814,7 @@ def claim := ⟦ fn get_mut_entry(stream: ByteStream) -> ((U64, RevealMutConstInfo), ByteStream) { - let (idx, s) = get_tag0(stream); + let (idx, s) = get_tagn0(stream); let (info, s) = get_reveal_mut_const_info(s); ((idx, info), s) } @@ -830,10 +830,10 @@ def claim := ⟦ } } - -- RevealConstantInfo parser. `variant + mask:Tag0 + per-bit fields`. + -- 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_tag0(s); + 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]); @@ -889,7 +889,7 @@ def claim := ⟦ let (components, s) = match b0 { 0 => (store(ListNode.Nil), s), 1 => - let (count, s2) = get_tag0(s); + let (count, s2) = get_tagn0(s); get_mut_entry_list_inner(s2, count), }; (RevealConstantInfo.Muts(components), s), @@ -1281,9 +1281,13 @@ def claim := ⟦ -- revelation of the committed constant. -- variant 7 (Contains tree target) → run_contains: merkle -- membership. - -- Variants without an arm here (notably 3, Eval) have no defined - -- semantics upstream, so the match falls through and aborts rather - -- than accepting a claim whose meaning is unspecified. + -- 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 + -- variants without an arm (notably 3, Eval) have no defined semantics + -- upstream. In both cases the match falls through and aborts 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). @@ -1294,22 +1298,25 @@ def claim := ⟦ let h = @blake3(bytes); assert_eq!(@b3_pack(h), digest, "claim: bytes do not hash to the public claim digest"); - let (tag, s) = get_tag4(bytes); + -- The claim header is TagN4(0xE, variant): variants 4-7 are the one + -- byte 0xE4-0xE7, and Resource (9) is rung 2, `E8 01`. + let (tag, s) = get_tagn4(bytes); let (flag, size) = tag; - assert_eq!(flag, 0xE, "claim: wrong tag4 flag"); - -- Dispatch on the FULL tag4 size, matching Rust `Claim::get` which - -- matches `tag.size: u64`. The variant is only ever 4-7, so the high 7 - -- bytes must be zero; a size >= 256 whose low byte is 4/5/6/7 would + 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 4-9, 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: tag4 size exceeds a single byte"); + "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, 3u8, "claim: unsupported object format"); + assert_eq!(format, 4u8, "claim: unsupported object format"); let (validator, s) = read_byte(s); match variant { 4 => diff --git a/Ix/IxVM/Kernel/Infer.lean b/Ix/IxVM/Kernel/Infer.lean index 7c89c471a..d514b4145 100644 --- a/Ix/IxVM/Kernel/Infer.lean +++ b/Ix/IxVM/Kernel/Infer.lean @@ -387,10 +387,10 @@ def infer := ⟦ } fn str_addr() -> Addr { - store([0x9du8, 0x6au8, 0xe4u8, 0x34u8, 0x29u8, 0xecu8, 0x02u8, 0xa9u8, - 0x33u8, 0x8bu8, 0xbcu8, 0xd0u8, 0xdbu8, 0x0au8, 0xc1u8, 0x93u8, - 0xd7u8, 0x5eu8, 0xbdu8, 0x46u8, 0xf8u8, 0x84u8, 0xbfu8, 0xcbu8, - 0xd2u8, 0xc4u8, 0x2bu8, 0xf7u8, 0xfau8, 0xeau8, 0x15u8, 0x0du8]) + store([0x22u8, 0x16u8, 0x25u8, 0xa0u8, 0x0eu8, 0xe2u8, 0xd6u8, 0xb9u8, + 0x62u8, 0x97u8, 0xe3u8, 0x4du8, 0x7eu8, 0x05u8, 0xbfu8, 0x7eu8, + 0x4fu8, 0xd3u8, 0x8du8, 0x8du8, 0x99u8, 0xd3u8, 0xe1u8, 0xd6u8, + 0x4au8, 0x7cu8, 0xd2u8, 0xe0u8, 0x6cu8, 0xa0u8, 0x75u8, 0x2du8]) } fn k_infer_lit(lit: KLiteral) -> KExpr { @@ -596,24 +596,24 @@ def infer := ⟦ -- ============================================================================ fn nat_dec_le_addr_dec() -> Addr { - store([0xf0u8, 0xf1u8, 0x5eu8, 0xd0u8, 0x79u8, 0x82u8, 0x2fu8, 0x06u8, - 0xe8u8, 0x2eu8, 0x36u8, 0x66u8, 0x4bu8, 0xf6u8, 0x1eu8, 0x79u8, - 0x7eu8, 0x5bu8, 0x1eu8, 0x7bu8, 0x0bu8, 0x41u8, 0x55u8, 0x15u8, - 0x27u8, 0x62u8, 0xc5u8, 0x13u8, 0x27u8, 0x4bu8, 0xfeu8, 0xe1u8]) + store([0x7bu8, 0xb6u8, 0x59u8, 0x87u8, 0x66u8, 0x71u8, 0xe0u8, 0x3du8, + 0x07u8, 0x31u8, 0xc4u8, 0x56u8, 0xe8u8, 0x94u8, 0xceu8, 0x9eu8, + 0x6fu8, 0x7du8, 0xe8u8, 0x25u8, 0x0au8, 0xb4u8, 0xaeu8, 0x70u8, + 0x11u8, 0x3du8, 0xc0u8, 0x8eu8, 0x24u8, 0x53u8, 0x21u8, 0x27u8]) } fn nat_dec_eq_addr_dec() -> Addr { - store([0x8au8, 0x5du8, 0x5eu8, 0xeeu8, 0x41u8, 0x4au8, 0x2fu8, 0xa5u8, - 0x95u8, 0x6bu8, 0x74u8, 0xe8u8, 0x32u8, 0x3au8, 0x20u8, 0x50u8, - 0x8du8, 0x77u8, 0x4eu8, 0xd1u8, 0xb5u8, 0x60u8, 0x3fu8, 0x55u8, - 0xe7u8, 0x74u8, 0xadu8, 0x89u8, 0x6bu8, 0xd3u8, 0xe6u8, 0xe7u8]) + store([0xf1u8, 0xdeu8, 0x71u8, 0x03u8, 0x80u8, 0x2eu8, 0xbcu8, 0x53u8, + 0x09u8, 0x04u8, 0x1bu8, 0xdau8, 0xadu8, 0xeau8, 0x4au8, 0x65u8, + 0x65u8, 0x2du8, 0x54u8, 0xafu8, 0x37u8, 0xe6u8, 0x6au8, 0xaau8, + 0xf4u8, 0x17u8, 0x87u8, 0xb1u8, 0xd8u8, 0x91u8, 0x95u8, 0x57u8]) } fn nat_dec_lt_addr_dec() -> Addr { - store([0x7cu8, 0x49u8, 0x77u8, 0x19u8, 0x6eu8, 0x95u8, 0xbeu8, 0x2au8, - 0x75u8, 0x9fu8, 0xc9u8, 0xc6u8, 0xd1u8, 0x53u8, 0x3du8, 0xb8u8, - 0xdau8, 0x49u8, 0x59u8, 0x2fu8, 0x06u8, 0x41u8, 0x9bu8, 0x15u8, - 0x5du8, 0x88u8, 0x83u8, 0x33u8, 0xc8u8, 0xddu8, 0x89u8, 0x31u8]) + store([0xafu8, 0x58u8, 0x6bu8, 0x07u8, 0x54u8, 0x6eu8, 0x1fu8, 0xcau8, + 0x9au8, 0xb0u8, 0x78u8, 0x0du8, 0x1cu8, 0x23u8, 0x6au8, 0xf8u8, + 0xd3u8, 0x60u8, 0xc4u8, 0xc6u8, 0xbbu8, 0x32u8, 0xbbu8, 0x0cu8, + 0xd0u8, 0x3eu8, 0xc9u8, 0xcau8, 0x63u8, 0xd3u8, 0xdau8, 0x96u8]) } fn decidable_is_true_addr_dec() -> Addr { @@ -631,31 +631,31 @@ def infer := ⟦ } fn nat_le_of_ble_eq_true_addr_dec() -> Addr { - store([0xadu8, 0x25u8, 0xbfu8, 0xd2u8, 0x07u8, 0xbau8, 0xe8u8, 0x32u8, - 0xc7u8, 0x3du8, 0x5cu8, 0xe6u8, 0x14u8, 0xbeu8, 0xadu8, 0x22u8, - 0xefu8, 0x98u8, 0x62u8, 0xe1u8, 0x10u8, 0xf8u8, 0xd1u8, 0x7au8, - 0x50u8, 0x64u8, 0xffu8, 0xb7u8, 0x60u8, 0x3eu8, 0xeeu8, 0x3du8]) + store([0x5cu8, 0x99u8, 0xdcu8, 0x61u8, 0x88u8, 0x9eu8, 0x4au8, 0x1eu8, + 0x06u8, 0xffu8, 0x6fu8, 0x24u8, 0xd1u8, 0x84u8, 0xdcu8, 0x65u8, + 0x53u8, 0x02u8, 0x8cu8, 0xc6u8, 0x2bu8, 0x89u8, 0xfau8, 0x61u8, + 0xbcu8, 0x23u8, 0x11u8, 0x5bu8, 0x6au8, 0x76u8, 0x20u8, 0x68u8]) } fn nat_not_le_of_not_ble_eq_true_addr_dec() -> Addr { - store([0xe3u8, 0x65u8, 0x8fu8, 0x50u8, 0xdcu8, 0x51u8, 0x23u8, 0xefu8, - 0xffu8, 0x21u8, 0x35u8, 0x88u8, 0xdeu8, 0xe3u8, 0xd4u8, 0xc6u8, - 0x06u8, 0x3fu8, 0x5eu8, 0xdbu8, 0x18u8, 0x95u8, 0x08u8, 0x50u8, - 0xacu8, 0x04u8, 0x90u8, 0xc9u8, 0x37u8, 0x81u8, 0x90u8, 0x09u8]) + store([0x93u8, 0xc0u8, 0xeau8, 0x70u8, 0xc5u8, 0xc3u8, 0x3fu8, 0x7bu8, + 0xceu8, 0xcdu8, 0x40u8, 0x5du8, 0xfdu8, 0xeeu8, 0x5cu8, 0x54u8, + 0x71u8, 0xf7u8, 0x4au8, 0xeeu8, 0x61u8, 0xf8u8, 0xbbu8, 0x61u8, + 0x0bu8, 0x25u8, 0x52u8, 0xd7u8, 0xffu8, 0xe2u8, 0x81u8, 0x83u8]) } fn nat_eq_of_beq_eq_true_addr_dec() -> Addr { - store([0x9cu8, 0x91u8, 0xe7u8, 0x9du8, 0xe7u8, 0x32u8, 0x22u8, 0x6bu8, - 0xa2u8, 0xe7u8, 0x3cu8, 0xbdu8, 0xd3u8, 0x30u8, 0x85u8, 0x1bu8, - 0xaeu8, 0xc4u8, 0x06u8, 0x68u8, 0xebu8, 0x40u8, 0xc6u8, 0xf3u8, - 0x2au8, 0xa2u8, 0xf8u8, 0xdau8, 0xc5u8, 0xa0u8, 0x4bu8, 0x51u8]) + store([0xc4u8, 0x4cu8, 0x52u8, 0x85u8, 0x78u8, 0xdau8, 0xb3u8, 0x90u8, + 0x30u8, 0x88u8, 0xd0u8, 0x64u8, 0xccu8, 0x9bu8, 0x67u8, 0x9du8, + 0x2cu8, 0x0eu8, 0xb3u8, 0xfeu8, 0x73u8, 0xdau8, 0x3cu8, 0x1cu8, + 0xe1u8, 0xccu8, 0x9du8, 0x1bu8, 0x8fu8, 0x2cu8, 0xadu8, 0xd3u8]) } fn nat_ne_of_beq_eq_false_addr_dec() -> Addr { - store([0xa0u8, 0x7du8, 0xb5u8, 0x32u8, 0x74u8, 0x7eu8, 0x65u8, 0xeeu8, - 0x77u8, 0xa7u8, 0xbau8, 0x01u8, 0x50u8, 0x69u8, 0xbdu8, 0xbau8, - 0xf1u8, 0xf7u8, 0x09u8, 0xceu8, 0x0du8, 0x60u8, 0xb8u8, 0x3cu8, - 0x94u8, 0xf4u8, 0x0du8, 0x0eu8, 0x5eu8, 0x57u8, 0x59u8, 0x5au8]) + store([0x6au8, 0x77u8, 0x39u8, 0xcau8, 0x74u8, 0xfdu8, 0x00u8, 0x33u8, + 0xddu8, 0xcbu8, 0x1cu8, 0x4du8, 0x98u8, 0xcdu8, 0xe4u8, 0x19u8, + 0x20u8, 0xf1u8, 0x73u8, 0xd3u8, 0xb8u8, 0xa6u8, 0xfau8, 0xdeu8, + 0x75u8, 0xa4u8, 0x9bu8, 0x74u8, 0x96u8, 0xecu8, 0x8cu8, 0xadu8]) } fn bool_type_addr_dec() -> Addr { @@ -673,24 +673,24 @@ def infer := ⟦ } fn int_dec_eq_addr_dec() -> Addr { - store([0xfcu8, 0x8cu8, 0x44u8, 0xccu8, 0x97u8, 0x0cu8, 0xfcu8, 0x18u8, - 0x3cu8, 0xcdu8, 0x10u8, 0xa2u8, 0xd1u8, 0xcdu8, 0xebu8, 0x2cu8, - 0x84u8, 0x93u8, 0x07u8, 0x76u8, 0x0eu8, 0x91u8, 0xf5u8, 0xcdu8, - 0x29u8, 0xa2u8, 0xb0u8, 0x2fu8, 0x70u8, 0x6du8, 0x83u8, 0xdau8]) + store([0x35u8, 0xa9u8, 0xedu8, 0x72u8, 0x02u8, 0xe3u8, 0xc4u8, 0x38u8, + 0x57u8, 0xcdu8, 0xc4u8, 0x06u8, 0x3eu8, 0xacu8, 0x12u8, 0x3fu8, + 0xe7u8, 0xb7u8, 0x7fu8, 0x06u8, 0x31u8, 0x15u8, 0x4au8, 0xc5u8, + 0x40u8, 0xdbu8, 0xa2u8, 0xc9u8, 0x97u8, 0xbdu8, 0xf2u8, 0x24u8]) } fn int_dec_le_addr_dec() -> Addr { - store([0xfcu8, 0xdfu8, 0x18u8, 0x60u8, 0xadu8, 0x4cu8, 0xd6u8, 0x72u8, - 0x23u8, 0x93u8, 0x92u8, 0xe6u8, 0x0eu8, 0x7bu8, 0x49u8, 0xe0u8, - 0x24u8, 0xafu8, 0x04u8, 0x75u8, 0x73u8, 0x9cu8, 0x3au8, 0x40u8, - 0x19u8, 0x5au8, 0x91u8, 0x4eu8, 0xaeu8, 0xc4u8, 0x2cu8, 0x04u8]) + store([0x17u8, 0x10u8, 0x03u8, 0x4au8, 0x51u8, 0x7fu8, 0x24u8, 0x9fu8, + 0x5cu8, 0x82u8, 0x65u8, 0xe8u8, 0xe2u8, 0x78u8, 0x3bu8, 0xe6u8, + 0x06u8, 0x19u8, 0xf0u8, 0xc8u8, 0xe8u8, 0x5fu8, 0x4eu8, 0xabu8, + 0x62u8, 0x5eu8, 0x85u8, 0x98u8, 0x3au8, 0xbdu8, 0x72u8, 0x2eu8]) } fn int_dec_lt_addr_dec() -> Addr { - store([0x1du8, 0x54u8, 0x80u8, 0x6au8, 0xb1u8, 0xebu8, 0xc7u8, 0x91u8, - 0xe1u8, 0xdbu8, 0x96u8, 0xe8u8, 0x8du8, 0x04u8, 0x07u8, 0xceu8, - 0xf3u8, 0x52u8, 0x39u8, 0x27u8, 0xd6u8, 0x0bu8, 0xa6u8, 0x69u8, - 0x68u8, 0x9bu8, 0x92u8, 0xa8u8, 0xeeu8, 0xb3u8, 0x64u8, 0x45u8]) + store([0x53u8, 0x18u8, 0x87u8, 0x7au8, 0xe6u8, 0x1eu8, 0x1du8, 0xa3u8, + 0x79u8, 0x80u8, 0xd8u8, 0x0cu8, 0x11u8, 0xe3u8, 0xe4u8, 0x7au8, + 0x36u8, 0xd8u8, 0x50u8, 0xc3u8, 0xe4u8, 0x3eu8, 0x99u8, 0x71u8, + 0x61u8, 0x22u8, 0xf1u8, 0xe6u8, 0xefu8, 0xf0u8, 0x1eu8, 0x9fu8]) } fn int_of_nat_addr_dec() -> Addr { diff --git a/Ix/IxVM/Kernel/InferOnly.lean b/Ix/IxVM/Kernel/InferOnly.lean index c6df98f1a..e98115fbd 100644 --- a/Ix/IxVM/Kernel/InferOnly.lean +++ b/Ix/IxVM/Kernel/InferOnly.lean @@ -66,10 +66,10 @@ def inferOnly := ⟦ } fn str_addr_io() -> Addr { - store([0x9du8, 0x6au8, 0xe4u8, 0x34u8, 0x29u8, 0xecu8, 0x02u8, 0xa9u8, - 0x33u8, 0x8bu8, 0xbcu8, 0xd0u8, 0xdbu8, 0x0au8, 0xc1u8, 0x93u8, - 0xd7u8, 0x5eu8, 0xbdu8, 0x46u8, 0xf8u8, 0x84u8, 0xbfu8, 0xcbu8, - 0xd2u8, 0xc4u8, 0x2bu8, 0xf7u8, 0xfau8, 0xeau8, 0x15u8, 0x0du8]) + store([0x22u8, 0x16u8, 0x25u8, 0xa0u8, 0x0eu8, 0xe2u8, 0xd6u8, 0xb9u8, + 0x62u8, 0x97u8, 0xe3u8, 0x4du8, 0x7eu8, 0x05u8, 0xbfu8, 0x7eu8, + 0x4fu8, 0xd3u8, 0x8du8, 0x8du8, 0x99u8, 0xd3u8, 0xe1u8, 0xd6u8, + 0x4au8, 0x7cu8, 0xd2u8, 0xe0u8, 0x6cu8, 0xa0u8, 0x75u8, 0x2du8]) } -- k_infer_only: type-synthesis-only (mirror Rust `with_infer_only`). diff --git a/Ix/IxVM/Kernel/NatPrim.lean b/Ix/IxVM/Kernel/NatPrim.lean index 09027e7aa..e9ab11a50 100644 --- a/Ix/IxVM/Kernel/NatPrim.lean +++ b/Ix/IxVM/Kernel/NatPrim.lean @@ -53,122 +53,122 @@ def natPrim := ⟦ } fn nat_pred_addr() -> Addr { - store([0x76u8, 0xafu8, 0xa2u8, 0x54u8, 0xa8u8, 0xbbu8, 0xf2u8, 0xacu8, - 0x43u8, 0x27u8, 0xd7u8, 0xb9u8, 0x4bu8, 0xe0u8, 0xc6u8, 0x3bu8, - 0xd7u8, 0x08u8, 0x83u8, 0x6bu8, 0x5fu8, 0x73u8, 0x84u8, 0xceu8, - 0x99u8, 0x03u8, 0x88u8, 0xadu8, 0xb0u8, 0xa1u8, 0xd3u8, 0xcfu8]) + store([0x32u8, 0x44u8, 0x68u8, 0x73u8, 0x01u8, 0xd7u8, 0x79u8, 0xecu8, + 0x75u8, 0x72u8, 0x74u8, 0x76u8, 0x1du8, 0x90u8, 0x3du8, 0xefu8, + 0x3eu8, 0xb3u8, 0x13u8, 0x51u8, 0x77u8, 0x32u8, 0x7bu8, 0x70u8, + 0x9bu8, 0xcbu8, 0xd8u8, 0x54u8, 0xefu8, 0x49u8, 0x6fu8, 0x79u8]) } fn int_of_nat_addr() -> Addr { store([0x0au8, 0x99u8, 0xf4u8, 0x9cu8, 0xc7u8, 0x3au8, 0xb9u8, 0xf4u8, 0x27u8, 0x83u8, 0x09u8, 0x2eu8, 0x71u8, 0x20u8, 0x61u8, 0x32u8, 0x25u8, 0x67u8, 0x0bu8, 0xabu8, 0x89u8, 0xb9u8, 0xd6u8, 0x35u8, 0x33u8, 0xd1u8, 0xadu8, 0xefu8, 0xc8u8, 0x76u8, 0x18u8, 0x2fu8]) } fn int_neg_succ_addr() -> Addr { store([0xf7u8, 0x13u8, 0x0du8, 0x58u8, 0x64u8, 0xe1u8, 0xbau8, 0x77u8, 0xb0u8, 0xf6u8, 0xa7u8, 0x33u8, 0x8fu8, 0x92u8, 0x15u8, 0x9cu8, 0x35u8, 0xbdu8, 0x51u8, 0x47u8, 0xe0u8, 0xfeu8, 0xbcu8, 0xf1u8, 0xebu8, 0xedu8, 0x45u8, 0x6eu8, 0x51u8, 0x35u8, 0x38u8, 0xccu8]) } - fn int_add_addr() -> Addr { store([0x9du8, 0xb0u8, 0x17u8, 0x7eu8, 0x4eu8, 0x8bu8, 0x6au8, 0x0eu8, 0x73u8, 0x23u8, 0x06u8, 0x95u8, 0x09u8, 0xc2u8, 0x45u8, 0x7du8, 0xe9u8, 0x59u8, 0x8au8, 0x7eu8, 0x38u8, 0xe7u8, 0x2fu8, 0xfeu8, 0x19u8, 0xadu8, 0x34u8, 0x61u8, 0x72u8, 0x56u8, 0xe1u8, 0x0du8]) } - fn int_sub_addr() -> Addr { store([0x85u8, 0x62u8, 0x13u8, 0x87u8, 0xefu8, 0x30u8, 0x27u8, 0x02u8, 0x8du8, 0x83u8, 0x52u8, 0x87u8, 0xf3u8, 0xccu8, 0x14u8, 0x61u8, 0xefu8, 0x04u8, 0x1du8, 0xefu8, 0x1fu8, 0xd9u8, 0x1eu8, 0x28u8, 0xe8u8, 0x7fu8, 0x66u8, 0x9cu8, 0xc0u8, 0x4au8, 0x5eu8, 0xeau8]) } - fn int_mul_addr() -> Addr { store([0xb0u8, 0x54u8, 0x59u8, 0x62u8, 0x3du8, 0x23u8, 0x29u8, 0x9du8, 0x3au8, 0x84u8, 0x9eu8, 0xb7u8, 0xfbu8, 0x75u8, 0xbau8, 0xdbu8, 0xc1u8, 0x54u8, 0x7au8, 0x1cu8, 0xd9u8, 0xeeu8, 0x56u8, 0x0cu8, 0x15u8, 0x06u8, 0x7fu8, 0xbdu8, 0x98u8, 0x5cu8, 0x6cu8, 0xeau8]) } - fn int_neg_addr() -> Addr { store([0x67u8, 0x01u8, 0xd7u8, 0x65u8, 0xffu8, 0x10u8, 0xbfu8, 0xa3u8, 0xa6u8, 0xc3u8, 0x47u8, 0xdfu8, 0x15u8, 0x19u8, 0x4eu8, 0x0du8, 0xb8u8, 0x62u8, 0xeeu8, 0x25u8, 0xb5u8, 0x4fu8, 0x25u8, 0xa5u8, 0x9fu8, 0x7cu8, 0xf2u8, 0x19u8, 0x51u8, 0xa3u8, 0x99u8, 0x7eu8]) } - fn int_emod_addr() -> Addr { store([0xe2u8, 0x9cu8, 0xfau8, 0x79u8, 0x21u8, 0xbbu8, 0x57u8, 0xf4u8, 0x78u8, 0x2bu8, 0x02u8, 0x1cu8, 0x97u8, 0x75u8, 0x96u8, 0xa4u8, 0xfau8, 0xe0u8, 0x4eu8, 0x94u8, 0xf7u8, 0xb0u8, 0x79u8, 0x55u8, 0xfeu8, 0x28u8, 0x14u8, 0xfcu8, 0x48u8, 0xdeu8, 0x90u8, 0xe7u8]) } - fn int_ediv_addr() -> Addr { store([0x9cu8, 0x95u8, 0x2du8, 0x45u8, 0xa3u8, 0xbdu8, 0x43u8, 0x16u8, 0x15u8, 0x29u8, 0xfcu8, 0xfbu8, 0x5eu8, 0x27u8, 0x6bu8, 0xeau8, 0xb0u8, 0xcfu8, 0x4fu8, 0xd6u8, 0x4au8, 0x01u8, 0xbau8, 0x9bu8, 0xc2u8, 0xc7u8, 0xcdu8, 0xa3u8, 0x76u8, 0xcbu8, 0x8fu8, 0x54u8]) } - fn int_bmod_addr() -> Addr { store([0x0bu8, 0x15u8, 0x64u8, 0xdeu8, 0xa6u8, 0xffu8, 0xcdu8, 0x20u8, 0x4eu8, 0xbcu8, 0xd1u8, 0xaau8, 0x69u8, 0xd2u8, 0x9eu8, 0xe6u8, 0xf3u8, 0xacu8, 0xccu8, 0xd8u8, 0x7bu8, 0xd1u8, 0x46u8, 0xffu8, 0x67u8, 0x45u8, 0x56u8, 0xacu8, 0x9cu8, 0xc8u8, 0xccu8, 0xb3u8]) } - fn int_bdiv_addr() -> Addr { store([0x6du8, 0x35u8, 0xdcu8, 0x43u8, 0x66u8, 0x0fu8, 0x6cu8, 0x50u8, 0x9au8, 0x13u8, 0xf2u8, 0x82u8, 0x4cu8, 0x02u8, 0x7eu8, 0xd9u8, 0x9au8, 0xb0u8, 0x70u8, 0xa0u8, 0x8fu8, 0x05u8, 0x8fu8, 0xf0u8, 0xa5u8, 0xf4u8, 0x6au8, 0x75u8, 0x92u8, 0x50u8, 0x79u8, 0x7du8]) } - fn int_nat_abs_addr() -> Addr { store([0x26u8, 0x1au8, 0xe5u8, 0x4eu8, 0xdbu8, 0x66u8, 0xe9u8, 0x00u8, 0x78u8, 0x4au8, 0x64u8, 0x35u8, 0x0bu8, 0xc0u8, 0x1eu8, 0x8bu8, 0x3fu8, 0xe1u8, 0x33u8, 0x2au8, 0x47u8, 0xcau8, 0xeau8, 0xb5u8, 0x8eu8, 0x03u8, 0x61u8, 0xdfu8, 0xfcu8, 0x7eu8, 0xa0u8, 0x08u8]) } - fn int_pow_addr() -> Addr { store([0x87u8, 0x26u8, 0x64u8, 0x15u8, 0x98u8, 0x2bu8, 0xbdu8, 0xecu8, 0x50u8, 0xc6u8, 0x1du8, 0xecu8, 0x5bu8, 0x73u8, 0xccu8, 0x0cu8, 0xcdu8, 0x5cu8, 0x99u8, 0x74u8, 0x45u8, 0x99u8, 0x7au8, 0x97u8, 0x24u8, 0xa1u8, 0xccu8, 0x5cu8, 0x2eu8, 0x39u8, 0xd3u8, 0xa4u8]) } + fn int_add_addr() -> Addr { store([0xb6u8, 0x66u8, 0x92u8, 0x5bu8, 0x10u8, 0x47u8, 0x3fu8, 0xbeu8, 0x1au8, 0x76u8, 0x30u8, 0xecu8, 0x49u8, 0x6fu8, 0xe0u8, 0x7du8, 0x79u8, 0x9cu8, 0x52u8, 0x48u8, 0x66u8, 0x7du8, 0xb1u8, 0xe2u8, 0x30u8, 0x2fu8, 0xcau8, 0x5fu8, 0xe4u8, 0xc5u8, 0x0cu8, 0xb6u8]) } + fn int_sub_addr() -> Addr { store([0x7cu8, 0x60u8, 0x04u8, 0x3du8, 0x60u8, 0x16u8, 0xe2u8, 0xf0u8, 0xefu8, 0x5du8, 0x76u8, 0x4eu8, 0x1au8, 0xb7u8, 0x92u8, 0x39u8, 0x68u8, 0xd4u8, 0x3du8, 0x5cu8, 0x38u8, 0x81u8, 0x86u8, 0xddu8, 0xf6u8, 0xc8u8, 0x3cu8, 0x28u8, 0xf0u8, 0x24u8, 0x01u8, 0x7au8]) } + fn int_mul_addr() -> Addr { store([0x9du8, 0xffu8, 0x94u8, 0x9eu8, 0x4du8, 0x02u8, 0x82u8, 0x39u8, 0x32u8, 0x13u8, 0x04u8, 0x2au8, 0x36u8, 0xa6u8, 0x9au8, 0xf4u8, 0xb7u8, 0x1au8, 0x58u8, 0x70u8, 0x90u8, 0x96u8, 0xeau8, 0xa3u8, 0xdeu8, 0x51u8, 0x30u8, 0xbau8, 0xe0u8, 0xafu8, 0x84u8, 0xf3u8]) } + fn int_neg_addr() -> Addr { store([0x19u8, 0xc8u8, 0x76u8, 0x49u8, 0xf9u8, 0xa1u8, 0x78u8, 0x09u8, 0xf2u8, 0x48u8, 0xbeu8, 0xffu8, 0x7bu8, 0xc3u8, 0x7fu8, 0x56u8, 0x9fu8, 0x54u8, 0x8eu8, 0x24u8, 0xa9u8, 0x8du8, 0x8au8, 0x7cu8, 0xddu8, 0xd5u8, 0xb8u8, 0x2eu8, 0xb8u8, 0x08u8, 0xe5u8, 0xa6u8]) } + fn int_emod_addr() -> Addr { store([0x13u8, 0xc9u8, 0x7eu8, 0x84u8, 0xfbu8, 0x8au8, 0xc3u8, 0xeeu8, 0x81u8, 0x20u8, 0xe9u8, 0x23u8, 0xd6u8, 0x1fu8, 0xcau8, 0x6fu8, 0x7eu8, 0x6bu8, 0xb9u8, 0x24u8, 0x1eu8, 0xc3u8, 0xaau8, 0x5du8, 0x35u8, 0x9bu8, 0xa5u8, 0xdcu8, 0xe5u8, 0x42u8, 0xaau8, 0x11u8]) } + fn int_ediv_addr() -> Addr { store([0x53u8, 0xe4u8, 0x04u8, 0xf5u8, 0xddu8, 0x3cu8, 0x53u8, 0x69u8, 0x3bu8, 0xc3u8, 0xb5u8, 0xbfu8, 0xaeu8, 0x58u8, 0x2bu8, 0x04u8, 0x96u8, 0xecu8, 0x3cu8, 0x05u8, 0xafu8, 0x0cu8, 0xeeu8, 0x0au8, 0x46u8, 0xc3u8, 0x8au8, 0xb6u8, 0x62u8, 0xc5u8, 0x7fu8, 0xdfu8]) } + fn int_bmod_addr() -> Addr { store([0xd0u8, 0x38u8, 0x0du8, 0xc9u8, 0xb6u8, 0x3au8, 0xfeu8, 0xebu8, 0x32u8, 0x35u8, 0xa7u8, 0x7au8, 0xdeu8, 0xb3u8, 0x55u8, 0xa8u8, 0xb5u8, 0x2bu8, 0x07u8, 0x30u8, 0x97u8, 0x15u8, 0x95u8, 0x09u8, 0x37u8, 0x41u8, 0xecu8, 0x2cu8, 0x6du8, 0x57u8, 0xcdu8, 0x49u8]) } + fn int_bdiv_addr() -> Addr { store([0x20u8, 0x9au8, 0xcau8, 0x62u8, 0xccu8, 0x1fu8, 0x9du8, 0xd2u8, 0xc0u8, 0xa9u8, 0x28u8, 0xcdu8, 0x84u8, 0xd7u8, 0x2bu8, 0xb4u8, 0x15u8, 0x70u8, 0xaau8, 0x97u8, 0xc1u8, 0xfdu8, 0x83u8, 0x3eu8, 0x5fu8, 0xffu8, 0xc5u8, 0x67u8, 0xc1u8, 0xc6u8, 0x40u8, 0x1fu8]) } + fn int_nat_abs_addr() -> Addr { store([0x01u8, 0xe7u8, 0xc7u8, 0x24u8, 0x50u8, 0x88u8, 0x97u8, 0xe0u8, 0x1eu8, 0x5du8, 0x0bu8, 0x8fu8, 0x72u8, 0xe2u8, 0xcfu8, 0xa2u8, 0x60u8, 0x7cu8, 0xeau8, 0x5fu8, 0xf0u8, 0xd3u8, 0x52u8, 0xd0u8, 0x08u8, 0xd0u8, 0xe7u8, 0x51u8, 0x2au8, 0xabu8, 0x2fu8, 0x46u8]) } + fn int_pow_addr() -> Addr { store([0xa2u8, 0x89u8, 0x58u8, 0xd7u8, 0x47u8, 0xe8u8, 0x7bu8, 0x5au8, 0x60u8, 0xe4u8, 0xfau8, 0x07u8, 0xefu8, 0x7eu8, 0xd8u8, 0xd9u8, 0x49u8, 0xf6u8, 0x9au8, 0xdcu8, 0xbcu8, 0x44u8, 0xafu8, 0xe2u8, 0x95u8, 0x84u8, 0x82u8, 0xd3u8, 0xeeu8, 0x9bu8, 0x33u8, 0x65u8]) } fn nat_add_addr() -> Addr { - store([0x72u8, 0x4du8, 0xb7u8, 0x97u8, 0xe1u8, 0x81u8, 0x75u8, 0x45u8, - 0xa0u8, 0x83u8, 0x71u8, 0x43u8, 0x2fu8, 0xd1u8, 0xfau8, 0x64u8, - 0x28u8, 0xa3u8, 0x7du8, 0xcfu8, 0x9cu8, 0x16u8, 0x71u8, 0xdfu8, - 0x7eu8, 0x46u8, 0x48u8, 0x49u8, 0xdbu8, 0x0au8, 0x81u8, 0xacu8]) + store([0x3eu8, 0x8au8, 0xadu8, 0xccu8, 0x61u8, 0x1cu8, 0x4du8, 0x86u8, + 0x77u8, 0xcau8, 0xdfu8, 0x00u8, 0xc7u8, 0x85u8, 0x06u8, 0x56u8, + 0x1du8, 0x33u8, 0x73u8, 0x8eu8, 0xe3u8, 0xd5u8, 0x71u8, 0xf7u8, + 0xa4u8, 0x19u8, 0x6eu8, 0x26u8, 0x05u8, 0x80u8, 0xc9u8, 0xb8u8]) } fn nat_sub_addr() -> Addr { - store([0x9du8, 0xe2u8, 0xd2u8, 0xc6u8, 0x0eu8, 0x7du8, 0x42u8, 0x1au8, - 0x2fu8, 0xdfu8, 0xb8u8, 0x70u8, 0x6eu8, 0x91u8, 0xe0u8, 0xe6u8, - 0xd8u8, 0x57u8, 0x6cu8, 0x3bu8, 0xd4u8, 0x6eu8, 0xc0u8, 0x04u8, - 0x05u8, 0xc6u8, 0x58u8, 0x75u8, 0xcbu8, 0x9bu8, 0x5au8, 0x26u8]) + store([0x03u8, 0xb3u8, 0xa0u8, 0x41u8, 0x28u8, 0x5bu8, 0x0fu8, 0xe2u8, + 0x02u8, 0xd9u8, 0x0bu8, 0x22u8, 0x7du8, 0x40u8, 0x5cu8, 0x4cu8, + 0xecu8, 0x25u8, 0x2du8, 0xf1u8, 0x8bu8, 0xa7u8, 0x61u8, 0x6au8, + 0xcdu8, 0x6du8, 0xaeu8, 0x27u8, 0x92u8, 0xe6u8, 0x72u8, 0xbbu8]) } fn nat_mul_addr() -> Addr { - store([0x56u8, 0x6au8, 0x3cu8, 0x22u8, 0x49u8, 0xbcu8, 0x20u8, 0x76u8, - 0x54u8, 0x3du8, 0x9bu8, 0xc5u8, 0x61u8, 0xa8u8, 0x41u8, 0xf6u8, - 0xfdu8, 0x35u8, 0xffu8, 0xb5u8, 0xbdu8, 0xbbu8, 0xc5u8, 0xc9u8, - 0x91u8, 0xa9u8, 0xc6u8, 0x4fu8, 0xecu8, 0xcbu8, 0xd5u8, 0xd4u8]) + store([0x37u8, 0x3bu8, 0x7du8, 0x74u8, 0xf6u8, 0xb4u8, 0x0du8, 0xa1u8, + 0x1bu8, 0x7eu8, 0xd7u8, 0x96u8, 0x03u8, 0xa4u8, 0x5eu8, 0xc7u8, + 0x01u8, 0x1au8, 0x88u8, 0x31u8, 0xb7u8, 0x20u8, 0xb5u8, 0x7du8, + 0x2eu8, 0xfeu8, 0x92u8, 0xe8u8, 0x2au8, 0x3du8, 0x57u8, 0xf0u8]) } fn nat_pow_addr() -> Addr { - store([0x5bu8, 0xa4u8, 0x3au8, 0xc3u8, 0xe5u8, 0xd2u8, 0x9fu8, 0xe5u8, - 0xceu8, 0x81u8, 0xf1u8, 0x8au8, 0x18u8, 0x17u8, 0x8au8, 0x27u8, - 0x05u8, 0xc3u8, 0x7eu8, 0xe6u8, 0x74u8, 0xb9u8, 0xb6u8, 0xeeu8, - 0x50u8, 0xe9u8, 0x46u8, 0x6au8, 0x86u8, 0x59u8, 0x3bu8, 0x15u8]) + store([0x5bu8, 0xaau8, 0xf0u8, 0x5cu8, 0x96u8, 0x9du8, 0x2cu8, 0xf3u8, + 0x77u8, 0x31u8, 0x21u8, 0x11u8, 0xbeu8, 0x51u8, 0xbbu8, 0x64u8, + 0xc6u8, 0x00u8, 0xc1u8, 0x3fu8, 0xa1u8, 0x64u8, 0xeeu8, 0x72u8, + 0x2eu8, 0x92u8, 0x24u8, 0x3bu8, 0x0fu8, 0x77u8, 0x1bu8, 0xabu8]) } fn nat_gcd_addr() -> Addr { - store([0x76u8, 0x00u8, 0x7du8, 0xcfu8, 0x8bu8, 0x28u8, 0x5cu8, 0xdbu8, - 0xd6u8, 0xf7u8, 0x79u8, 0x01u8, 0x22u8, 0x90u8, 0xfeu8, 0x2eu8, - 0x6au8, 0xfdu8, 0x22u8, 0x1cu8, 0xe8u8, 0x82u8, 0x10u8, 0x82u8, - 0xa7u8, 0xe2u8, 0xefu8, 0x81u8, 0xe8u8, 0xd8u8, 0x15u8, 0xcfu8]) + store([0xabu8, 0xa9u8, 0x4bu8, 0xfbu8, 0x41u8, 0x35u8, 0x1du8, 0x4du8, + 0xb3u8, 0x61u8, 0x72u8, 0xc3u8, 0x79u8, 0xa5u8, 0x12u8, 0xf0u8, + 0x42u8, 0x19u8, 0xefu8, 0x21u8, 0xdcu8, 0x54u8, 0x54u8, 0xd7u8, + 0x15u8, 0x90u8, 0x96u8, 0x7du8, 0x4eu8, 0x8fu8, 0x91u8, 0x3fu8]) } fn nat_mod_addr() -> Addr { - store([0xe6u8, 0xffu8, 0xe7u8, 0x87u8, 0x13u8, 0xd4u8, 0xb9u8, 0x74u8, - 0xa8u8, 0x2du8, 0x01u8, 0x87u8, 0x53u8, 0x8fu8, 0x1au8, 0x0cu8, - 0xf5u8, 0xc4u8, 0xb2u8, 0x60u8, 0xf0u8, 0xfdu8, 0x99u8, 0x26u8, - 0x4fu8, 0xabu8, 0x26u8, 0x3bu8, 0x1au8, 0xf8u8, 0x47u8, 0xf9u8]) + store([0x11u8, 0xabu8, 0xbfu8, 0x98u8, 0x64u8, 0x81u8, 0xc5u8, 0x3au8, + 0x21u8, 0xc8u8, 0xcbu8, 0x21u8, 0xeeu8, 0x25u8, 0x81u8, 0xaeu8, + 0x62u8, 0x38u8, 0xaeu8, 0xdbu8, 0xecu8, 0x15u8, 0xf9u8, 0x72u8, + 0x95u8, 0x9du8, 0x08u8, 0x6bu8, 0xefu8, 0x1au8, 0x19u8, 0x85u8]) } fn nat_div_addr() -> Addr { - store([0xc0u8, 0x75u8, 0xedu8, 0x97u8, 0x6fu8, 0x17u8, 0x02u8, 0xf3u8, - 0x64u8, 0xfbu8, 0x0bu8, 0xb3u8, 0x4au8, 0xa8u8, 0xbbu8, 0xc1u8, - 0x66u8, 0xadu8, 0xacu8, 0xe5u8, 0x73u8, 0xf2u8, 0xceu8, 0x91u8, - 0x4bu8, 0x43u8, 0xdcu8, 0x4fu8, 0x4au8, 0xabu8, 0x62u8, 0x19u8]) + store([0x82u8, 0x4du8, 0x1cu8, 0x53u8, 0xd8u8, 0xc1u8, 0xc3u8, 0xcfu8, + 0x0au8, 0x27u8, 0xf2u8, 0x46u8, 0x39u8, 0xecu8, 0x2bu8, 0xe1u8, + 0xecu8, 0xc1u8, 0x3du8, 0x4au8, 0x01u8, 0xc9u8, 0x93u8, 0x17u8, + 0x15u8, 0x95u8, 0xedu8, 0xccu8, 0xf6u8, 0x94u8, 0x97u8, 0x37u8]) } fn nat_land_addr() -> Addr { - store([0xc6u8, 0x1fu8, 0xadu8, 0x46u8, 0xa1u8, 0x02u8, 0xdbu8, 0xffu8, - 0x59u8, 0x22u8, 0x31u8, 0x2du8, 0x4fu8, 0xbeu8, 0x6eu8, 0x70u8, - 0x4eu8, 0xc3u8, 0xc6u8, 0x2cu8, 0x6cu8, 0x6fu8, 0x64u8, 0xb3u8, - 0xd4u8, 0x81u8, 0xb7u8, 0x8cu8, 0x77u8, 0xcfu8, 0x31u8, 0x5du8]) + store([0xd9u8, 0x8bu8, 0xedu8, 0x1eu8, 0x14u8, 0xcdu8, 0xa0u8, 0xeeu8, + 0xa4u8, 0x70u8, 0xa5u8, 0xa4u8, 0x9fu8, 0xf7u8, 0x92u8, 0x6cu8, + 0x80u8, 0xebu8, 0x4bu8, 0xc7u8, 0xbfu8, 0xbdu8, 0xd0u8, 0xc3u8, + 0xe1u8, 0x4du8, 0x4bu8, 0xaau8, 0x5cu8, 0x2du8, 0xd0u8, 0xd7u8]) } fn nat_lor_addr() -> Addr { - store([0xcbu8, 0x7du8, 0xccu8, 0xc0u8, 0x20u8, 0xa5u8, 0x30u8, 0xfeu8, - 0xd7u8, 0xc6u8, 0x22u8, 0xb1u8, 0x00u8, 0xeeu8, 0x52u8, 0xc1u8, - 0x07u8, 0x8bu8, 0x50u8, 0x18u8, 0x15u8, 0x9bu8, 0xa4u8, 0x68u8, - 0x2fu8, 0x81u8, 0x7eu8, 0x37u8, 0x76u8, 0x78u8, 0x9eu8, 0xe8u8]) + store([0x88u8, 0xffu8, 0x34u8, 0xddu8, 0x42u8, 0xe5u8, 0x77u8, 0x66u8, + 0xbeu8, 0xefu8, 0xc2u8, 0x29u8, 0xd8u8, 0xb6u8, 0x2du8, 0xabu8, + 0xbau8, 0x9cu8, 0xefu8, 0x6au8, 0xadu8, 0xccu8, 0x85u8, 0xc8u8, + 0x8au8, 0xd6u8, 0x73u8, 0x23u8, 0xd0u8, 0x2bu8, 0xbfu8, 0x21u8]) } fn nat_xor_addr() -> Addr { - store([0xd8u8, 0xa6u8, 0xb0u8, 0x5au8, 0x1au8, 0x4eu8, 0x5cu8, 0xadu8, - 0xc6u8, 0x9cu8, 0x53u8, 0x79u8, 0x2eu8, 0x8eu8, 0x13u8, 0x03u8, - 0x14u8, 0x74u8, 0x5eu8, 0x76u8, 0xe3u8, 0x2bu8, 0xb3u8, 0x0au8, - 0x9cu8, 0xe0u8, 0x27u8, 0x2fu8, 0xa0u8, 0x79u8, 0xe8u8, 0xa6u8]) + store([0x1bu8, 0x0au8, 0xcdu8, 0xd4u8, 0x08u8, 0x0au8, 0xbeu8, 0x5bu8, + 0xc4u8, 0xacu8, 0xb5u8, 0xf0u8, 0x65u8, 0x27u8, 0xcbu8, 0x62u8, + 0xadu8, 0x92u8, 0x79u8, 0x2eu8, 0xb4u8, 0x29u8, 0xc2u8, 0xb3u8, + 0xbcu8, 0xb6u8, 0xf4u8, 0x71u8, 0xd7u8, 0x94u8, 0x50u8, 0x85u8]) } fn nat_shift_left_addr() -> Addr { - store([0x5cu8, 0x15u8, 0xf9u8, 0x8eu8, 0x2bu8, 0xd9u8, 0xc2u8, 0x57u8, - 0xbcu8, 0xdfu8, 0xacu8, 0x62u8, 0xb0u8, 0x04u8, 0x3au8, 0x2eu8, - 0x3eu8, 0x2bu8, 0xbdu8, 0xffu8, 0x8bu8, 0x21u8, 0x0fu8, 0x10u8, - 0x4bu8, 0x5cu8, 0x37u8, 0x39u8, 0xe8u8, 0x62u8, 0xacu8, 0x0cu8]) + store([0x05u8, 0xbbu8, 0x65u8, 0x7eu8, 0x8bu8, 0x9du8, 0x5du8, 0xc2u8, + 0x24u8, 0xe7u8, 0xefu8, 0x3du8, 0x53u8, 0xe5u8, 0x41u8, 0x53u8, + 0xceu8, 0x3au8, 0xc2u8, 0x6du8, 0xa8u8, 0xd1u8, 0xf1u8, 0xb1u8, + 0xd6u8, 0x10u8, 0x69u8, 0xa3u8, 0x72u8, 0x65u8, 0x66u8, 0xcdu8]) } fn nat_shift_right_addr() -> Addr { - store([0x3fu8, 0x92u8, 0x72u8, 0x53u8, 0x24u8, 0xb0u8, 0x9fu8, 0xa7u8, - 0x5cu8, 0x6fu8, 0xcdu8, 0x16u8, 0xdau8, 0x86u8, 0x36u8, 0x71u8, - 0x42u8, 0x8fu8, 0xf3u8, 0x3bu8, 0x7du8, 0xb6u8, 0x67u8, 0xebu8, - 0x76u8, 0x0eu8, 0x1cu8, 0xd5u8, 0x03u8, 0xa2u8, 0xbcu8, 0xadu8]) + store([0x25u8, 0x01u8, 0x9fu8, 0xf4u8, 0x85u8, 0xfcu8, 0xf5u8, 0x70u8, + 0x95u8, 0x97u8, 0xcdu8, 0x1eu8, 0x07u8, 0xfcu8, 0xc3u8, 0xceu8, + 0x79u8, 0x67u8, 0x76u8, 0xefu8, 0x3fu8, 0x71u8, 0x5au8, 0x6du8, + 0x18u8, 0x7eu8, 0xb5u8, 0x83u8, 0x1cu8, 0x63u8, 0xb4u8, 0xbeu8]) } fn nat_beq_addr() -> Addr { - store([0xffu8, 0xd3u8, 0xf0u8, 0x2au8, 0x19u8, 0xfdu8, 0xa6u8, 0x49u8, - 0xaau8, 0x56u8, 0x08u8, 0xedu8, 0x81u8, 0x8du8, 0xb3u8, 0x82u8, - 0xe1u8, 0x60u8, 0x23u8, 0x1bu8, 0x76u8, 0xd5u8, 0xb0u8, 0x91u8, - 0x76u8, 0xd7u8, 0xddu8, 0x1au8, 0x8du8, 0x5bu8, 0x1eu8, 0xc5u8]) + store([0xd3u8, 0xd8u8, 0xffu8, 0x92u8, 0x4au8, 0xf9u8, 0xdcu8, 0x4bu8, + 0x5cu8, 0xd8u8, 0x69u8, 0x76u8, 0x06u8, 0x15u8, 0xb3u8, 0xe7u8, + 0xeeu8, 0x80u8, 0x91u8, 0x6bu8, 0xb6u8, 0x17u8, 0x25u8, 0x9du8, + 0x45u8, 0x89u8, 0x0cu8, 0x69u8, 0xf4u8, 0x12u8, 0x83u8, 0x37u8]) } fn nat_ble_addr() -> Addr { - store([0x68u8, 0xa3u8, 0x64u8, 0x3eu8, 0xc6u8, 0x98u8, 0x16u8, 0xaeu8, - 0xc1u8, 0x07u8, 0x30u8, 0x2du8, 0xdbu8, 0xfau8, 0x05u8, 0x4cu8, - 0xebu8, 0xcdu8, 0x3eu8, 0xc1u8, 0x73u8, 0xcdu8, 0x5fu8, 0x7eu8, - 0x6du8, 0x88u8, 0x36u8, 0x38u8, 0x63u8, 0x1au8, 0xfeu8, 0x65u8]) + store([0x9eu8, 0x44u8, 0x5bu8, 0x9du8, 0x5fu8, 0x82u8, 0x52u8, 0x77u8, + 0x23u8, 0x47u8, 0x87u8, 0x2eu8, 0x90u8, 0x9bu8, 0x5du8, 0xb4u8, + 0xe7u8, 0xecu8, 0xa7u8, 0x08u8, 0x6cu8, 0xedu8, 0xf4u8, 0xfeu8, + 0xc6u8, 0xdeu8, 0x84u8, 0x0fu8, 0x6bu8, 0x7bu8, 0x5fu8, 0x92u8]) } fn bool_true_addr() -> Addr { @@ -187,17 +187,17 @@ def natPrim := ⟦ -- Native primitives () fn system_platform_num_bits_addr() -> Addr { - store([0x6fu8, 0x62u8, 0x06u8, 0x54u8, 0xd3u8, 0x41u8, 0x99u8, 0x0au8, - 0x30u8, 0x13u8, 0x87u8, 0xb8u8, 0x0eu8, 0xf7u8, 0x5bu8, 0x1eu8, - 0x0bu8, 0x61u8, 0x30u8, 0xddu8, 0xf1u8, 0x91u8, 0x64u8, 0x02u8, - 0x5bu8, 0x6du8, 0xc3u8, 0x7bu8, 0xf3u8, 0xc3u8, 0xdcu8, 0x18u8]) + store([0x57u8, 0xa3u8, 0x1cu8, 0x1eu8, 0x34u8, 0xcfu8, 0x39u8, 0x93u8, + 0xb2u8, 0x09u8, 0x39u8, 0xddu8, 0x29u8, 0xbau8, 0x27u8, 0x26u8, + 0x3fu8, 0x24u8, 0xfbu8, 0xbeu8, 0xedu8, 0xe2u8, 0xf6u8, 0xa6u8, + 0xd0u8, 0x89u8, 0xb8u8, 0x05u8, 0x1fu8, 0xe3u8, 0x2cu8, 0x3cu8]) } fn punit_size_of_1_addr() -> Addr { - store([0xe8u8, 0x5bu8, 0xf5u8, 0x16u8, 0xc7u8, 0x6cu8, 0xadu8, 0xd8u8, - 0xceu8, 0x1fu8, 0xdau8, 0xb3u8, 0xccu8, 0x94u8, 0xedu8, 0x68u8, - 0x5eu8, 0x47u8, 0xbeu8, 0x3cu8, 0x7au8, 0x8bu8, 0x52u8, 0xf5u8, - 0x3fu8, 0xe2u8, 0xb3u8, 0x50u8, 0x2eu8, 0x6fu8, 0x70u8, 0xc7u8]) + store([0x52u8, 0x36u8, 0x99u8, 0xb6u8, 0xe8u8, 0x27u8, 0xb7u8, 0x4au8, + 0x95u8, 0x0du8, 0x47u8, 0x18u8, 0xbdu8, 0xf5u8, 0xb1u8, 0x3cu8, + 0x19u8, 0x3eu8, 0x3cu8, 0x7cu8, 0x37u8, 0x1au8, 0xaau8, 0xd4u8, + 0xd6u8, 0x35u8, 0x66u8, 0x7bu8, 0xe7u8, 0x4bu8, 0x05u8, 0xfau8]) } -- Compiler-emitted native reduction primitives. @@ -216,17 +216,17 @@ def natPrim := ⟦ } fn subtype_val_addr() -> Addr { - store([0xeau8, 0x65u8, 0xf5u8, 0x17u8, 0x45u8, 0x7fu8, 0xaeu8, 0x9bu8, - 0x70u8, 0x52u8, 0x99u8, 0xdau8, 0x08u8, 0xb0u8, 0xd3u8, 0xc8u8, - 0xcfu8, 0x9au8, 0x47u8, 0x6fu8, 0x16u8, 0x47u8, 0x0cu8, 0xcau8, - 0x5cu8, 0xaeu8, 0x5eu8, 0xa7u8, 0xbdu8, 0x23u8, 0x82u8, 0x30u8]) + store([0xd1u8, 0xbfu8, 0xecu8, 0x8du8, 0xf9u8, 0x08u8, 0xc8u8, 0x87u8, + 0xe4u8, 0xf4u8, 0x89u8, 0xadu8, 0xc2u8, 0xeeu8, 0xc7u8, 0x7au8, + 0x53u8, 0xe8u8, 0xffu8, 0x28u8, 0xb5u8, 0xbdu8, 0x9au8, 0x4cu8, + 0x21u8, 0xa5u8, 0x6du8, 0xa6u8, 0x38u8, 0x1eu8, 0xedu8, 0x8fu8]) } fn system_platform_get_num_bits_addr() -> Addr { - store([0x00u8, 0xc2u8, 0x66u8, 0x83u8, 0x4fu8, 0x90u8, 0x39u8, 0x93u8, - 0x1bu8, 0x4bu8, 0xe2u8, 0xfau8, 0xc5u8, 0x58u8, 0x4cu8, 0xd1u8, - 0x76u8, 0xa0u8, 0xaeu8, 0x7eu8, 0xe4u8, 0xcbu8, 0x40u8, 0x64u8, - 0xddu8, 0xb5u8, 0xe0u8, 0x4du8, 0xd1u8, 0x2bu8, 0x6cu8, 0xbbu8]) + store([0x23u8, 0x6eu8, 0x46u8, 0xbdu8, 0xe1u8, 0xf5u8, 0x93u8, 0x09u8, + 0xc2u8, 0xccu8, 0x68u8, 0x5au8, 0x73u8, 0x79u8, 0xbcu8, 0x52u8, + 0x94u8, 0xa9u8, 0x81u8, 0x7eu8, 0x59u8, 0x79u8, 0x15u8, 0xddu8, + 0xccu8, 0x4bu8, 0x3du8, 0x93u8, 0x32u8, 0x84u8, 0xcdu8, 0x70u8]) } @@ -348,45 +348,45 @@ def natPrim := ⟦ -- BitVec primitives () fn bit_vec_to_nat_addr() -> Addr { - store([0xc1u8, 0x10u8, 0xd6u8, 0x14u8, 0xb4u8, 0x41u8, 0xc6u8, 0xccu8, - 0xa6u8, 0x9eu8, 0xcdu8, 0x7cu8, 0x1cu8, 0x2cu8, 0x76u8, 0xf3u8, - 0xbcu8, 0x21u8, 0xfdu8, 0x40u8, 0xc4u8, 0x00u8, 0x1eu8, 0x6au8, - 0x1au8, 0x7du8, 0x1cu8, 0xf4u8, 0x81u8, 0xe2u8, 0x3cu8, 0xddu8]) + store([0xfau8, 0xdeu8, 0x2du8, 0xbfu8, 0xb1u8, 0xd7u8, 0xf7u8, 0x7cu8, + 0x30u8, 0xc2u8, 0x47u8, 0xd5u8, 0x2du8, 0xf1u8, 0x28u8, 0xbfu8, + 0x51u8, 0x6eu8, 0xedu8, 0xceu8, 0x01u8, 0xf8u8, 0x17u8, 0xd3u8, + 0x63u8, 0xceu8, 0x88u8, 0xdau8, 0x13u8, 0xcfu8, 0xacu8, 0x2bu8]) } fn bit_vec_of_nat_addr() -> Addr { - store([0x29u8, 0xb9u8, 0xf2u8, 0x40u8, 0x86u8, 0xb1u8, 0xb1u8, 0xf8u8, - 0x82u8, 0x11u8, 0x35u8, 0x88u8, 0x66u8, 0x13u8, 0x9fu8, 0xdbu8, - 0x7du8, 0xcdu8, 0xfcu8, 0x97u8, 0xb5u8, 0xf6u8, 0xc7u8, 0x7fu8, - 0xc4u8, 0x95u8, 0xbfu8, 0x8cu8, 0x77u8, 0x63u8, 0x99u8, 0x82u8]) + store([0x67u8, 0x16u8, 0x0bu8, 0x97u8, 0x67u8, 0x93u8, 0x06u8, 0xd2u8, + 0x82u8, 0x04u8, 0x45u8, 0x38u8, 0x3au8, 0x6du8, 0x74u8, 0x0eu8, + 0x6fu8, 0xe9u8, 0x83u8, 0x9cu8, 0x25u8, 0x45u8, 0xeau8, 0x48u8, + 0x68u8, 0x0fu8, 0xf2u8, 0xa7u8, 0x7bu8, 0x0bu8, 0xe9u8, 0x86u8]) } fn bit_vec_addr() -> Addr { - store([0x7fu8, 0x0fu8, 0x5fu8, 0xedu8, 0xa1u8, 0x82u8, 0x80u8, 0x72u8, - 0x12u8, 0x3fu8, 0x24u8, 0x2au8, 0x46u8, 0xa4u8, 0x05u8, 0x49u8, - 0xe8u8, 0x59u8, 0x34u8, 0xf7u8, 0x39u8, 0x5eu8, 0x4fu8, 0x93u8, - 0xf6u8, 0x5du8, 0xdau8, 0x4eu8, 0x48u8, 0x09u8, 0xf3u8, 0x25u8]) + store([0x90u8, 0x02u8, 0x2au8, 0xe4u8, 0xc5u8, 0xd5u8, 0x2au8, 0xd2u8, + 0x8au8, 0xcdu8, 0x80u8, 0x05u8, 0x1du8, 0xd4u8, 0x1fu8, 0x27u8, + 0xf5u8, 0x1cu8, 0x9cu8, 0x4au8, 0xfbu8, 0xabu8, 0x1bu8, 0xb3u8, + 0x91u8, 0x77u8, 0x3cu8, 0x19u8, 0xefu8, 0x0du8, 0xc1u8, 0xe9u8]) } fn bit_vec_ult_addr() -> Addr { - store([0x93u8, 0x01u8, 0xd8u8, 0x50u8, 0xbdu8, 0xe2u8, 0x46u8, 0x94u8, - 0x0bu8, 0x7bu8, 0x3eu8, 0x81u8, 0xe7u8, 0x86u8, 0xf7u8, 0xf1u8, - 0x2bu8, 0xaeu8, 0x8eu8, 0x5cu8, 0xeau8, 0x6bu8, 0x3fu8, 0x40u8, - 0x40u8, 0x06u8, 0x0bu8, 0x3au8, 0x7fu8, 0x59u8, 0x55u8, 0x7cu8]) + store([0x2fu8, 0x9cu8, 0x9cu8, 0x36u8, 0x90u8, 0x45u8, 0x03u8, 0x6du8, + 0x9au8, 0x35u8, 0xffu8, 0x7bu8, 0x38u8, 0x28u8, 0x5du8, 0xcau8, + 0x3bu8, 0x97u8, 0x64u8, 0x26u8, 0xc8u8, 0x1au8, 0x8fu8, 0x36u8, + 0x6fu8, 0xceu8, 0x11u8, 0x61u8, 0xb0u8, 0x90u8, 0xd6u8, 0x0du8]) } fn decidable_decide_addr() -> Addr { - store([0x20u8, 0xe8u8, 0x90u8, 0x62u8, 0x80u8, 0xb4u8, 0xdcu8, 0xd7u8, - 0x4au8, 0x7au8, 0x78u8, 0xe0u8, 0x6du8, 0x58u8, 0x0eu8, 0x6fu8, - 0x00u8, 0xeeu8, 0xbbu8, 0xa9u8, 0xfcu8, 0x40u8, 0x78u8, 0x92u8, - 0x62u8, 0xe9u8, 0x5cu8, 0xacu8, 0xb6u8, 0xf0u8, 0xd6u8, 0x99u8]) + store([0x11u8, 0x15u8, 0x7bu8, 0xc3u8, 0x89u8, 0x8fu8, 0x06u8, 0xe3u8, + 0xe6u8, 0xf2u8, 0xcau8, 0x83u8, 0x41u8, 0x1eu8, 0xfdu8, 0x0du8, + 0x43u8, 0xb8u8, 0x84u8, 0x6bu8, 0x57u8, 0xd2u8, 0xf6u8, 0x08u8, + 0x8eu8, 0x18u8, 0xf3u8, 0x44u8, 0x7du8, 0xdcu8, 0x3bu8, 0x28u8]) } fn lt_lt_addr() -> Addr { - store([0x48u8, 0x02u8, 0xb1u8, 0x83u8, 0xf4u8, 0xd6u8, 0xdcu8, 0xccu8, - 0xacu8, 0xbau8, 0x57u8, 0x72u8, 0x18u8, 0x24u8, 0xa7u8, 0xbbu8, - 0x67u8, 0xdau8, 0xebu8, 0x27u8, 0x25u8, 0xdau8, 0x17u8, 0x23u8, - 0x92u8, 0x71u8, 0xc1u8, 0x35u8, 0x95u8, 0x2cu8, 0xaau8, 0x61u8]) + store([0x06u8, 0x1cu8, 0x26u8, 0x58u8, 0xc7u8, 0x6au8, 0x68u8, 0xd9u8, + 0x09u8, 0x78u8, 0x85u8, 0x98u8, 0x24u8, 0x99u8, 0x3bu8, 0xbbu8, + 0xe1u8, 0x5du8, 0xbfu8, 0x9bu8, 0x99u8, 0x68u8, 0x61u8, 0x93u8, + 0x25u8, 0x42u8, 0x0eu8, 0x7cu8, 0x83u8, 0x9bu8, 0x05u8, 0xc7u8]) } fn is_bitvec_prim_addr(a: Addr) -> G { @@ -592,10 +592,10 @@ def natPrim := ⟦ -- String primitives () fn string_utf8_byte_size_addr() -> Addr { - store([0x52u8, 0xb0u8, 0x22u8, 0x6eu8, 0xa1u8, 0x4cu8, 0x94u8, 0xb1u8, - 0xf9u8, 0x33u8, 0x4cu8, 0x99u8, 0x57u8, 0xf5u8, 0x58u8, 0x93u8, - 0x99u8, 0xa8u8, 0x6bu8, 0xcdu8, 0xaeu8, 0x11u8, 0x1fu8, 0x28u8, - 0x47u8, 0xc9u8, 0xb0u8, 0xc2u8, 0xfbu8, 0x0au8, 0x22u8, 0x61u8]) + store([0x4cu8, 0x08u8, 0x68u8, 0x26u8, 0xccu8, 0x67u8, 0x9du8, 0xf3u8, + 0xb6u8, 0xaau8, 0x57u8, 0xa2u8, 0x9fu8, 0x3du8, 0x09u8, 0x3au8, + 0x8au8, 0x92u8, 0xd0u8, 0xdeu8, 0x4eu8, 0xdeu8, 0xceu8, 0xf4u8, + 0x6au8, 0x90u8, 0x8du8, 0x83u8, 0x98u8, 0x73u8, 0x3du8, 0xc0u8]) } -- Native string-value fast paths (mirror crates/kernel/src/primitive.rs @@ -603,24 +603,24 @@ def natPrim := ⟦ -- decidable equality reduce natively in whnf, keeping evaluator-grade -- string values out of the structural ByteArray/UTF-8 model. fn string_append_addr() -> Addr { - store([0x13u8, 0x2fu8, 0x11u8, 0x75u8, 0xccu8, 0x3cu8, 0xacu8, 0x5au8, - 0x3eu8, 0x3du8, 0x74u8, 0xe8u8, 0x79u8, 0x7fu8, 0x9bu8, 0xa6u8, - 0x7fu8, 0x2eu8, 0x46u8, 0x7bu8, 0x80u8, 0x04u8, 0xa3u8, 0xf2u8, - 0x8bu8, 0xb5u8, 0xdfu8, 0xd1u8, 0x6au8, 0x36u8, 0x47u8, 0xb1u8]) + store([0x0eu8, 0xaeu8, 0x69u8, 0xf3u8, 0xf8u8, 0xb1u8, 0x98u8, 0xd1u8, + 0xffu8, 0xacu8, 0x67u8, 0xb9u8, 0xe8u8, 0x8du8, 0x39u8, 0x52u8, + 0x6bu8, 0x1bu8, 0x03u8, 0x9fu8, 0xf5u8, 0x19u8, 0xcdu8, 0x87u8, + 0xeeu8, 0xc1u8, 0x06u8, 0xf6u8, 0x39u8, 0x74u8, 0x86u8, 0x0cu8]) } fn string_of_list_addr() -> Addr { - store([0x27u8, 0x2eu8, 0xa5u8, 0xceu8, 0x6bu8, 0xabu8, 0x89u8, 0x58u8, - 0x16u8, 0x5cu8, 0x7fu8, 0x56u8, 0xd7u8, 0x1fu8, 0xfeu8, 0x2au8, - 0x5bu8, 0x17u8, 0x5eu8, 0xd5u8, 0x81u8, 0x10u8, 0x12u8, 0x6du8, - 0xfau8, 0x96u8, 0xe1u8, 0xf8u8, 0xa0u8, 0xc9u8, 0x9au8, 0xd2u8]) + store([0x45u8, 0xdcu8, 0xb3u8, 0xc5u8, 0xe5u8, 0xadu8, 0xa3u8, 0xbcu8, + 0x0cu8, 0xa5u8, 0x2du8, 0x62u8, 0xa6u8, 0x6fu8, 0x7fu8, 0x9du8, + 0xdau8, 0x35u8, 0x07u8, 0xdfu8, 0x71u8, 0x06u8, 0x1au8, 0x5cu8, + 0x20u8, 0x0au8, 0xdeu8, 0xa0u8, 0xcfu8, 0x24u8, 0x10u8, 0x14u8]) } fn char_of_nat_addr() -> Addr { - store([0xcau8, 0xf5u8, 0x1bu8, 0x03u8, 0x9du8, 0x71u8, 0xcfu8, 0xceu8, - 0x70u8, 0x63u8, 0xe1u8, 0x06u8, 0x06u8, 0x4fu8, 0x94u8, 0x35u8, - 0xf5u8, 0x33u8, 0x7bu8, 0xbcu8, 0x42u8, 0x56u8, 0x7cu8, 0x8cu8, - 0x78u8, 0xb5u8, 0xf6u8, 0x6cu8, 0x7fu8, 0x08u8, 0x79u8, 0x20u8]) + store([0xcfu8, 0xf8u8, 0x75u8, 0x91u8, 0x4fu8, 0x3fu8, 0x8bu8, 0x4fu8, + 0x00u8, 0x14u8, 0xd1u8, 0xeau8, 0xa2u8, 0x23u8, 0xc6u8, 0xb9u8, + 0xdau8, 0x72u8, 0x01u8, 0x23u8, 0x9bu8, 0xc5u8, 0x97u8, 0x6eu8, + 0x14u8, 0x0bu8, 0x69u8, 0xd9u8, 0x9cu8, 0xd1u8, 0xf3u8, 0x57u8]) } fn list_nil_addr() -> Addr { @@ -638,52 +638,52 @@ def natPrim := ⟦ } fn char_type_addr() -> Addr { - store([0x4cu8, 0x59u8, 0xbcu8, 0x4eu8, 0xacu8, 0x82u8, 0xd3u8, 0x1eu8, - 0xbeu8, 0xd5u8, 0x9bu8, 0xb2u8, 0x06u8, 0x90u8, 0x9du8, 0xbdu8, - 0xedu8, 0x65u8, 0xb9u8, 0x2fu8, 0xd5u8, 0x6du8, 0xe2u8, 0x51u8, - 0x8fu8, 0xcdu8, 0xadu8, 0xb0u8, 0xa4u8, 0x2cu8, 0x11u8, 0xa0u8]) + store([0x06u8, 0x5fu8, 0xc8u8, 0xb4u8, 0x13u8, 0x93u8, 0xf5u8, 0x25u8, + 0xc1u8, 0xe5u8, 0x41u8, 0xb9u8, 0xd4u8, 0xbcu8, 0x97u8, 0xc2u8, + 0x0cu8, 0x13u8, 0xbfu8, 0x23u8, 0xa7u8, 0x20u8, 0x9au8, 0x20u8, + 0x93u8, 0xb6u8, 0xf4u8, 0x52u8, 0x73u8, 0x30u8, 0x11u8, 0x4au8]) } fn string_back_addr() -> Addr { - store([0x32u8, 0x10u8, 0x4bu8, 0x03u8, 0x34u8, 0x8du8, 0x11u8, 0xacu8, - 0xb2u8, 0x43u8, 0x7fu8, 0xdau8, 0x24u8, 0x96u8, 0x6du8, 0xc5u8, - 0x8cu8, 0xc8u8, 0xc8u8, 0xbcu8, 0xcau8, 0x96u8, 0x58u8, 0x26u8, - 0x14u8, 0xe6u8, 0x44u8, 0xd3u8, 0x19u8, 0xa4u8, 0x2cu8, 0x62u8]) + store([0xb0u8, 0x52u8, 0xe8u8, 0x14u8, 0x12u8, 0x0eu8, 0xa6u8, 0x29u8, + 0x9au8, 0xecu8, 0xf4u8, 0xe9u8, 0xbbu8, 0x2bu8, 0x65u8, 0x6du8, + 0x67u8, 0xc1u8, 0xf9u8, 0x53u8, 0x7eu8, 0x8fu8, 0x0eu8, 0x9fu8, + 0x16u8, 0x47u8, 0x9cu8, 0x98u8, 0xa0u8, 0x4fu8, 0xdeu8, 0x93u8]) } fn string_legacy_back_addr() -> Addr { - store([0x37u8, 0xefu8, 0x5fu8, 0xeeu8, 0x76u8, 0x5du8, 0xc2u8, 0xe5u8, - 0xc7u8, 0x42u8, 0x5cu8, 0x18u8, 0x0cu8, 0xd4u8, 0x20u8, 0x07u8, - 0xdbu8, 0x7du8, 0x29u8, 0xaeu8, 0x0du8, 0x5cu8, 0x09u8, 0x17u8, - 0x89u8, 0xf4u8, 0x62u8, 0xf2u8, 0x80u8, 0x5bu8, 0x0eu8, 0x09u8]) + store([0x10u8, 0xafu8, 0x1du8, 0xecu8, 0xd5u8, 0xd2u8, 0xcdu8, 0x08u8, + 0x5au8, 0xdfu8, 0xf8u8, 0xaeu8, 0x7fu8, 0xb4u8, 0x4cu8, 0xfcu8, + 0x5du8, 0x22u8, 0xa8u8, 0x9bu8, 0xbcu8, 0x40u8, 0xb8u8, 0x1bu8, + 0x80u8, 0x9du8, 0x3du8, 0x55u8, 0x6fu8, 0xdau8, 0x3eu8, 0x8fu8]) } fn string_to_byte_array_addr() -> Addr { - store([0x79u8, 0x86u8, 0x2au8, 0xcfu8, 0xbcu8, 0x2eu8, 0x37u8, 0xb7u8, - 0xb6u8, 0x12u8, 0x21u8, 0x43u8, 0xf0u8, 0xa6u8, 0xa5u8, 0x11u8, - 0x14u8, 0xc3u8, 0x4fu8, 0xa4u8, 0x83u8, 0xffu8, 0x14u8, 0x14u8, - 0x64u8, 0x83u8, 0xdeu8, 0x18u8, 0x83u8, 0x5du8, 0x42u8, 0x09u8]) + store([0xdeu8, 0x01u8, 0x30u8, 0x24u8, 0xc5u8, 0x98u8, 0xe5u8, 0xf0u8, + 0xc3u8, 0xdcu8, 0xd0u8, 0x67u8, 0xf5u8, 0x06u8, 0xe1u8, 0xd2u8, + 0xe3u8, 0x27u8, 0x49u8, 0x57u8, 0x35u8, 0x22u8, 0xacu8, 0xb5u8, + 0x39u8, 0xb6u8, 0x14u8, 0x00u8, 0x62u8, 0x7cu8, 0xf8u8, 0x97u8]) } fn byte_array_empty_addr() -> Addr { - store([0xbfu8, 0x58u8, 0xe6u8, 0xcbu8, 0x3au8, 0xa0u8, 0xf7u8, 0x46u8, - 0x85u8, 0x06u8, 0x29u8, 0x04u8, 0x16u8, 0x35u8, 0xcdu8, 0x30u8, - 0xc0u8, 0xadu8, 0x66u8, 0x26u8, 0x2bu8, 0x66u8, 0x17u8, 0x66u8, - 0x0fu8, 0x22u8, 0x90u8, 0x24u8, 0x1fu8, 0x08u8, 0xb0u8, 0x8bu8]) + store([0x4du8, 0xa6u8, 0x61u8, 0x91u8, 0x7au8, 0x58u8, 0x15u8, 0x2fu8, + 0x5cu8, 0xa9u8, 0x74u8, 0xd2u8, 0x25u8, 0x6du8, 0x98u8, 0xefu8, + 0xa9u8, 0xd7u8, 0x22u8, 0xc4u8, 0xf1u8, 0x63u8, 0x82u8, 0xe9u8, + 0xcdu8, 0xf0u8, 0x16u8, 0xdfu8, 0x4cu8, 0x57u8, 0x43u8, 0x68u8]) } fn string_dec_eq_addr() -> Addr { - store([0x19u8, 0x13u8, 0x4fu8, 0xdcu8, 0x18u8, 0x8eu8, 0x83u8, 0x77u8, - 0xd0u8, 0x17u8, 0x38u8, 0x57u8, 0xe1u8, 0x5du8, 0x3bu8, 0x50u8, - 0x65u8, 0xedu8, 0x76u8, 0xdau8, 0x98u8, 0x13u8, 0x97u8, 0x10u8, - 0x7eu8, 0x5cu8, 0x40u8, 0x4du8, 0xb3u8, 0xf3u8, 0xb7u8, 0x18u8]) + store([0xdau8, 0x7bu8, 0xb3u8, 0x31u8, 0xe0u8, 0x98u8, 0xf9u8, 0xbfu8, + 0x5cu8, 0xdau8, 0xbcu8, 0xb9u8, 0x60u8, 0x9au8, 0x7eu8, 0x95u8, + 0x3du8, 0xffu8, 0xc6u8, 0x09u8, 0xadu8, 0x9du8, 0x90u8, 0x87u8, + 0x1au8, 0x14u8, 0xc0u8, 0x16u8, 0xc5u8, 0x2au8, 0x30u8, 0x11u8]) } fn string_type_addr() -> Addr { - store([0x9du8, 0x6au8, 0xe4u8, 0x34u8, 0x29u8, 0xecu8, 0x02u8, 0xa9u8, - 0x33u8, 0x8bu8, 0xbcu8, 0xd0u8, 0xdbu8, 0x0au8, 0xc1u8, 0x93u8, - 0xd7u8, 0x5eu8, 0xbdu8, 0x46u8, 0xf8u8, 0x84u8, 0xbfu8, 0xcbu8, - 0xd2u8, 0xc4u8, 0x2bu8, 0xf7u8, 0xfau8, 0xeau8, 0x15u8, 0x0du8]) + store([0x22u8, 0x16u8, 0x25u8, 0xa0u8, 0x0eu8, 0xe2u8, 0xd6u8, 0xb9u8, + 0x62u8, 0x97u8, 0xe3u8, 0x4du8, 0x7eu8, 0x05u8, 0xbfu8, 0x7eu8, + 0x4fu8, 0xd3u8, 0x8du8, 0x8du8, 0x99u8, 0xd3u8, 0xe1u8, 0xd6u8, + 0x4au8, 0x7cu8, 0xd2u8, 0xe0u8, 0x6cu8, 0xa0u8, 0x75u8, 0x2du8]) } -- Address is a string primitive. diff --git a/Ix/IxVM/Kernel/Whnf.lean b/Ix/IxVM/Kernel/Whnf.lean index c22b4c9f1..79d7ffa7a 100644 --- a/Ix/IxVM/Kernel/Whnf.lean +++ b/Ix/IxVM/Kernel/Whnf.lean @@ -128,17 +128,17 @@ def whnf := ⟦ } fn fin_addr() -> Addr { - store([0x3du8, 0x79u8, 0x79u8, 0x7bu8, 0xc5u8, 0x72u8, 0xd8u8, 0xf3u8, - 0x3eu8, 0xb7u8, 0xcfu8, 0xf5u8, 0xaau8, 0x13u8, 0xf8u8, 0xdcu8, - 0x73u8, 0xbcu8, 0xf2u8, 0x10u8, 0x26u8, 0xbfu8, 0x05u8, 0xd0u8, - 0x38u8, 0x88u8, 0xc9u8, 0xaau8, 0x03u8, 0x69u8, 0xdcu8, 0xefu8]) + store([0x1eu8, 0x1au8, 0x2bu8, 0xbbu8, 0x19u8, 0x20u8, 0xedu8, 0x4au8, + 0x12u8, 0x81u8, 0xa3u8, 0xdeu8, 0xcau8, 0x64u8, 0x6au8, 0xd3u8, + 0x13u8, 0xcau8, 0x9cu8, 0x7bu8, 0xf7u8, 0xeau8, 0xbdu8, 0xc3u8, + 0x65u8, 0x59u8, 0x87u8, 0x79u8, 0x7cu8, 0xccu8, 0x0cu8, 0x55u8]) } fn decidable_rec_addr() -> Addr { - store([0x16u8, 0xcfu8, 0xddu8, 0xdau8, 0x9cu8, 0x27u8, 0x46u8, 0x60u8, - 0xf3u8, 0x91u8, 0xb1u8, 0x0eu8, 0xefu8, 0xe0u8, 0x66u8, 0x27u8, - 0x5au8, 0xffu8, 0xfau8, 0xe1u8, 0xccu8, 0xd4u8, 0x9cu8, 0x6du8, - 0xafu8, 0x43u8, 0xafu8, 0xb8u8, 0xa8u8, 0x0au8, 0xeau8, 0x85u8]) + store([0x3eu8, 0xa7u8, 0xe1u8, 0x8fu8, 0xcbu8, 0xb7u8, 0xc4u8, 0x98u8, + 0xb2u8, 0xa4u8, 0x52u8, 0x37u8, 0xbdu8, 0xa6u8, 0x59u8, 0xc0u8, + 0xedu8, 0xc9u8, 0x7bu8, 0x3du8, 0x54u8, 0xa4u8, 0xadu8, 0x0du8, + 0x11u8, 0xbcu8, 0x2eu8, 0xbeu8, 0xc8u8, 0x0cu8, 0xfau8, 0x17u8]) } fn nat_ty_addr() -> Addr { diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean index e4f5f6487..c0e791458 100644 --- a/Ix/Ixon.lean +++ b/Ix/Ixon.lean @@ -3,7 +3,7 @@ This module defines: - Serialize typeclass and primitive serialization - - Tag0/Tag2/Tag4 encoding + - TagN integer encoding (4-, 2- and 0-bit flags) - Expr, Univ, and Constant types matching Rust exactly - All numeric fields use UInt64 (matching Rust's u64) -/ @@ -18,8 +18,9 @@ public section namespace Ixon -/-- Stable identifier for the v2 Ixon wire grammar. -/ -def wireFormatId : String := "ixon-v3" +/-- Stable identifier for the Ixon wire format, version 4 (`Env.VERSION`). +Mirrors Rust `WIRE_FORMAT_ID`. -/ +def wireFormatId : String := "ixon-v4" /-! ## Serialization Monad and Typeclass -/ @@ -136,18 +137,6 @@ instance : Serialize Address where /-! ## Tag Encoding -/ -/-- Count bytes needed to represent a u64 in minimal little-endian form. -/ -def u64ByteCount (x : UInt64) : UInt8 := - if x == 0 then 0 - else if x < 0x100 then 1 - else if x < 0x10000 then 2 - else if x < 0x1000000 then 3 - else if x < 0x100000000 then 4 - else if x < 0x10000000000 then 5 - else if x < 0x1000000000000 then 6 - else if x < 0x100000000000000 then 7 - else 8 - /-- Write the requested low bytes of a `UInt64`, least significant first. -/ def putU64TrimmedLEAux (x : UInt64) : Nat → PutM Unit | 0 => pure () @@ -155,10 +144,6 @@ def putU64TrimmedLEAux (x : UInt64) : Nat → PutM Unit putU8 x.toUInt8 putU64TrimmedLEAux (x >>> 8) len -/-- Write a u64 in minimal little-endian bytes. -/ -def putU64TrimmedLE (x : UInt64) : PutM Unit := - putU64TrimmedLEAux x (u64ByteCount x).toNat - /-- Read exactly `len` little-endian bytes into a `UInt64`. -/ def getU64TrimmedLEAux : Nat → GetM UInt64 | 0 => pure 0 @@ -167,110 +152,130 @@ def getU64TrimmedLEAux : Nat → GetM UInt64 let high ← getU64TrimmedLEAux len return low.toUInt64 ||| (high <<< 8) -/-- Read a u64 from minimal little-endian bytes. - - Widths past 8 are rejected, matching Rust `u64_get_trimmed_le`. - Without the guard the shift below wraps — `UInt64.shiftLeft` is taken - mod 64 — so byte 8 would OR back into bits 0-7 and a `Tag0` whose - payload claims nine bytes would read as a *different value* here than - in the kernel, which discards the surplus. Same bytes, same address, - two constants. -/ -def getU64TrimmedLE (len : Nat) : GetM UInt64 := do - if len > 8 then - throw "getU64TrimmedLE: len > 8" - getU64TrimmedLEAux len - -/-- Tag0: Variable-length encoding for small integers. - Header byte: [large:1][size:7] - - If large=0: size is in low 7 bits (0-127) - - If large=1: (size+1) bytes follow containing actual size -/ -structure Tag0 where - size : UInt64 - deriving BEq, Repr - -def putTag0 (t : Tag0) : PutM Unit := do - if t.size < 128 then - putU8 t.size.toUInt8 - else - let byteCount := u64ByteCount t.size - putU8 (0x80 ||| (byteCount - 1)) - putU64TrimmedLE t.size - -def getTag0 : GetM Tag0 := do - let b ← getU8 - let large := b &&& 0x80 != 0 - let small := b &&& 0x7F - let size ← if large then - getU64TrimmedLE (small.toNat + 1) - else - pure small.toUInt64 - if large && (size < 128 || u64ByteCount size != small + 1) then - throw "noncanonical Tag0 integer" - return ⟨size⟩ - -/-- Tag2: 2-bit flag + size. - Header byte: [flag:2][large:1][size:5] - - If large=0: size is in low 5 bits (0-31) - - If large=1: (size+1) bytes follow containing actual size -/ -structure Tag2 where - flag : UInt8 - size : UInt64 - deriving BEq, Repr - -def putTag2 (t : Tag2) : PutM Unit := do - if t.size < 32 then - putU8 ((t.flag <<< 6) ||| t.size.toUInt8) - else - let byteCount := u64ByteCount t.size - putU8 ((t.flag <<< 6) ||| 0x20 ||| (byteCount - 1)) - putU64TrimmedLE t.size - -def getTag2 : GetM Tag2 := do - let b ← getU8 - let flag := b >>> 6 - let large := b &&& 0x20 != 0 - let small := b &&& 0x1F - let size ← if large then - getU64TrimmedLE (small.toNat + 1) - else - pure small.toUInt64 - if large && (size < 32 || u64ByteCount size != small + 1) then - throw "noncanonical Tag2 integer" - return ⟨flag, size⟩ - -/-- Tag4: 4-bit flag + size. - Header byte: [flag:4][large:1][size:3] - - If large=0: size is in low 3 bits (0-7) - - If large=1: (size+1) bytes follow containing actual size -/ -structure Tag4 where +/-! ### TagN: the Ixon integer code + +Every integer field of the wire format is a TagN integer: `f = 4` for +expression, constant, environment, commitment, claim and proof headers (the +flag selects the variant), `f = 2` for universe terms and `f = 0` (no flag) +for counts, indices and every other unsigned integer. A TagN integer is one +header byte `[flag : f bits][payload : r = 8 − f bits]` (`f ∈ {0, 2, 4}`) +followed by 0, 1, 2, 3, 4 or 8 little-endian bytes. With `L` the top payload +bit and `M` the next one: + +* `L = 0`: the low `r − 1` payload bits are the value (rung 1, `[0, R₁)`, + `R₁ = 2^(r−1)`); +* `L = 1, M = 0`: the low `r − 2` bits followed by one byte hold `value − R₁` + (rung 2, `[R₁, R₂)`, `R₂ = R₁ + 2^(r−2+8)`); +* `L = 1, M = 1`: the low `r − 2` bits are a code `c`; `c = 0, 1, 2, 3` + select 2, 3, 4, 8 following bytes holding `value − R₂`, `value − R₃`, + `value − R₄`, `value − R₅` (rungs `[R₂, R₃)`, `[R₃, R₄)`, `[R₄, R₅)`, + `[R₅, R₆)` with `R₃ = R₂ + 2^16`, `R₄ = R₃ + 2^24`, `R₅ = R₄ + 2^32`, + `R₆ = R₅ + 2^64`); every other code is invalid (none for `f = 4`, whose + code has two bits). + +Each rung starts where the previous one ends, so a value has exactly one +encoding. Rung ends and widths (1, 2, 3, 4, 5, 9 bytes): + +| f | R₁ | R₂ | R₃ | R₄ | R₅ | +|---|---|---|---|---|---| +| 0 | 128 | 16512 | 82048 | 16859264 | 4311826560 | +| 2 | 32 | 4128 | 69664 | 16846880 | 4311814176 | +| 4 | 8 | 1032 | 66568 | 16843784 | 4311811080 | + +The code itself represents `[0, R₆)`. Since `R₅ < 2^33`, `R₆ > 2^64`: every +`UInt64` is representable for each `f`, and the decoder rejects 8-byte +payloads whose value would reach `2^64`. -/ + +/-- End of TagN rung 1 for an `f`-bit flag. -/ +def tagNEnd1 (f : Nat) : Nat := 2 ^ (8 - f - 1) +/-- End of TagN rung 2 (one trailing byte). -/ +def tagNEnd2 (f : Nat) : Nat := tagNEnd1 f + 2 ^ (8 - f - 2 + 8) +/-- End of TagN rung 3 (two trailing bytes). -/ +def tagNEnd3 (f : Nat) : Nat := tagNEnd2 f + 2 ^ 16 +/-- End of TagN rung 4 (three trailing bytes). -/ +def tagNEnd4 (f : Nat) : Nat := tagNEnd3 f + 2 ^ 24 +/-- End of TagN rung 5 (four trailing bytes). -/ +def tagNEnd5 (f : Nat) : Nat := tagNEnd4 f + 2 ^ 32 +/-- End of TagN rung 6 (eight trailing bytes; beyond every `UInt64`). -/ +def tagNEnd6 (f : Nat) : Nat := tagNEnd5 f + 2 ^ 64 + +/-- Byte width of the TagN encoding of `value`: the single width-by-index +function for the TagN code. -/ +def tagNByteWidth (f value : Nat) : Nat := + if value < tagNEnd1 f then 1 + else if value < tagNEnd2 f then 2 + else if value < tagNEnd3 f then 3 + else if value < tagNEnd4 f then 4 + else if value < tagNEnd5 f then 5 + else 9 + +/-- A decoded TagN flag and value. -/ +structure TagN where flag : UInt8 - size : UInt64 - deriving BEq, Repr, Inhabited, Ord, Hashable + value : UInt64 + deriving BEq, Repr, Inhabited -def putTag4 (t : Tag4) : PutM Unit := do - if t.size < 8 then - putU8 ((t.flag <<< 4) ||| t.size.toUInt8) +/-- Header byte: `flag` in the high `f` bits, `payload` in the low `8 − f`. -/ +def tagNHeader (f : Nat) (flag : UInt8) (payload : Nat) : UInt8 := + (flag.toNat * 2 ^ (8 - f) + payload).toUInt8 + +/-- Write `value` in the TagN code with an `f`-bit `flag` (`flag < 2^f`). -/ +def putTagN (f : Nat) (flag : UInt8) (value : UInt64) : PutM Unit := + let v := value.toNat + let lead := 2 ^ (8 - f - 1) + let mbit := 2 ^ (8 - f - 2) + if v < tagNEnd1 f then + putU8 (tagNHeader f flag v) + else if v < tagNEnd2 f then do + putU8 (tagNHeader f flag (lead + (v - tagNEnd1 f) / 256)) + putU8 ((v - tagNEnd1 f) % 256).toUInt8 + else if v < tagNEnd3 f then do + putU8 (tagNHeader f flag (lead + mbit)) + putU64TrimmedLEAux (v - tagNEnd2 f).toUInt64 2 + else if v < tagNEnd4 f then do + putU8 (tagNHeader f flag (lead + mbit + 1)) + putU64TrimmedLEAux (v - tagNEnd3 f).toUInt64 3 + else if v < tagNEnd5 f then do + putU8 (tagNHeader f flag (lead + mbit + 2)) + putU64TrimmedLEAux (v - tagNEnd4 f).toUInt64 4 + else do + putU8 (tagNHeader f flag (lead + mbit + 3)) + putU64TrimmedLEAux (v - tagNEnd5 f).toUInt64 8 + +/-- The multi-byte TagN rungs, selected by the code `c` in the low `8 − f − 2` +header bits. -/ +def getTagNWide (f : Nat) (flag : UInt8) (c : Nat) : GetM TagN := + if c = 0 then do + let x ← getU64TrimmedLEAux 2 + pure ⟨flag, (tagNEnd2 f + x.toNat).toUInt64⟩ + else if c = 1 then do + let x ← getU64TrimmedLEAux 3 + pure ⟨flag, (tagNEnd3 f + x.toNat).toUInt64⟩ + else if c = 2 then do + let x ← getU64TrimmedLEAux 4 + pure ⟨flag, (tagNEnd4 f + x.toNat).toUInt64⟩ + else if c = 3 then do + let x ← getU64TrimmedLEAux 8 + if tagNEnd5 f + x.toNat < 2 ^ 64 then + pure ⟨flag, (tagNEnd5 f + x.toNat).toUInt64⟩ + else + throw "TagN value exceeds UInt64" else - let byteCount := u64ByteCount t.size - putU8 ((t.flag <<< 4) ||| 0x08 ||| (byteCount - 1)) - putU64TrimmedLE t.size + throw s!"invalid TagN code {c}" -def getTag4 : GetM Tag4 := do +/-- Read a TagN integer with an `f`-bit flag. Invalid codes and values +reaching `2^64` are rejected. -/ +def getTagN (f : Nat) : GetM TagN := do let b ← getU8 - let flag := b >>> 4 - let large := b &&& 0x08 != 0 - let small := b &&& 0x07 - let size ← if large then - getU64TrimmedLE (small.toNat + 1) + let flag := (b.toNat / 2 ^ (8 - f)).toUInt8 + let p := b.toNat % 2 ^ (8 - f) + if p < 2 ^ (8 - f - 1) then + pure ⟨flag, p.toUInt64⟩ + else if p - 2 ^ (8 - f - 1) < 2 ^ (8 - f - 2) then do + let lo ← getU8 + pure ⟨flag, (tagNEnd1 f + (p - 2 ^ (8 - f - 1)) * 256 + lo.toNat).toUInt64⟩ else - pure small.toUInt64 - if large && (size < 8 || u64ByteCount size != small + 1) then - throw "noncanonical Tag4 integer" - return ⟨flag, size⟩ - -instance : Serialize Tag4 where - put := putTag4 - get := getTag4 + getTagNWide f flag (p - 2 ^ (8 - f - 1) - 2 ^ (8 - f - 2)) /-! ## Contract serialization -/ @@ -351,10 +356,10 @@ namespace Expr def FLAG_LET : UInt8 := 0xA def FLAG_SHARE : UInt8 := 0xB - /-- Embed an ordinary Lean lambda in Ixon v3. -/ + /-- Embed an ordinary Lean lambda in Ixon. -/ def leanLam (ty body : Expr) : Expr := .lam .many ty body - /-- Embed an ordinary Lean forall in Ixon v3. -/ + /-- Embed an ordinary Lean forall in Ixon. -/ def leanAll (ty body : Expr) : Expr := .all .many .shared ty body /-- Embed an ordinary Lean let with default contracts. -/ @@ -522,7 +527,8 @@ inductive CallSiteEntry where (Rust field name: `meta` — a reserved keyword here). -/ | kept (canonIdx : UInt64) (metaIdx : UInt64) /-- Argument was collapsed. Expression stored in - `ConstantMeta.metaSharing[sharingIdx]`. `metaIdx` is the arena index + `ConstantMeta.metaSharing[sharingIdx]` (a direct index, not offset by + the primary sharing table's length). `metaIdx` is the arena index for this argument's metadata subtree. -/ | collapsed (sharingIdx : UInt64) (metaIdx : UInt64) deriving BEq, Repr, Inhabited @@ -653,15 +659,32 @@ structure UnivPatch where deriving Inhabited, BEq, Repr /-- Per-constant metadata wrapper: variant payload + extension tables. - The extension tables (`metaSharing`/`metaRefs`/`metaUnivs`) form a - virtual address space extending the primary `Constant` tables, used by - `callSite` nodes in the metadata arena for call-site surgery roundtrip - and by `univPatches` for original level spellings (canonicity §10.6). - Mirrors Rust `ixon::metadata::ConstantMeta`. -/ + The extension tables (`metaSharing`/`metaRefs`/`metaUnivs`) extend the + index spaces of the primary `Constant` tables (for a projection, the + tables of its `muts` block), used by `callSite` nodes in the metadata + arena for call-site surgery roundtrip and by `univPatches` for original + level spellings (canonicity §10.6). Mirrors Rust + `ixon::metadata::ConstantMeta`. -/ structure ConstantMeta where info : ConstantMetaInfo := .empty - /-- Compiled Ixon expressions for collapsed call-site arguments. May - contain `Share(idx)` references into the extended sharing table. -/ + /-- Compiled Ixon expressions for collapsed call-site arguments and + rewritten call-site heads, indexed DIRECTLY (no offset) by + `CallSiteEntry.collapsed sharingIdx` and `origHead = some (sharingIdx, _)`. + + Extended index space for `share` (a reader rule; the bytes are + unchanged). Let the primary table `sharing` have `p` entries and this + table `q`. A `share i` occurring inside an expression of + `metaSharing[j]` denotes primary entry `i` when `i < p` (expanded + against the primary table only: shares nested in a primary entry stay + primary) and `metaSharing[i - p]` when `p ≤ i < p + j`. Entry `j` may + reference every primary entry and only the metadata entries before + it; `i ≥ p + q` (out of range) and `p + j ≤ i < p + q` (a forward or + self reference) are reader errors, so expansion is well founded. A + `share` in a primary expression always denotes a primary entry: + metadata never changes how primary bytes decode. Readers: the Lean + and Rust decompilers (`Ix.DecompileM.ShareScope`, Rust + `decompile::ShareScope`); kernel ingress never reads this table. + The compilers emit no `share` here today. -/ metaSharing : Array Expr := #[] /-- Extension refs table (addresses referenced by collapsed arg expressions), serialized as raw 32-byte addresses (not name-indexed). -/ @@ -803,23 +826,23 @@ theorem Univ.succBase_sizeOf_le (u : Univ) : | imax a b => simp [Univ.succBase] | var idx => simp [Univ.succBase] -/-- Total v2 universe writer. Successor telescopes retain the production +/-- Total universe writer. Successor telescopes retain the production compressed representation; `succBase_sizeOf_le` supplies the non-obvious structural decrease. -/ def putUniv : Univ → PutM Unit - | .zero => putTag2 ⟨Univ.FLAG_ZERO_SUCC, 0⟩ + | .zero => putTagN 2 Univ.FLAG_ZERO_SUCC 0 | u@(.succ _) => do - putTag2 ⟨Univ.FLAG_ZERO_SUCC, u.succCount⟩ + putTagN 2 Univ.FLAG_ZERO_SUCC u.succCount putUniv u.succBase | .max a b => do - putTag2 ⟨Univ.FLAG_MAX, 0⟩ + putTagN 2 Univ.FLAG_MAX 0 putUniv a putUniv b | .imax a b => do - putTag2 ⟨Univ.FLAG_IMAX, 0⟩ + putTagN 2 Univ.FLAG_IMAX 0 putUniv a putUniv b - | .var idx => putTag2 ⟨Univ.FLAG_VAR, idx⟩ + | .var idx => putTagN 2 Univ.FLAG_VAR idx termination_by u => sizeOf u decreasing_by all_goals simp_wf @@ -838,14 +861,14 @@ def Univ.addSucc : Nat → Univ → Univ /-- Decode the payload selected by one universe tag, using `recur` for every recursive child. Naming the post-tag continuation keeps its wire grammar directly available to codec proofs. -/ -def getUnivFromTag (recur : GetM Univ) (tag : Tag2) : GetM Univ := do +def getUnivFromTag (recur : GetM Univ) (tag : TagN) : GetM Univ := do match tag.flag with | 0 => -- ZERO_SUCC - if tag.size == 0 then + if tag.value == 0 then return .zero else let base ← recur - return base.addSucc tag.size.toNat + return base.addSucc tag.value.toNat | 1 => -- MAX let a ← recur let b ← recur @@ -855,14 +878,14 @@ def getUnivFromTag (recur : GetM Univ) (tag : Tag2) : GetM Univ := do let b ← recur return .imax a b | 3 => -- VAR - return .var tag.size + return .var tag.value | f => throw s!"getUniv: invalid flag {f}" -/-- Total v2 universe reader. Each recursive layer consumes a tag byte, so +/-- Total universe reader. Each recursive layer consumes a tag byte, so a caller-supplied byte budget is a complete termination measure. -/ def getUnivFuel : Nat → GetM Univ | 0 => throw "getUniv: recursion budget exhausted" - | fuel + 1 => getTag2 >>= getUnivFromTag (getUnivFuel fuel) + | fuel + 1 => getTagN 2 >>= getUnivFromTag (getUnivFuel fuel) /-- Decode one universe from the current cursor. Remaining bytes plus one are sufficient fuel because every recursive layer consumes a tag. -/ @@ -1050,52 +1073,52 @@ private theorem nodeCount_right_lt_sum3 (left middle right : Nat) : Nat.lt_of_le_of_lt (Nat.le_add_left right (left + middle)) (Nat.lt_succ_self _) -/-- Total canonical v3 expression writer. Telescope collection preserves the +/-- Total canonical expression writer. Telescope collection preserves the Rust byte grammar; the node-count lemmas above expose its recursive calls to the kernel termination checker. -/ def putExpr : Expr → PutM Unit - | .sort idx => putTag4 ⟨Expr.FLAG_SORT, idx⟩ - | .var idx => putTag4 ⟨Expr.FLAG_VAR, idx⟩ + | .sort idx => putTagN 4 Expr.FLAG_SORT idx + | .var idx => putTagN 4 Expr.FLAG_VAR idx | .ref refIdx univIdxs => do - -- Rust format: Tag4(flag, array_len), Tag0(ref_idx), then elements - putTag4 ⟨Expr.FLAG_REF, univIdxs.size.toUInt64⟩ - putTag0 ⟨refIdx⟩ - for idx in univIdxs do putTag0 ⟨idx⟩ + -- Rust format: TagN(4, flag, array_len), TagN(0, ref_idx), then elements + putTagN 4 Expr.FLAG_REF univIdxs.size.toUInt64 + putTagN 0 0 refIdx + for idx in univIdxs do putTagN 0 0 idx | .recur recIdx univIdxs => do - -- Rust format: Tag4(flag, array_len), Tag0(rec_idx), then elements - putTag4 ⟨Expr.FLAG_REC, univIdxs.size.toUInt64⟩ - putTag0 ⟨recIdx⟩ - for idx in univIdxs do putTag0 ⟨idx⟩ + -- Rust format: TagN(4, flag, array_len), TagN(0, rec_idx), then elements + putTagN 4 Expr.FLAG_REC univIdxs.size.toUInt64 + putTagN 0 0 recIdx + for idx in univIdxs do putTagN 0 0 idx | .prj typeRefIdx fieldIdx val => do - -- Rust format: Tag4(flag, field_idx), Tag0(type_ref_idx), then val - putTag4 ⟨Expr.FLAG_PRJ, fieldIdx⟩ - putTag0 ⟨typeRefIdx⟩ + -- Rust format: TagN(4, flag, field_idx), TagN(0, type_ref_idx), then val + putTagN 4 Expr.FLAG_PRJ fieldIdx + putTagN 0 0 typeRefIdx putExpr val - | .str refIdx => putTag4 ⟨Expr.FLAG_STR, refIdx⟩ - | .nat refIdx => putTag4 ⟨Expr.FLAG_NAT, refIdx⟩ + | .str refIdx => putTagN 4 Expr.FLAG_STR refIdx + | .nat refIdx => putTagN 4 Expr.FLAG_NAT refIdx | e@(.app _ _) => do - putTag4 ⟨Expr.FLAG_APP, e.collectAppArgs.1.length.toUInt64⟩ + putTagN 4 Expr.FLAG_APP e.collectAppArgs.1.length.toUInt64 putExpr e.collectAppArgs.2 for arg in e.collectAppArgs.1 do putExpr arg | e@(.lam _ _ _) => do - putTag4 ⟨Expr.FLAG_LAM, e.collectLamBinders.1.length.toUInt64⟩ + putTagN 4 Expr.FLAG_LAM e.collectLamBinders.1.length.toUInt64 for binder in e.collectLamBinders.1 do putU8 binder.1.toBits putExpr binder.2 putExpr e.collectLamBinders.2 | e@(.all _ _ _ _) => do - putTag4 ⟨Expr.FLAG_ALL, e.collectAllBinders.1.length.toUInt64⟩ + putTagN 4 Expr.FLAG_ALL e.collectAllBinders.1.length.toUInt64 for binder in e.collectAllBinders.1 do putU8 (packAllContract binder.1 binder.2.1) putExpr binder.2.2 putExpr e.collectAllBinders.2 | .letE contract ty val body => do - putTag4 ⟨Expr.FLAG_LET, contract.flags⟩ + putTagN 4 Expr.FLAG_LET contract.flags putBinderContract contract.binder putExpr ty putExpr val putExpr body - | .share idx => putTag4 ⟨Expr.FLAG_SHARE, idx⟩ + | .share idx => putTagN 4 Expr.FLAG_SHARE idx termination_by e => e.nodeCount decreasing_by all_goals simp_wf @@ -1127,12 +1150,12 @@ decreasing_by simpa only [Expr.nodeCount] using Expr.collectAllBinders_base_nodeCount_lt _ _ _ _ -/-- Read `count` `Tag0` sizes in wire order. -/ -def getTag0Sizes : Nat → GetM (List UInt64) +/-- Read `count` TagN (`f = 0`) values in wire order. -/ +def getTagN0Values : Nat → GetM (List UInt64) | 0 => pure [] | count + 1 => do - let head := (← getTag0).size - let tail ← getTag0Sizes count + let head := (← getTagN 0).value + let tail ← getTagN0Values count return head :: tail /-- Read and apply one canonical application argument at a time. -/ @@ -1163,52 +1186,52 @@ def getExprAllBinders (recur : GetM Expr) : let tail ← getExprAllBinders recur count return (contract, result, ty) :: tail -/-- Parse a v3 expression after its leading `Tag4`. Recursive reads are +/-- Parse an expression after its leading TagN (`f = 4`) header. Recursive reads are supplied explicitly so `getExprFuel` below remains structurally total. -/ -def getExprFromTag (recur : GetM Expr) (tag : Tag4) : GetM Expr := do +def getExprFromTag (recur : GetM Expr) (tag : TagN) : GetM Expr := do match tag.flag with - | 0x0 => return .sort tag.size - | 0x1 => return .var tag.size - | 0x2 => do -- REF: tag.size is array_len, then ref_idx, then elements - let refIdx := (← getTag0).size - checkCount tag.size - let univIdxs ← getTag0Sizes tag.size.toNat + | 0x0 => return .sort tag.value + | 0x1 => return .var tag.value + | 0x2 => do -- REF: tag.value is array_len, then ref_idx, then elements + let refIdx := (← getTagN 0).value + checkCount tag.value + let univIdxs ← getTagN0Values tag.value.toNat return .ref refIdx univIdxs.toArray - | 0x3 => do -- REC: tag.size is array_len, then rec_idx, then elements - let recIdx := (← getTag0).size - checkCount tag.size - let univIdxs ← getTag0Sizes tag.size.toNat + | 0x3 => do -- REC: tag.value is array_len, then rec_idx, then elements + let recIdx := (← getTagN 0).value + checkCount tag.value + let univIdxs ← getTagN0Values tag.value.toNat return .recur recIdx univIdxs.toArray - | 0x4 => do -- PRJ: tag.size is field_idx, then type_ref_idx, then val - let typeRefIdx := (← getTag0).size + | 0x4 => do -- PRJ: tag.value is field_idx, then type_ref_idx, then val + let typeRefIdx := (← getTagN 0).value let val ← recur - return .prj typeRefIdx tag.size val - | 0x5 => return .str tag.size - | 0x6 => return .nat tag.size + return .prj typeRefIdx tag.value val + | 0x5 => return .str tag.value + | 0x6 => return .nat tag.value | 0x7 => do -- APP (telescope) - if tag.size == 0 then + if tag.value == 0 then throw "getExpr: empty app spine" - checkCount tag.size + checkCount tag.value let base ← recur match base with | .app .. => throw "getExpr: non-canonical app base" | _ => pure () - getExprAppArgs recur tag.size.toNat base + getExprAppArgs recur tag.value.toNat base | 0x8 => do -- LAM (telescope) - if tag.size == 0 then + if tag.value == 0 then throw "getExpr: Lam with zero binders" - checkCount tag.size 2 - let binders ← getExprLamBinders recur tag.size.toNat + checkCount tag.value 2 + let binders ← getExprLamBinders recur tag.value.toNat let body ← recur match body with | .lam .. => throw "getExpr: non-canonical lam telescope" | _ => pure () return binders.foldr (fun (uses, ty) result => .lam uses ty result) body | 0x9 => do -- ALL (telescope) - if tag.size == 0 then + if tag.value == 0 then throw "getExpr: All with zero binders" - checkCount tag.size 2 - let binders ← getExprAllBinders recur tag.size.toNat + checkCount tag.value 2 + let binders ← getExprAllBinders recur tag.value.toNat let body ← recur match body with | .all .. => throw "getExpr: non-canonical all telescope" @@ -1216,24 +1239,24 @@ def getExprFromTag (recur : GetM Expr) (tag : Tag4) : GetM Expr := do return binders.foldr (fun (uses, owned, ty) result => .all uses owned ty result) body | 0xA => do -- LET - if tag.size > 3 then - throw s!"getExpr: invalid let flags {tag.size}" + if tag.value > 3 then + throw s!"getExpr: invalid let flags {tag.value}" let binder ← getBinderContract - let some contract := LetContract.ofFlags? tag.size binder + let some contract := LetContract.ofFlags? tag.value binder | throw "getExpr: invalid let flags" let ty ← recur let val ← recur let body ← recur return .letE contract ty val body - | 0xB => return .share tag.size + | 0xB => return .share tag.value | f => throw s!"getExpr: invalid flag {f}" -/-- Total v3 expression reader. Every recursive layer consumes a `Tag4` +/-- Total expression reader. Every recursive layer consumes a TagN (`f = 4`) header header, so a caller-supplied byte budget is a complete termination measure even for telescope-compressed applications and binders. -/ def getExprFuel : Nat → GetM Expr | 0 => throw "getExpr: recursion budget exhausted" - | fuel + 1 => getTag4 >>= getExprFromTag (getExprFuel fuel) + | fuel + 1 => getTagN 4 >>= getExprFromTag (getExprFuel fuel) /-- Decode one expression from the current cursor. Remaining bytes plus one are sufficient fuel because every recursive expression consumes a tag. -/ @@ -1266,7 +1289,7 @@ def unpackDefKindSafety (b : UInt8) : DefKind × DefinitionSafety := def putDefinition (d : Definition) : PutM Unit := do putU8 (packDefKindSafety d.kind d.safety) - putTag0 ⟨d.lvls⟩ + putTagN 0 0 d.lvls putExpr d.typ putExpr d.value @@ -1275,7 +1298,7 @@ def getDefinition : GetM Definition := do if flags >>> 2 > 2 || (flags &&& 3) > 2 then throw "invalid definition kind/safety" let (kind, safety) := unpackDefKindSafety flags - let lvls := (← getTag0).size + let lvls := (← getTagN 0).value let typ ← getExpr let value ← getExpr return ⟨kind, safety, lvls, typ, value⟩ @@ -1285,11 +1308,11 @@ instance : Serialize Definition where get := getDefinition def putRecursorRule (r : RecursorRule) : PutM Unit := do - putTag0 ⟨r.fields⟩ + putTagN 0 0 r.fields putExpr r.rhs def getRecursorRule : GetM RecursorRule := do - let fields := (← getTag0).size + let fields := (← getTagN 0).value let rhs ← getExpr return ⟨fields, rhs⟩ @@ -1299,13 +1322,13 @@ instance : Serialize RecursorRule where def putRecursor (r : Recursor) : PutM Unit := do putU8 (packBools [r.k, r.isUnsafe]) - putTag0 ⟨r.lvls⟩ - putTag0 ⟨r.params⟩ - putTag0 ⟨r.indices⟩ - putTag0 ⟨r.motives⟩ - putTag0 ⟨r.minors⟩ + putTagN 0 0 r.lvls + putTagN 0 0 r.params + putTagN 0 0 r.indices + putTagN 0 0 r.motives + putTagN 0 0 r.minors putExpr r.typ - putTag0 ⟨r.rules.size.toUInt64⟩ + putTagN 0 0 r.rules.size.toUInt64 for rule in r.rules do putRecursorRule rule def getRecursor : GetM Recursor := do @@ -1314,13 +1337,13 @@ def getRecursor : GetM Recursor := do let bools := unpackBools 2 flags let k := bools[0]! let isUnsafe := bools[1]! - let lvls := (← getTag0).size - let params := (← getTag0).size - let indices := (← getTag0).size - let motives := (← getTag0).size - let minors := (← getTag0).size + let lvls := (← getTagN 0).value + let params := (← getTagN 0).value + let indices := (← getTagN 0).value + let motives := (← getTagN 0).value + let minors := (← getTagN 0).value let typ ← getExpr - let numRules := (← getTag0).size.toNat + let numRules := (← getTagN 0).value.toNat checkCount numRules.toUInt64 2 let mut rules := #[] for _ in [0:numRules] do @@ -1333,12 +1356,12 @@ instance : Serialize Recursor where def putAxiom (a : Axiom) : PutM Unit := do putU8 (if a.isUnsafe then 1 else 0) - putTag0 ⟨a.lvls⟩ + putTagN 0 0 a.lvls putExpr a.typ def getAxiom : GetM Axiom := do let isUnsafe ← Serialize.get - let lvls := (← getTag0).size + let lvls := (← getTagN 0).value let typ ← getExpr return ⟨isUnsafe, lvls, typ⟩ @@ -1349,7 +1372,7 @@ instance : Serialize Axiom where def putQuotient (q : Quotient) : PutM Unit := do let k : UInt8 := match q.kind with | .type => 0 | .ctor => 1 | .lift => 2 | .ind => 3 putU8 k - putTag0 ⟨q.lvls⟩ + putTagN 0 0 q.lvls putExpr q.typ def getQuotient : GetM Quotient := do @@ -1357,7 +1380,7 @@ def getQuotient : GetM Quotient := do let k : QuotKind ← match v with | 0 => pure .type | 1 => pure .ctor | 2 => pure .lift | 3 => pure .ind | _ => throw s!"invalid QuotKind tag {v}" - let lvls := (← getTag0).size + let lvls := (← getTagN 0).value let typ ← getExpr return ⟨k, lvls, typ⟩ @@ -1367,18 +1390,18 @@ instance : Serialize Quotient where def putConstructor (c : Constructor) : PutM Unit := do putU8 (if c.isUnsafe then 1 else 0) - putTag0 ⟨c.lvls⟩ - putTag0 ⟨c.cidx⟩ - putTag0 ⟨c.params⟩ - putTag0 ⟨c.fields⟩ + putTagN 0 0 c.lvls + putTagN 0 0 c.cidx + putTagN 0 0 c.params + putTagN 0 0 c.fields putExpr c.typ def getConstructor : GetM Constructor := do let isUnsafe ← Serialize.get - let lvls := (← getTag0).size - let cidx := (← getTag0).size - let params := (← getTag0).size - let fields := (← getTag0).size + let lvls := (← getTagN 0).value + let cidx := (← getTagN 0).value + let params := (← getTagN 0).value + let fields := (← getTagN 0).value let typ ← getExpr return ⟨isUnsafe, lvls, cidx, params, fields, typ⟩ @@ -1388,20 +1411,20 @@ instance : Serialize Constructor where def putInductive (i : Inductive) : PutM Unit := do putU8 (packBools [i.isUnsafe]) - putTag0 ⟨i.lvls⟩ - putTag0 ⟨i.params⟩ - putTag0 ⟨i.indices⟩ + putTagN 0 0 i.lvls + putTagN 0 0 i.params + putTagN 0 0 i.indices putExpr i.typ - putTag0 ⟨i.ctors.size.toUInt64⟩ + putTagN 0 0 i.ctors.size.toUInt64 for c in i.ctors do putConstructor c def getInductive : GetM Inductive := do let isUnsafe ← Serialize.get - let lvls := (← getTag0).size - let params := (← getTag0).size - let indices := (← getTag0).size + let lvls := (← getTagN 0).value + let params := (← getTagN 0).value + let indices := (← getTagN 0).value let typ ← getExpr - let numCtors := (← getTag0).size.toNat + let numCtors := (← getTagN 0).value.toNat checkCount numCtors.toUInt64 6 let mut ctors := #[] for _ in [0:numCtors] do @@ -1413,11 +1436,11 @@ instance : Serialize Inductive where get := getInductive def putInductiveProj (p : InductiveProj) : PutM Unit := do - putTag0 ⟨p.idx⟩ + putTagN 0 0 p.idx Serialize.put p.block def getInductiveProj : GetM InductiveProj := do - let idx := (← getTag0).size + let idx := (← getTagN 0).value let block ← Serialize.get return ⟨idx, block⟩ @@ -1426,13 +1449,13 @@ instance : Serialize InductiveProj where get := getInductiveProj def putConstructorProj (p : ConstructorProj) : PutM Unit := do - putTag0 ⟨p.idx⟩ - putTag0 ⟨p.cidx⟩ + putTagN 0 0 p.idx + putTagN 0 0 p.cidx Serialize.put p.block def getConstructorProj : GetM ConstructorProj := do - let idx := (← getTag0).size - let cidx := (← getTag0).size + let idx := (← getTagN 0).value + let cidx := (← getTagN 0).value let block ← Serialize.get return ⟨idx, cidx, block⟩ @@ -1441,11 +1464,11 @@ instance : Serialize ConstructorProj where get := getConstructorProj def putRecursorProj (p : RecursorProj) : PutM Unit := do - putTag0 ⟨p.idx⟩ + putTagN 0 0 p.idx Serialize.put p.block def getRecursorProj : GetM RecursorProj := do - let idx := (← getTag0).size + let idx := (← getTagN 0).value let block ← Serialize.get return ⟨idx, block⟩ @@ -1454,11 +1477,11 @@ instance : Serialize RecursorProj where get := getRecursorProj def putDefinitionProj (p : DefinitionProj) : PutM Unit := do - putTag0 ⟨p.idx⟩ + putTagN 0 0 p.idx Serialize.put p.block def getDefinitionProj : GetM DefinitionProj := do - let idx := (← getTag0).size + let idx := (← getTagN 0).value let block ← Serialize.get return ⟨idx, block⟩ @@ -1483,27 +1506,27 @@ instance : Serialize MutConst where get := getMutConst def putConstantInfo : ConstantInfo → PutM Unit - | .defn d => putTag4 ⟨Constant.FLAG, ConstantInfo.CONST_DEFN⟩ *> putDefinition d - | .recr r => putTag4 ⟨Constant.FLAG, ConstantInfo.CONST_RECR⟩ *> putRecursor r - | .axio a => putTag4 ⟨Constant.FLAG, ConstantInfo.CONST_AXIO⟩ *> putAxiom a - | .quot q => putTag4 ⟨Constant.FLAG, ConstantInfo.CONST_QUOT⟩ *> putQuotient q - | .cPrj p => putTag4 ⟨Constant.FLAG, ConstantInfo.CONST_CPRJ⟩ *> putConstructorProj p - | .rPrj p => putTag4 ⟨Constant.FLAG, ConstantInfo.CONST_RPRJ⟩ *> putRecursorProj p - | .iPrj p => putTag4 ⟨Constant.FLAG, ConstantInfo.CONST_IPRJ⟩ *> putInductiveProj p - | .dPrj p => putTag4 ⟨Constant.FLAG, ConstantInfo.CONST_DPRJ⟩ *> putDefinitionProj p + | .defn d => putTagN 4 Constant.FLAG ConstantInfo.CONST_DEFN *> putDefinition d + | .recr r => putTagN 4 Constant.FLAG ConstantInfo.CONST_RECR *> putRecursor r + | .axio a => putTagN 4 Constant.FLAG ConstantInfo.CONST_AXIO *> putAxiom a + | .quot q => putTagN 4 Constant.FLAG ConstantInfo.CONST_QUOT *> putQuotient q + | .cPrj p => putTagN 4 Constant.FLAG ConstantInfo.CONST_CPRJ *> putConstructorProj p + | .rPrj p => putTagN 4 Constant.FLAG ConstantInfo.CONST_RPRJ *> putRecursorProj p + | .iPrj p => putTagN 4 Constant.FLAG ConstantInfo.CONST_IPRJ *> putInductiveProj p + | .dPrj p => putTagN 4 Constant.FLAG ConstantInfo.CONST_DPRJ *> putDefinitionProj p | .muts ms => do - putTag4 ⟨Constant.FLAG_MUTS, ms.size.toUInt64⟩ + putTagN 4 Constant.FLAG_MUTS ms.size.toUInt64 for m in ms do putMutConst m def getConstantInfo : GetM ConstantInfo := do - let tag ← getTag4 + let tag ← getTagN 4 if tag.flag == Constant.FLAG_MUTS then let mut ms := #[] - for _ in [0:tag.size.toNat] do + for _ in [0:tag.value.toNat] do ms := ms.push (← getMutConst) return .muts ms else if tag.flag == Constant.FLAG then - match tag.size with + match tag.value with | 0 => .defn <$> getDefinition | 1 => .recr <$> getRecursor | 2 => .axio <$> getAxiom @@ -1522,24 +1545,24 @@ instance : Serialize ConstantInfo where def putConstant (c : Constant) : PutM Unit := do putConstantInfo c.info - putTag0 ⟨c.sharing.size.toUInt64⟩ + putTagN 0 0 c.sharing.size.toUInt64 for e in c.sharing do putExpr e - putTag0 ⟨c.refs.size.toUInt64⟩ + putTagN 0 0 c.refs.size.toUInt64 for a in c.refs do Serialize.put a - putTag0 ⟨c.univs.size.toUInt64⟩ + putTagN 0 0 c.univs.size.toUInt64 for u in c.univs do putUniv u def getConstant : GetM Constant := do let info ← getConstantInfo - let numSharing := (← getTag0).size.toNat + let numSharing := (← getTagN 0).value.toNat let mut sharing := #[] for _ in [0:numSharing] do sharing := sharing.push (← getExpr) - let numRefs := (← getTag0).size.toNat + let numRefs := (← getTagN 0).value.toNat let mut refs := #[] for _ in [0:numRefs] do refs := refs.push (← Serialize.get) - let numUnivs := (← getTag0).size.toNat + let numUnivs := (← getTagN 0).value.toNat let mut univs := #[] for _ in [0:numUnivs] do univs := univs.push (← getUniv) @@ -1592,9 +1615,9 @@ structure LazyConstant where `ofConstant` it is a standalone buffer holding just this constant's serialized bytes. -/ buf : ByteArray - /-- Start offset of this constant's Tag4 body within `buf`. -/ + /-- Start offset of this constant's TagN-headed body within `buf`. -/ off : Nat := 0 - /-- Length of this constant's Tag4 body. -/ + /-- Length of this constant's TagN-headed body. -/ len : Nat /-- Pre-materialized constant. `some` only for the build path; the lazy load path leaves this `none` and parses the window fresh on each `get`. -/ @@ -1628,7 +1651,7 @@ def get? (lc : LazyConstant) : Option Constant := | some c => some c | none => (deConstantAt lc.buf lc.off).toOption -/-- Raw serialized bytes (the Tag4 constant body). Returns the backing buffer +/-- Raw serialized bytes (the TagN-headed constant body). Returns the backing buffer directly when the window spans all of it (the standalone case), and only copies out a sub-slice for a true window into a larger shared buffer. -/ def rawBytes (lc : LazyConstant) : ByteArray := @@ -1645,7 +1668,7 @@ inductive ConstTag where namespace LazyConstant -/-- Peek the `ConstantInfo` variant from the leading Tag4 head byte, without +/-- Peek the `ConstantInfo` variant from the leading TagN (`f = 4`) header byte, without parsing the body — the cheap dispatch used by anon work enumeration (mirrors Rust `LazyConstant::peek_variant`). -/ def peekTag (lc : LazyConstant) : Except String ConstTag := do @@ -1658,9 +1681,9 @@ def peekTag (lc : LazyConstant) : Except String ConstTag := do if flag == Constant.FLAG_MUTS then return .muts if flag != Constant.FLAG then - throw s!"LazyConstant.peekTag: unexpected Tag4 flag {flag} (head={head})" + throw s!"LazyConstant.peekTag: unexpected constant header flag {flag} (head={head})" if large then - throw s!"LazyConstant.peekTag: unexpected large-form Tag4 for non-Muts constant (head={head})" + throw s!"LazyConstant.peekTag: unexpected multi-byte header for non-Muts constant (head={head})" if small == ConstantInfo.CONST_DEFN then return .defn else if small == ConstantInfo.CONST_RECR then return .recr else if small == ConstantInfo.CONST_AXIO then return .axio @@ -1684,23 +1707,23 @@ abbrev NameReverseIndex := Array Address /-- Put an address as an index. -/ def putIdx (addr : Address) (idx : NameIndex) : PutM Unit := do let i := idx.get? addr |>.getD 0 - putTag0 ⟨i⟩ + putTagN 0 0 i /-- Get an address from an index. -/ def getIdx (rev : NameReverseIndex) : GetM Address := do - let i := (← getTag0).size.toNat + let i := (← getTagN 0).value.toNat match rev[i]? with | some addr => pure addr | none => throw s!"invalid name index {i}, max {rev.size}" /-- Put a vector of addresses as indices. -/ def putIdxVec (addrs : Array Address) (idx : NameIndex) : PutM Unit := do - putTag0 ⟨addrs.size.toUInt64⟩ + putTagN 0 0 addrs.size.toUInt64 for a in addrs do putIdx a idx /-- Get a vector of addresses from indices. -/ def getIdxVec (rev : NameReverseIndex) : GetM (Array Address) := do - let len := (← getTag0).size.toNat + let len := (← getTagN 0).value.toNat let mut v := #[] for _ in [0:len] do v := v.push (← getIdx rev) @@ -1721,16 +1744,16 @@ def getBinderInfo : GetM Lean.BinderInfo := do | 3 => pure .instImplicit | x => throw s!"invalid BinderInfo {x}" -/-- Serialize ReducibilityHints fused into a single Tag0 value: +/-- Serialize ReducibilityHints fused into a single TagN (`f = 0`) value: 0 = opaque, 1 = abbrev, h + 2 = regular h. The §3 wire form — mirrors Rust `serialize.rs::fuse_hint`. -/ def putFusedHint : Lean.ReducibilityHints → PutM Unit - | .opaque => putTag0 ⟨0⟩ - | .abbrev => putTag0 ⟨1⟩ - | .regular n => putTag0 ⟨n.toUInt64 + 2⟩ + | .opaque => putTagN 0 0 0 + | .abbrev => putTagN 0 0 1 + | .regular n => putTagN 0 0 (n.toUInt64 + 2) def getFusedHint : GetM Lean.ReducibilityHints := do - match (← getTag0).size with + match (← getTagN 0).value with | 0 => pure .opaque | 1 => pure .abbrev | v => @@ -1743,13 +1766,13 @@ def getFusedHint : GetM Lean.ReducibilityHints := do value + 1 (some opaque = 1, some abbrev = 2, some (regular h) = h + 3). The §5 per-name hint form; mirrors Rust `fuse_opt_hint`. -/ def putFusedOptHint : Option Lean.ReducibilityHints → PutM Unit - | none => putTag0 ⟨0⟩ - | some .opaque => putTag0 ⟨1⟩ - | some .abbrev => putTag0 ⟨2⟩ - | some (.regular n) => putTag0 ⟨n.toUInt64 + 3⟩ + | none => putTagN 0 0 0 + | some .opaque => putTagN 0 0 1 + | some .abbrev => putTagN 0 0 2 + | some (.regular n) => putTagN 0 0 (n.toUInt64 + 3) def getFusedOptHint : GetM (Option Lean.ReducibilityHints) := do - match (← getTag0).size with + match (← getTagN 0).value with | 0 => pure none | 1 => pure (some .opaque) | 2 => pure (some .abbrev) @@ -1798,13 +1821,13 @@ def getDataValueIndexed (rev : NameReverseIndex) : GetM DataValue := do /-- Serialize KVMap with indexed addresses. -/ def putKVMapIndexed (kvmap : KVMap) (idx : NameIndex) : PutM Unit := do - putTag0 ⟨kvmap.size.toUInt64⟩ + putTagN 0 0 kvmap.size.toUInt64 for (k, v) in kvmap do putIdx k idx putDataValueIndexed v idx def getKVMapIndexed (rev : NameReverseIndex) : GetM KVMap := do - let len := (← getTag0).size.toNat + let len := (← getTagN 0).value.toNat let mut kvmap := #[] for _ in [0:len] do let k ← getIdx rev @@ -1814,186 +1837,291 @@ def getKVMapIndexed (rev : NameReverseIndex) : GetM KVMap := do /-- Serialize mdata stack (Array KVMap) with indexed addresses. -/ def putMdataStackIndexed (mdata : Array KVMap) (idx : NameIndex) : PutM Unit := do - putTag0 ⟨mdata.size.toUInt64⟩ + putTagN 0 0 mdata.size.toUInt64 for kv in mdata do putKVMapIndexed kv idx def getMdataStackIndexed (rev : NameReverseIndex) : GetM (Array KVMap) := do - let len := (← getTag0).size.toNat + let len := (← getTagN 0).value.toNat let mut mdata := #[] for _ in [0:len] do mdata := mdata.push (← getKVMapIndexed rev) pure mdata -/-- Serialize ExprMetaData with indexed addresses. Arena indices use Tag0 encoding. -/ -def putExprMetaDataIndexed (em : ExprMetaData) (idx : NameIndex) : PutM Unit := do +/-! ### ExprMeta arena wire format + +`arena := len node₀ … node_{len-1}`; node `i` is a tag byte +`kind <<< 3 ||| mask` followed by its fields in declaration order. Kinds: +0 leaf, 1 app, 2–5 binder (2 + binder info), 6 letBinder, 7 ref, 8 prj, +9 mdata, 10 callSite, 11 etaCallSite. Child references are never absolute: + +* The *structural* slots (app fun/arg, binder type/body, let + type/value/body, prj child, mdata child) may be **implicit**: bit `s` of + `mask` set means slot `s` is not written and refers to the node the + post-order cursor expects. The cursor `top` starts at `i` and visits the + slots last to first; an implicit slot is node `top - 1`, after which `top` + becomes `lo[top - 1]`; `lo[i]` is `top` after the last slot (the first + index of node `i`'s contiguous post-order block; `lo[i] = i` for a node + without structural slots). A tree allocated bottom-up in post-order writes + no child references at all. +* Every other reference (a structural slot whose bit is clear, and every + call-site reference) is **explicit**: TagN (`f = 0`) of the backward + delta `(i - 1 - c) mod 2^64`. Forward references are representable + (wrapping), so every arena of `UInt64` indices has an encoding. + +The writer marks a slot implicit exactly when its child is `top - 1`, and +the reader rejects an explicit slot equal to `top - 1` and an implicit slot +with `top = 0`, so each arena has exactly one encoding. Mirrors Rust +`ixon::metadata::ExprMeta::put_with` / `get_with`. -/ + +/-- Number of structural (possibly implicit) child slots of a node kind; +`none` for an unknown kind. -/ +def exprMetaSlotCount : Nat → Option Nat + | 0 | 7 | 10 | 11 => some 0 + | 1 | 2 | 3 | 4 | 5 => some 2 + | 6 => some 3 + | 8 | 9 => some 1 + | _ => none + +/-- The structural child slots of a node, in field order. -/ +def ExprMetaData.structuralSlots : ExprMetaData → Array UInt64 + | .app f a => #[f, a] + | .binder _ _ t b => #[t, b] + | .letBinder _ t v b => #[t, v, b] + | .prj _ c => #[c] + | .mdata _ c => #[c] + | _ => #[] + +/-- The implicit-slot mask of node `i` and its block start `lo[i]`, given +the block starts `lo[0..i]` of the preceding nodes. -/ +def exprMetaImplicitMask (node : ExprMetaData) (i : Nat) (lo : Array Nat) : + UInt8 × Nat := Id.run do + let slots := node.structuralSlots + let mut top := i + let mut mask : UInt8 := 0 + for k in [0:slots.size] do + let s := slots.size - 1 - k + if top > 0 && slots[s]!.toNat == top - 1 then + mask := mask ||| ((1 : UInt8) <<< s.toUInt8) + top := lo[top - 1]! + return (mask, top) + +/-- Explicit reference from node `i` to node `c`: TagN of `i - 1 - c` +(wrapping). -/ +def putExprMetaRef (i : Nat) (c : UInt64) : PutM Unit := + putTagN 0 0 (i.toUInt64 - 1 - c) + +def getExprMetaRef (i : Nat) : GetM UInt64 := do + let d := (← getTagN 0).value + pure (i.toUInt64 - 1 - d) + +/-- Call-site entries: count, then per entry a tag byte, the canonical or +sharing index, and an explicit reference. -/ +def putExprMetaEntries (i : Nat) (entries : Array CallSiteEntry) : PutM Unit := do + putTagN 0 0 entries.size.toUInt64 + for entry in entries do + match entry with + | .kept canonIdx metaIdx => + putU8 0 + putTagN 0 0 canonIdx + putExprMetaRef i metaIdx + | .collapsed sharingIdx metaIdx => + putU8 1 + putTagN 0 0 sharingIdx + putExprMetaRef i metaIdx + +def getExprMetaEntries (i : Nat) : GetM (Array CallSiteEntry) := do + let numEntries := (← getTagN 0).value.toNat + let mut entries : Array CallSiteEntry := #[] + for _ in [0:numEntries] do + let entry ← match ← getU8 with + | 0 => + let canonIdx := (← getTagN 0).value + let metaIdx ← getExprMetaRef i + pure (CallSiteEntry.kept canonIdx metaIdx) + | 1 => + let sharingIdx := (← getTagN 0).value + let metaIdx ← getExprMetaRef i + pure (CallSiteEntry.collapsed sharingIdx metaIdx) + | x => throw s!"invalid CallSiteEntry tag {x}" + entries := entries.push entry + pure entries + +/-- A count followed by explicit references. -/ +def putExprMetaRefs (i : Nat) (refs : Array UInt64) : PutM Unit := do + putTagN 0 0 refs.size.toUInt64 + for c in refs do putExprMetaRef i c + +def getExprMetaRefs (i : Nat) : GetM (Array UInt64) := do + let n := (← getTagN 0).value.toNat + let mut refs : Array UInt64 := #[] + for _ in [0:n] do + refs := refs.push (← getExprMetaRef i) + pure refs + +/-- Node tag byte: `kind <<< 3 ||| mask`. -/ +def exprMetaTag (kind mask : UInt8) : UInt8 := (kind <<< 3) ||| mask + +/-- Write node `i` of an arena with its implicit-slot `mask`. -/ +def putExprMetaNode (em : ExprMetaData) (i : Nat) (mask : UInt8) (idx : NameIndex) : + PutM Unit := do + let slot (s : UInt8) (c : UInt64) : PutM Unit := + if mask &&& ((1 : UInt8) <<< s) == 0 then putExprMetaRef i c else pure () match em with | .leaf => putU8 0 | .app f a => - putU8 1 - putTag0 ⟨f⟩ - putTag0 ⟨a⟩ + putU8 (exprMetaTag 1 mask) + slot 0 f + slot 1 a | .binder name info tyChild bodyChild => - let tag : UInt8 := 2 + match info with + let kind : UInt8 := 2 + match info with | .default => 0 | .implicit => 1 | .strictImplicit => 2 | .instImplicit => 3 - putU8 tag + putU8 (exprMetaTag kind mask) putIdx name idx - putTag0 ⟨tyChild⟩ - putTag0 ⟨bodyChild⟩ + slot 0 tyChild + slot 1 bodyChild | .letBinder name tyChild valChild bodyChild => - putU8 6 + putU8 (exprMetaTag 6 mask) putIdx name idx - putTag0 ⟨tyChild⟩ - putTag0 ⟨valChild⟩ - putTag0 ⟨bodyChild⟩ + slot 0 tyChild + slot 1 valChild + slot 2 bodyChild | .ref name => - putU8 7 + putU8 (exprMetaTag 7 0) putIdx name idx | .prj structName child => - putU8 8 + putU8 (exprMetaTag 8 mask) putIdx structName idx - putTag0 ⟨child⟩ + slot 0 child | .mdata mdata child => - putU8 9 + putU8 (exprMetaTag 9 mask) putMdataStackIndexed mdata idx - putTag0 ⟨child⟩ + slot 0 child | .callSite name entries canonMeta origHead => - putU8 10 + putU8 (exprMetaTag 10 0) putIdx name idx - putTag0 ⟨entries.size.toUInt64⟩ - for entry in entries do - match entry with - | .kept canonIdx metaIdx => - putU8 0 - putTag0 ⟨canonIdx⟩ - putTag0 ⟨metaIdx⟩ - | .collapsed sharingIdx metaIdx => - putU8 1 - putTag0 ⟨sharingIdx⟩ - putTag0 ⟨metaIdx⟩ - putTag0 ⟨canonMeta.size.toUInt64⟩ - for m in canonMeta do putTag0 ⟨m⟩ + putExprMetaEntries i entries + putExprMetaRefs i canonMeta match origHead with | none => putU8 0 | some (sharingIdx, metaIdx) => putU8 1 - putTag0 ⟨sharingIdx⟩ - putTag0 ⟨metaIdx⟩ + putTagN 0 0 sharingIdx + putExprMetaRef i metaIdx | .etaCallSite nSynth name entries canonMeta wrapperMeta => - putU8 11 - putTag0 ⟨nSynth⟩ + putU8 (exprMetaTag 11 0) + putTagN 0 0 nSynth putIdx name idx - putTag0 ⟨entries.size.toUInt64⟩ - for entry in entries do - match entry with - | .kept canonIdx metaIdx => - putU8 0 - putTag0 ⟨canonIdx⟩ - putTag0 ⟨metaIdx⟩ - | .collapsed sharingIdx metaIdx => - putU8 1 - putTag0 ⟨sharingIdx⟩ - putTag0 ⟨metaIdx⟩ - putTag0 ⟨canonMeta.size.toUInt64⟩ - for m in canonMeta do putTag0 ⟨m⟩ - putTag0 ⟨wrapperMeta⟩ - -def getExprMetaDataIndexed (rev : NameReverseIndex) : GetM ExprMetaData := do + putExprMetaEntries i entries + putExprMetaRefs i canonMeta + putExprMetaRef i wrapperMeta + +/-- Resolve the implicit slots of node `i` (explicit ones are already read) +and return them with `lo[i]`; rejects an implicit slot with no preceding +node and an explicit slot at the implicit position. -/ +def resolveExprMetaSlots (slots : Array UInt64) (mask : UInt8) (i : Nat) + (lo : Array Nat) : GetM (Array UInt64 × Nat) := do + let mut cs := slots + let mut top := i + for k in [0:cs.size] do + let s := cs.size - 1 - k + if mask &&& ((1 : UInt8) <<< s.toUInt8) != 0 then + if top == 0 then + throw s!"ExprMeta: node {i}: implicit child slot {s} with no preceding node" + cs := cs.set! s (top - 1).toUInt64 + top := lo[top - 1]! + else if top > 0 && cs[s]!.toNat == top - 1 then + throw s!"ExprMeta: node {i}: explicit child slot {s} refers to the implicit \ + position {top - 1} (noncanonical)" + return (cs, top) + +/-- Read node `i` of an arena, given the block starts `lo[0..i]`; returns the +node and `lo[i]`. -/ +def getExprMetaNode (rev : NameReverseIndex) (i : Nat) (lo : Array Nat) : + GetM (ExprMetaData × Nat) := do let tag ← getU8 - match tag with - | 0 => pure .leaf + let kind := (tag >>> 3).toNat + let mask := tag &&& 7 + match exprMetaSlotCount kind with + | some n => if mask.toNat ≥ 2 ^ n then throw s!"invalid ExprMetaData tag {tag}" + | none => throw s!"invalid ExprMetaData tag {tag}" + let slot (s : UInt8) : GetM UInt64 := + if mask &&& ((1 : UInt8) <<< s) == 0 then getExprMetaRef i else pure 0 + match kind with + | 0 => pure (.leaf, i) | 1 => - let f := (← getTag0).size - let a := (← getTag0).size - pure (.app f a) + let f ← slot 0 + let a ← slot 1 + let (cs, top) ← resolveExprMetaSlots #[f, a] mask i lo + pure (.app cs[0]! cs[1]!, top) | 2 | 3 | 4 | 5 => - let info := match tag with + let info := match kind with | 2 => Lean.BinderInfo.default | 3 => .implicit | 4 => .strictImplicit | _ => .instImplicit let name ← getIdx rev - let tyChild := (← getTag0).size - let bodyChild := (← getTag0).size - pure (.binder name info tyChild bodyChild) + let t ← slot 0 + let b ← slot 1 + let (cs, top) ← resolveExprMetaSlots #[t, b] mask i lo + pure (.binder name info cs[0]! cs[1]!, top) | 6 => let name ← getIdx rev - let tyChild := (← getTag0).size - let valChild := (← getTag0).size - let bodyChild := (← getTag0).size - pure (.letBinder name tyChild valChild bodyChild) + let t ← slot 0 + let v ← slot 1 + let b ← slot 2 + let (cs, top) ← resolveExprMetaSlots #[t, v, b] mask i lo + pure (.letBinder name cs[0]! cs[1]! cs[2]!, top) | 7 => let name ← getIdx rev - pure (.ref name) + pure (.ref name, i) | 8 => let structName ← getIdx rev - let child := (← getTag0).size - pure (.prj structName child) + let c ← slot 0 + let (cs, top) ← resolveExprMetaSlots #[c] mask i lo + pure (.prj structName cs[0]!, top) | 9 => let mdata ← getMdataStackIndexed rev - let child := (← getTag0).size - pure (.mdata mdata child) + let c ← slot 0 + let (cs, top) ← resolveExprMetaSlots #[c] mask i lo + pure (.mdata mdata cs[0]!, top) | 10 => let name ← getIdx rev - let numEntries := (← getTag0).size.toNat - let mut entries : Array CallSiteEntry := #[] - for _ in [0:numEntries] do - let entry ← match ← getU8 with - | 0 => - let canonIdx := (← getTag0).size - let metaIdx := (← getTag0).size - pure (CallSiteEntry.kept canonIdx metaIdx) - | 1 => - let sharingIdx := (← getTag0).size - let metaIdx := (← getTag0).size - pure (CallSiteEntry.collapsed sharingIdx metaIdx) - | x => throw s!"invalid CallSiteEntry tag {x}" - entries := entries.push entry - let numCanonMeta := (← getTag0).size.toNat - let mut canonMeta : Array UInt64 := #[] - for _ in [0:numCanonMeta] do - canonMeta := canonMeta.push (← getTag0).size + let entries ← getExprMetaEntries i + let canonMeta ← getExprMetaRefs i let origHead ← match ← getU8 with | 0 => pure none | 1 => - let sharingIdx := (← getTag0).size - let metaIdx := (← getTag0).size + let sharingIdx := (← getTagN 0).value + let metaIdx ← getExprMetaRef i pure (some (sharingIdx, metaIdx)) | x => throw s!"invalid CallSite origHead tag {x}" - pure (.callSite name entries canonMeta origHead) - | 11 => - let nSynth := (← getTag0).size + pure (.callSite name entries canonMeta origHead, i) + | _ => + let nSynth := (← getTagN 0).value let name ← getIdx rev - let numEntries := (← getTag0).size.toNat - let mut entries : Array CallSiteEntry := #[] - for _ in [0:numEntries] do - let entry ← match ← getU8 with - | 0 => - let canonIdx := (← getTag0).size - let metaIdx := (← getTag0).size - pure (CallSiteEntry.kept canonIdx metaIdx) - | 1 => - let sharingIdx := (← getTag0).size - let metaIdx := (← getTag0).size - pure (CallSiteEntry.collapsed sharingIdx metaIdx) - | x => throw s!"invalid CallSiteEntry tag {x}" - entries := entries.push entry - let numCanonMeta := (← getTag0).size.toNat - let mut canonMeta : Array UInt64 := #[] - for _ in [0:numCanonMeta] do - canonMeta := canonMeta.push (← getTag0).size - let wrapperMeta := (← getTag0).size - pure (.etaCallSite nSynth name entries canonMeta wrapperMeta) - | x => throw s!"invalid ExprMetaData tag {x}" - -/-- Serialize ExprMetaArena (length-prefixed array of ExprMetaData nodes). -/ + let entries ← getExprMetaEntries i + let canonMeta ← getExprMetaRefs i + let wrapperMeta ← getExprMetaRef i + pure (.etaCallSite nSynth name entries canonMeta wrapperMeta, i) + +/-- Serialize ExprMetaArena (length-prefixed array of nodes; see the arena +wire format above). -/ def putExprMetaArenaIndexed (arena : ExprMetaArena) (idx : NameIndex) : PutM Unit := do - putTag0 ⟨arena.nodes.size.toUInt64⟩ + putTagN 0 0 arena.nodes.size.toUInt64 + let mut lo : Array Nat := #[] + let mut i := 0 for node in arena.nodes do - putExprMetaDataIndexed node idx + let (mask, top) := exprMetaImplicitMask node i lo + putExprMetaNode node i mask idx + lo := lo.push top + i := i + 1 def getExprMetaArenaIndexed (rev : NameReverseIndex) : GetM ExprMetaArena := do - let len := (← getTag0).size.toNat + let len := (← getTagN 0).value.toNat let mut nodes : Array ExprMetaData := #[] - for _ in [0:len] do - nodes := nodes.push (← getExprMetaDataIndexed rev) + let mut lo : Array Nat := #[] + for i in [0:len] do + let (node, top) ← getExprMetaNode rev i lo + nodes := nodes.push node + lo := lo.push top pure ⟨nodes⟩ /-- Serialize the ConstantMetaInfo variant payload with indexed addresses. -/ @@ -2007,20 +2135,20 @@ def putConstantMetaInfoIndexed (cm : ConstantMetaInfo) (idx : NameIndex) : PutM putIdxVec all idx putIdxVec ctx idx putExprMetaArenaIndexed arena idx - putTag0 ⟨typeRoot⟩ - putTag0 ⟨valueRoot⟩ + putTagN 0 0 typeRoot + putTagN 0 0 valueRoot | .axio name lvls arena typeRoot => putU8 1 putIdx name idx putIdxVec lvls idx putExprMetaArenaIndexed arena idx - putTag0 ⟨typeRoot⟩ + putTagN 0 0 typeRoot | .quot name lvls arena typeRoot => putU8 2 putIdx name idx putIdxVec lvls idx putExprMetaArenaIndexed arena idx - putTag0 ⟨typeRoot⟩ + putTagN 0 0 typeRoot | .indc name lvls ctors all ctx arena typeRoot => putU8 3 putIdx name idx @@ -2029,14 +2157,14 @@ def putConstantMetaInfoIndexed (cm : ConstantMetaInfo) (idx : NameIndex) : PutM putIdxVec all idx putIdxVec ctx idx putExprMetaArenaIndexed arena idx - putTag0 ⟨typeRoot⟩ + putTagN 0 0 typeRoot | .ctor name lvls induct arena typeRoot => putU8 4 putIdx name idx putIdxVec lvls idx putIdx induct idx putExprMetaArenaIndexed arena idx - putTag0 ⟨typeRoot⟩ + putTagN 0 0 typeRoot | .recr name lvls rules all ctx arena typeRoot ruleRoots => putU8 5 putIdx name idx @@ -2045,53 +2173,53 @@ def putConstantMetaInfoIndexed (cm : ConstantMetaInfo) (idx : NameIndex) : PutM putIdxVec all idx putIdxVec ctx idx putExprMetaArenaIndexed arena idx - putTag0 ⟨typeRoot⟩ - putTag0 ⟨ruleRoots.size.toUInt64⟩ - for r in ruleRoots do putTag0 ⟨r⟩ + putTagN 0 0 typeRoot + putTagN 0 0 ruleRoots.size.toUInt64 + for r in ruleRoots do putTagN 0 0 r | .muts all auxLayout => putU8 6 - putTag0 ⟨all.size.toUInt64⟩ + putTagN 0 0 all.size.toUInt64 for cls in all do putIdxVec cls idx -- Option AuxLayout: 0 tag = none, 1 tag = some(perm vec, ctor-count - -- vec, evaporated flags). Vecs are Tag0 u64s; evaporated flags are + -- vec, evaporated flags). Vecs are TagN (`f = 0`) u64s; evaporated flags are -- one u8 (0/1) per entry (mirrors Rust `ConstantMetaInfo::Muts`). match auxLayout with | none => putU8 0 | some layout => putU8 1 - putTag0 ⟨layout.perm.size.toUInt64⟩ - for p in layout.perm do putTag0 ⟨p⟩ - putTag0 ⟨layout.sourceCtorCounts.size.toUInt64⟩ - for c in layout.sourceCtorCounts do putTag0 ⟨c⟩ + putTagN 0 0 layout.perm.size.toUInt64 + for p in layout.perm do putTagN 0 0 p + putTagN 0 0 layout.sourceCtorCounts.size.toUInt64 + for c in layout.sourceCtorCounts do putTagN 0 0 c -- Construction sites that predate the field default -- `evaporated := #[]`; serialize per-position all-`0` flags for -- them (the FFI decode normalizes identically), so the wire form -- always carries `perm.size` flags and Lean/Rust bytes agree. let evaporated := if layout.evaporated.isEmpty && !layout.perm.isEmpty then Array.replicate layout.perm.size 0 else layout.evaporated - putTag0 ⟨evaporated.size.toUInt64⟩ + putTagN 0 0 evaporated.size.toUInt64 for b in evaporated do putU8 (if b != 0 then 1 else 0) /-- Serialize ConstantMeta (wrapper) with indexed addresses: the variant payload, then the three extension tables — sharing exprs (`putExpr`), refs (raw 32-byte addresses, NOT name-indexed), univs (`putUniv`) — - then the level-spelling patches (per entry: Tag0 arenaIdx, Tag0 len, - Tag0 virtual univ indices; canonicity §10.6). Mirrors Rust + then the level-spelling patches (per entry: TagN arenaIdx, TagN len, + TagN virtual univ indices; canonicity §10.6). Mirrors Rust `ConstantMeta::put_with`. -/ def putConstantMetaIndexed (cm : ConstantMeta) (idx : NameIndex) : PutM Unit := do putConstantMetaInfoIndexed cm.info idx - putTag0 ⟨cm.metaSharing.size.toUInt64⟩ + putTagN 0 0 cm.metaSharing.size.toUInt64 for e in cm.metaSharing do putExpr e - putTag0 ⟨cm.metaRefs.size.toUInt64⟩ + putTagN 0 0 cm.metaRefs.size.toUInt64 for a in cm.metaRefs do Serialize.put a - putTag0 ⟨cm.metaUnivs.size.toUInt64⟩ + putTagN 0 0 cm.metaUnivs.size.toUInt64 for u in cm.metaUnivs do putUniv u - putTag0 ⟨cm.univPatches.size.toUInt64⟩ + putTagN 0 0 cm.univPatches.size.toUInt64 for p in cm.univPatches do - putTag0 ⟨p.arenaIdx⟩ - putTag0 ⟨p.univIdxs.size.toUInt64⟩ - for i in p.univIdxs do putTag0 ⟨i⟩ + putTagN 0 0 p.arenaIdx + putTagN 0 0 p.univIdxs.size.toUInt64 + for i in p.univIdxs do putTagN 0 0 i def getConstantMetaInfoIndexed (rev : NameReverseIndex) : GetM ConstantMetaInfo := do let cm ← match ← getU8 with @@ -2102,20 +2230,20 @@ def getConstantMetaInfoIndexed (rev : NameReverseIndex) : GetM ConstantMetaInfo let all ← getIdxVec rev let ctx ← getIdxVec rev let arena ← getExprMetaArenaIndexed rev - let typeRoot := (← getTag0).size - let valueRoot := (← getTag0).size + let typeRoot := (← getTagN 0).value + let valueRoot := (← getTagN 0).value pure (.defn name lvls all ctx arena typeRoot valueRoot) | 1 => let name ← getIdx rev let lvls ← getIdxVec rev let arena ← getExprMetaArenaIndexed rev - let typeRoot := (← getTag0).size + let typeRoot := (← getTagN 0).value pure (.axio name lvls arena typeRoot) | 2 => let name ← getIdx rev let lvls ← getIdxVec rev let arena ← getExprMetaArenaIndexed rev - let typeRoot := (← getTag0).size + let typeRoot := (← getTagN 0).value pure (.quot name lvls arena typeRoot) | 3 => let name ← getIdx rev @@ -2124,14 +2252,14 @@ def getConstantMetaInfoIndexed (rev : NameReverseIndex) : GetM ConstantMetaInfo let all ← getIdxVec rev let ctx ← getIdxVec rev let arena ← getExprMetaArenaIndexed rev - let typeRoot := (← getTag0).size + let typeRoot := (← getTagN 0).value pure (.indc name lvls ctors all ctx arena typeRoot) | 4 => let name ← getIdx rev let lvls ← getIdxVec rev let induct ← getIdx rev let arena ← getExprMetaArenaIndexed rev - let typeRoot := (← getTag0).size + let typeRoot := (← getTagN 0).value pure (.ctor name lvls induct arena typeRoot) | 5 => let name ← getIdx rev @@ -2140,14 +2268,14 @@ def getConstantMetaInfoIndexed (rev : NameReverseIndex) : GetM ConstantMetaInfo let all ← getIdxVec rev let ctx ← getIdxVec rev let arena ← getExprMetaArenaIndexed rev - let typeRoot := (← getTag0).size - let numRuleRoots := (← getTag0).size.toNat + let typeRoot := (← getTagN 0).value + let numRuleRoots := (← getTagN 0).value.toNat let mut ruleRoots : Array UInt64 := #[] for _ in [0:numRuleRoots] do - ruleRoots := ruleRoots.push (← getTag0).size + ruleRoots := ruleRoots.push (← getTagN 0).value pure (.recr name lvls rules all ctx arena typeRoot ruleRoots) | 6 => - let n := (← getTag0).size.toNat + let n := (← getTagN 0).value.toNat let mut all : Array (Array Address) := #[] for _ in [0:n] do all := all.push (← getIdxVec rev) @@ -2155,15 +2283,15 @@ def getConstantMetaInfoIndexed (rev : NameReverseIndex) : GetM ConstantMetaInfo let auxLayout ← match auxLayoutTag with | 0 => pure none | 1 => do - let nPerm := (← getTag0).size.toNat + let nPerm := (← getTagN 0).value.toNat let mut perm : Array UInt64 := #[] for _ in [0:nPerm] do - perm := perm.push (← getTag0).size - let nCounts := (← getTag0).size.toNat + perm := perm.push (← getTagN 0).value + let nCounts := (← getTagN 0).value.toNat let mut sourceCtorCounts : Array UInt64 := #[] for _ in [0:nCounts] do - sourceCtorCounts := sourceCtorCounts.push (← getTag0).size - let nEvap := (← getTag0).size.toNat + sourceCtorCounts := sourceCtorCounts.push (← getTagN 0).value + let nEvap := (← getTagN 0).value.toNat let mut evaporated : Array UInt64 := #[] for _ in [0:nEvap] do match ← getU8 with @@ -2183,26 +2311,26 @@ def getConstantMetaInfoIndexed (rev : NameReverseIndex) : GetM ConstantMetaInfo hint. -/ def getConstantMetaIndexed (rev : NameReverseIndex) : GetM ConstantMeta := do let info ← getConstantMetaInfoIndexed rev - let sharingLen := (← getTag0).size.toNat + let sharingLen := (← getTagN 0).value.toNat let mut metaSharing : Array Expr := #[] for _ in [0:sharingLen] do metaSharing := metaSharing.push (← getExpr) - let refsLen := (← getTag0).size.toNat + let refsLen := (← getTagN 0).value.toNat let mut metaRefs : Array Address := #[] for _ in [0:refsLen] do metaRefs := metaRefs.push (← Serialize.get (α := Address)) - let univsLen := (← getTag0).size.toNat + let univsLen := (← getTagN 0).value.toNat let mut metaUnivs : Array Univ := #[] for _ in [0:univsLen] do metaUnivs := metaUnivs.push (← getUniv) - let patchesLen := (← getTag0).size.toNat + let patchesLen := (← getTagN 0).value.toNat let mut univPatches : Array UnivPatch := #[] for _ in [0:patchesLen] do - let arenaIdx := (← getTag0).size - let idxsLen := (← getTag0).size.toNat + let arenaIdx := (← getTagN 0).value + let idxsLen := (← getTagN 0).value.toNat let mut univIdxs : Array UInt64 := #[] for _ in [0:idxsLen] do - univIdxs := univIdxs.push (← getTag0).size + univIdxs := univIdxs.push (← getTagN 0).value univPatches := univPatches.push { arenaIdx, univIdxs } pure { info, metaSharing, metaRefs, metaUnivs, univPatches } @@ -2224,15 +2352,15 @@ instance : Serialize Comm where def serComm (c : Comm) : ByteArray := runPut (putComm c) def deComm (bytes : ByteArray) : Except String Comm := runGet getComm bytes -/-- Serialize Comm with Tag4{0xE, 1} header. -/ +/-- Serialize Comm with TagN(4, 0xE, 1) header. -/ def putCommTagged (c : Comm) : PutM Unit := do - putTag4 ⟨0xE, 1⟩ + putTagN 4 0xE 1 putComm c -/-- Serialize Comm with Tag4{0xE, 1} header to bytes. -/ +/-- Serialize Comm with TagN(4, 0xE, 1) header to bytes. -/ def serCommTagged (c : Comm) : ByteArray := runPut (putCommTagged c) -/-- Compute commitment address: blake3(Tag4{0xE,5} + secret + payload). -/ +/-- Compute commitment address: blake3(TagN(4, 0xE, 5) + secret + payload). -/ def Comm.commit (c : Comm) : Address := Address.blake3 (serCommTagged c) /-! ## Ixon Environment -/ @@ -2362,21 +2490,12 @@ def u8? (c : DeserCursor) : Option (UInt8 × DeserCursor) := some (c.bytes[c.pos], { c with pos := c.pos + 1 }) else none -/-- Tag0 varint (same format as `getTag0`): head byte < 128 is the value; - otherwise `head % 128 + 1` little-endian extra bytes follow. -/ -def tag0? (c : DeserCursor) : Option (UInt64 × DeserCursor) := do - let (head, c) ← c.u8? - if head < 128 then - some (head.toUInt64, c) - else - let extra := (head % 128).toNat + 1 - let mut val : UInt64 := 0 - let mut cur := c - for i in [0:extra] do - let (b, c') ← cur.u8? - val := val ||| (b.toUInt64 <<< (i * 8).toUInt64) - cur := c' - some (val, cur) +/-- A TagN (`f = 0`) integer, read by `getTagN 0`; `none` on a malformed + or truncated integer. -/ +def tagN0? (c : DeserCursor) : Option (UInt64 × DeserCursor) := + match (getTagN 0).run { idx := c.pos, bytes := c.bytes } with + | .ok t s => some (t.value, { c with pos := s.idx }) + | .error _ _ => none def addr? (c : DeserCursor) : Option (Address × DeserCursor) := if c.pos + 32 ≤ c.bytes.size then @@ -2399,8 +2518,8 @@ def deserSubstring (env : Env) (c : DeserCursor) : Option (Ix.Substring × DeserCursor) := do let (strAddr, c) ← c.addr? let s ← (← env.getBlob? strAddr) |> String.fromUTF8? - let (startPos, c) ← c.tag0? - let (stopPos, c) ← c.tag0? + let (startPos, c) ← c.tagN0? + let (stopPos, c) ← c.tagN0? some (⟨s, startPos.toNat, stopPos.toNat⟩, c) def deserSourceInfo (env : Env) (c : DeserCursor) : @@ -2409,13 +2528,13 @@ def deserSourceInfo (env : Env) (c : DeserCursor) : match tag with | 0 => let (leading, c) ← deserSubstring env c - let (leadingPos, c) ← c.tag0? + let (leadingPos, c) ← c.tagN0? let (trailing, c) ← deserSubstring env c - let (trailingPos, c) ← c.tag0? + let (trailingPos, c) ← c.tagN0? some (.original leading leadingPos.toNat trailing trailingPos.toNat, c) | 1 => - let (start, c) ← c.tag0? - let (stop, c) ← c.tag0? + let (start, c) ← c.tagN0? + let (stop, c) ← c.tagN0? let (canonical, c) ← c.u8? some (.synthetic start.toNat stop.toNat (canonical != 0), c) | 2 => some (.none, c) @@ -2432,7 +2551,7 @@ def deserPreresolved (env : Env) (c : DeserCursor) : | 1 => let (nameAddr, c) ← c.addr? let name ← env.names[nameAddr]? - let (count, c) ← c.tag0? + let (count, c) ← c.tagN0? let mut fields : Array String := #[] let mut cur := c for _ in [0:count.toNat] do @@ -2454,7 +2573,7 @@ partial def deserSyntax (env : Env) (c : DeserCursor) : let (info, c) ← deserSourceInfo env c let (kindAddr, c) ← c.addr? let kind ← env.names[kindAddr]? - let (argCount, c) ← c.tag0? + let (argCount, c) ← c.tagN0? let mut args : Array Ix.Syntax := #[] let mut cur := c for _ in [0:argCount.toNat] do @@ -2472,7 +2591,7 @@ partial def deserSyntax (env : Env) (c : DeserCursor) : let (rawVal, c) ← deserSubstring env c let (valAddr, c) ← c.addr? let val ← env.names[valAddr]? - let (prCount, c) ← c.tag0? + let (prCount, c) ← c.tagN0? let mut preresolved : Array Ix.SyntaxPreresolved := #[] let mut cur := c for _ in [0:prCount.toNat] do @@ -2650,15 +2769,21 @@ def toRawEnv (env : Env) : RawEnv := { fun a b => (compare a.1 b.1).isLT } -/-- Tag4 flag for Env (0xE). -/ +/-- TagN (`f = 4`) header flag for Env (0xE). -/ def FLAG : UInt8 := 0xE -/-- `.ixe` format version, carried in the header's Tag4 size field. +/-- `.ixe` format version, carried in the header's TagN value field. Any change to serialized bytes bumps this; readers reject a mismatch and there is no back-compat reading of old versions — - `.ixe` files are regenerated artifacts. Mirrors Rust + `.ixe` files are regenerated artifacts. Version 4 is the TagN + format; its header is the single byte `0xE4`. Mirrors Rust `Env::VERSION` in `crates/ixon/src/serialize.rs`. -/ -def VERSION : UInt64 := 3 +def VERSION : UInt64 := 4 + +/-- Object-format byte bound by claim, proof and catalog scopes: the + format version as one byte, so an object produced under another + version is rejected. Mirrors Rust `Env::OBJECT_FORMAT`. -/ +def OBJECT_FORMAT : UInt8 := VERSION.toUInt8 /-- Serialize a name component (references parent by address). Format: tag (1 byte) + parent_addr (32 bytes) + data -/ @@ -2668,13 +2793,13 @@ def putNameComponent (name : Ix.Name) : PutM Unit := do | .str parent s _ => putU8 1 Serialize.put parent.getHash - putTag0 ⟨s.utf8ByteSize.toUInt64⟩ + putTagN 0 0 s.utf8ByteSize.toUInt64 putBytes s.toUTF8 | .num parent n _ => putU8 2 Serialize.put parent.getHash let bytes := ByteArray.mk (Nat.toBytesLE n) - putTag0 ⟨bytes.size.toUInt64⟩ + putTagN 0 0 bytes.size.toUInt64 putBytes bytes /-- Deserialize a name component using a lookup table for parents. -/ @@ -2687,7 +2812,7 @@ def getNameComponent (namesLookup : Std.HashMap Address Ix.Name) : GetM Ix.Name let parent ← match namesLookup.get? parentAddr with | some p => pure p | none => throw s!"getNameComponent: missing parent address {reprStr (toString parentAddr)}" - let len := (← getTag0).size.toNat + let len := (← getTagN 0).value.toNat let sBytes ← getBytes len match String.fromUTF8? sBytes with | some s => pure (Ix.Name.mkStr parent s) @@ -2697,7 +2822,7 @@ def getNameComponent (namesLookup : Std.HashMap Address Ix.Name) : GetM Ix.Name let parent ← match namesLookup.get? parentAddr with | some p => pure p | none => throw s!"getNameComponent: missing parent address {reprStr (toString parentAddr)}" - let len := (← getTag0).size.toNat + let len := (← getTagN 0).value.toNat let nBytes ← getBytes len pure (Ix.Name.mkNat parent (Nat.fromBytesLE nBytes.data)) | t => throw s!"getNameComponent: invalid tag {t}" @@ -2739,8 +2864,8 @@ partial def topologicalSortNames (names : Std.HashMap Address Ix.Name) : Array ( referencing unstored constants/names are unrepresentable and must fail at write time (mirrors Rust `Env::put`). -/ def putEnv (env : Env) : ExceptT String PutM Unit := do - -- Header: Tag4 with flag=0xE, size=VERSION (format version) - putTag4 ⟨FLAG, VERSION⟩ + -- Header: TagN(4) with flag=0xE, value=VERSION (format version) + putTagN 4 FLAG VERSION -- Canonical merkle root over consts addresses (matches Rust Env::put). -- Always 32 bytes: for empty const sets, the sentinel @@ -2760,33 +2885,33 @@ def putEnv (env : Env) : ExceptT String PutM Unit := do Serialize.put addr let assumptions := env.assumptions.toList.toArray.qsort fun a b => (compare a b).isLT - putTag0 ⟨assumptions.size.toUInt64⟩ + putTagN 0 0 assumptions.size.toUInt64 for addr in assumptions do Serialize.put addr -- Section 1: Blobs (Address -> bytes) let blobs := env.blobs.toList.toArray.qsort fun a b => (compare a.1 b.1).isLT - putTag0 ⟨blobs.size.toUInt64⟩ + putTagN 0 0 blobs.size.toUInt64 for (addr, bytes) in blobs do Serialize.put addr - putTag0 ⟨bytes.size.toUInt64⟩ + putTagN 0 0 bytes.size.toUInt64 putBytes bytes - -- Section 2: Consts (Address -> Tag0-length-prefixed Tag4 constant bytes) + -- Section 2: Consts (Address -> TagN-length-prefixed constant bytes) -- - -- The Tag0 length sidecar is added at the env-section level so a lazy - -- loader can slice each constant without parsing its Tag4 envelope. + -- The TagN length sidecar is added at the env-section level so a lazy + -- loader can slice each constant without parsing its header. -- The length is NOT part of the content-addressed bytes: the address - -- is `Address.hash` over the Tag4 constant body alone (which is + -- is `Address.hash` over the constant body alone (which is -- exactly what `serConstant` produces). let consts := env.consts.toList.toArray.qsort fun a b => (compare a.1 b.1).isLT - putTag0 ⟨consts.size.toUInt64⟩ + putTagN 0 0 consts.size.toUInt64 for (addr, lc) in consts do Serialize.put addr -- The lazy entry already holds exactly `serConstant`'s output, so write -- its bytes directly — no re-materialization or re-serialization. let bytes := lc.rawBytes - putTag0 ⟨bytes.size.toUInt64⟩ + putTagN 0 0 bytes.size.toUInt64 putBytes bytes -- Rank of each constant in §2's ascending-address order — §3 hint @@ -2802,7 +2927,7 @@ def putEnv (env : Env) : ExceptT String PutM Unit := do -- ascending). Matches Rust `Env::put`. let hintPairs := env.anonHints.toList.toArray.qsort fun a b => (compare a.1 b.1).isLT - putTag0 ⟨hintPairs.size.toUInt64⟩ + putTagN 0 0 hintPairs.size.toUInt64 let mut prevRank : UInt64 := 0 -- rank + 1 of the previous entry for (addr, hints) in hintPairs do match constIdx.get? addr with @@ -2810,7 +2935,7 @@ def putEnv (env : Env) : ExceptT String PutM Unit := do present in consts — hints must be keyed by stored \ constant addresses" | some rank => - putTag0 ⟨rank + 1 - prevRank⟩ + putTagN 0 0 (rank + 1 - prevRank) putFusedHint hints prevRank := rank + 1 @@ -2820,7 +2945,7 @@ def putEnv (env : Env) : ExceptT String PutM Unit := do -- Build name index from sorted positions (matching Rust) let nameIdx := sortedNames.zipIdx.foldl (fun acc ((addr, _), i) => acc.insert addr i.toUInt64) {} - putTag0 ⟨sortedNames.size.toUInt64⟩ + putTagN 0 0 sortedNames.size.toUInt64 for (addr, name) in sortedNames do Serialize.put addr putNameComponent name @@ -2832,18 +2957,18 @@ def putEnv (env : Env) : ExceptT String PutM Unit := do -- bodies. `original` keeps a raw address: it can reference an -- assumed constant that is NOT stored in §2 (prune cut bundles). let named := env.named.toList.toArray.qsort fun a b => (compare a.1 b.1).isLT - putTag0 ⟨named.size.toUInt64⟩ + putTagN 0 0 named.size.toUInt64 for (name, namedEntry) in named do -- The name's stored hash is bytewise its §4 component address. match nameIdx.get? name.getHash with | none => throw s!"putEnv: named key {reprStr (toString name.getHash)} \ not present in the name table" - | some i => putTag0 ⟨i⟩ + | some i => putTagN 0 0 i match constIdx.get? namedEntry.addr with | none => throw s!"putEnv: named entry constant \ {reprStr (toString namedEntry.addr)} not present in \ consts — named entries must reference stored constants" - | some rank => putTag0 ⟨rank⟩ + | some rank => putTagN 0 0 rank putFusedOptHint namedEntry.hints -- Metadata blob: ConstantMeta + original as Option (0 = none, -- 1 = some(addr, meta)), length-prefixed. @@ -2855,12 +2980,12 @@ def putEnv (env : Env) : ExceptT String PutM Unit := do putU8 1 Serialize.put origAddr putConstantMetaIndexed origMeta nameIdx - putTag0 ⟨blob.size.toUInt64⟩ + putTagN 0 0 blob.size.toUInt64 putBytes blob -- Section 6: Comms (Address -> Comm) let comms := env.comms.toList.toArray.qsort fun a b => (compare a.1 b.1).isLT - putTag0 ⟨comms.size.toUInt64⟩ + putTagN 0 0 comms.size.toUInt64 for (addr, comm) in comms do Serialize.put addr putComm comm @@ -2872,11 +2997,11 @@ def putEnv (env : Env) : ExceptT String PutM Unit := do returns zero-copy constant windows. -/ def getEnv : GetM Env := do -- Header - let tag ← getTag4 + let tag ← getTagN 4 if tag.flag != FLAG then throw s!"Env.get: expected flag 0x{FLAG.toNat.toDigits 16}, got 0x{tag.flag.toNat.toDigits 16}" - if tag.size != VERSION then - throw s!"Env.get: expected .ixe format version {VERSION}, got {tag.size} — recompile the artifact" + if tag.value != VERSION then + throw s!"Env.get: expected .ixe format version {VERSION}, got {tag.value} — recompile the artifact" -- Canonical merkle root (fixed 32 bytes). For empty const sets the -- stored value is `Ix.Merkle.zeroAddress`. Verified at end against @@ -2892,7 +3017,7 @@ def getEnv : GetM Env := do | 1 => some <$> Serialize.get | x => throw s!"Env.get: invalid main tag {x} in bundle header — \ possibly a pre-bundle-format .ixe; recompile it" - let numAssumptions := (← getTag0).size + let numAssumptions := (← getTagN 0).value let mut assumptionArr : Array Address := #[] for _ in [:numAssumptions.toNat] do let addr : Address ← Serialize.get @@ -2909,10 +3034,10 @@ def getEnv : GetM Env := do -- Section 1: Blobs (hash-verified per entry: a swapped blob would -- otherwise silently change a Nat/String literal's value — the -- consts merkle root covers only constant addresses) - let numBlobs := (← getTag0).size + let numBlobs := (← getTagN 0).value for _ in [:numBlobs.toNat] do let addr ← Serialize.get - let len := (← getTag0).size + let len := (← getTagN 0).value let bytes ← getBytes len.toNat if Address.blake3 bytes != addr then throw s!"Env.get: blob bytes hash mismatch for {reprStr (toString addr)}" @@ -2922,11 +3047,11 @@ def getEnv : GetM Env := do -- Per-entry integrity: bytes must hash to the stored address. The -- file order (strictly ascending addresses — enforced, since §3/§5 -- indices resolve against it) is retained as `constOrder`. - let numConsts := (← getTag0).size + let numConsts := (← getTagN 0).value let mut constOrder : Array Address := #[] for _ in [:numConsts.toNat] do let addr ← Serialize.get - let len := (← getTag0).size + let len := (← getTagN 0).value let bytes ← getBytes len.toNat if Address.blake3 bytes != addr then throw s!"Env.get: const bytes hash mismatch for {reprStr (toString addr)}" @@ -2945,14 +3070,14 @@ def getEnv : GetM Env := do throw s!"Env.get: main {reprStr (toString m)} not present in consts" -- Section 3: anon_hints — delta-coded §2 ranks + fused hints. - let numHints := (← getTag0).size + let numHints := (← getTagN 0).value if numHints.toNat > constOrder.size then throw s!"Env.get: hint count {numHints} exceeds const count \ {constOrder.size} — possibly a pre-compact-keys .ixe; \ recompile it" let mut cursor : Nat := 0 for _ in [:numHints.toNat] do - let delta := (← getTag0).size + let delta := (← getTagN 0).value if delta == 0 then throw "Env.get: zero hint index delta (§3 must be strictly \ ascending) — possibly a pre-compact-keys .ixe; recompile it" @@ -2967,7 +3092,7 @@ def getEnv : GetM Env := do cursor := idx + 1 -- Section 4: Names (build lookup table AND reverse index) - let numNames := (← getTag0).size + let numNames := (← getTagN 0).value let mut namesLookup : Std.HashMap Address Ix.Name := {} let mut nameRev : NameReverseIndex := #[] -- Always include anonymous name @@ -2983,16 +3108,16 @@ def getEnv : GetM Env := do -- entry's constant is a §2 rank; the per-name hint sits in the -- header before the length-prefixed metadata blob; `original` stays -- a raw address) - let numNamed := (← getTag0).size + let numNamed := (← getTagN 0).value for _ in [:numNamed.toNat] do - let nameIdx := (← getTag0).size.toNat + let nameIdx := (← getTagN 0).value.toNat let nameAddr ← match nameRev[nameIdx]? with | some a => pure (a : Address) | none => throw s!"Env.get: §5 name index {nameIdx} out of range \ ({nameRev.size} names) — possibly a pre-compact-keys .ixe; \ recompile it" - let constRank := (← getTag0).size.toNat + let constRank := (← getTagN 0).value.toNat let constAddr ← match constOrder[constRank]? with | some a => pure a | none => @@ -3000,7 +3125,7 @@ def getEnv : GetM Env := do ({constOrder.size} consts) — possibly a pre-compact-keys \ .ixe; recompile it" let hints ← getFusedOptHint - let metaLen := (← getTag0).size.toNat + let metaLen := (← getTagN 0).value.toNat let stBefore ← get if stBefore.bytes.size - stBefore.idx < metaLen then throw s!"Env.get: §5 metadata blob needs {metaLen} bytes, have \ @@ -3032,7 +3157,7 @@ def getEnv : GetM Env := do throw s!"getEnv: named entry references unknown name address {reprStr (toString nameAddr)}" -- Section 6: Comms - let numComms := (← getTag0).size + let numComms := (← getTagN 0).value for _ in [:numComms.toNat] do let addr ← Serialize.get (α := Address) let comm ← getComm @@ -3155,11 +3280,11 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do -- Header (verified as one span; the root's VALUE is verified against -- the recomputed merkle root after §2, exactly as `getEnv` does). let hdrStart := (← get).idx - let tag ← getTag4 + let tag ← getTagN 4 if tag.flag != Env.FLAG then throw s!"Env.get: expected flag 0x{Env.FLAG.toNat.toDigits 16}, got 0x{tag.flag.toNat.toDigits 16}" - if tag.size != Env.VERSION then - throw s!"Env.get: expected .ixe format version {Env.VERSION}, got {tag.size} — recompile the artifact" + if tag.value != Env.VERSION then + throw s!"Env.get: expected .ixe format version {Env.VERSION}, got {tag.value} — recompile the artifact" let storedRoot : Address ← Serialize.get let mainTag ← getU8 let main : Option Address ← match mainTag with @@ -3167,7 +3292,7 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do | 1 => some <$> Serialize.get | x => throw s!"Env.get: invalid main tag {x} in bundle header — \ possibly a pre-bundle-format .ixe; recompile it" - let numAssumptions := (← getTag0).size + let numAssumptions := (← getTagN 0).value let mut assumptionArr : Array Address := #[] for _ in [:numAssumptions.toNat] do let addr : Address ← Serialize.get @@ -3176,12 +3301,12 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do throw "Env.get: assumptions not strictly ascending" assumptionArr := assumptionArr.push addr reserCheck "header" hdrStart <| runPut do - putTag4 ⟨Env.FLAG, Env.VERSION⟩ + putTagN 4 Env.FLAG Env.VERSION Serialize.put storedRoot match main with | none => putU8 0 | some addr => do putU8 1; Serialize.put addr - putTag0 ⟨assumptionArr.size.toUInt64⟩ + putTagN 0 0 assumptionArr.size.toUInt64 for addr in assumptionArr do Serialize.put addr let mut env : Env := { @@ -3192,14 +3317,14 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do -- Section 1: Blobs (hash-verified; ascending order is the writer's -- sort contract, asserted here since no whole-image compare runs). let s1Start := (← get).idx - let numBlobs := (← getTag0).size - reserCheck "§1 count" s1Start <| runPut (putTag0 ⟨numBlobs⟩) + let numBlobs := (← getTagN 0).value + reserCheck "§1 count" s1Start <| runPut (putTagN 0 0 numBlobs) loadTrace s!"header ok; §1 blobs: {numBlobs}" let mut prevBlobAddr : Option Address := none for _ in [:numBlobs.toNat] do let eStart := (← get).idx let addr ← Serialize.get - let len := (← getTag0).size + let len := (← getTagN 0).value let bytes ← getBytes len.toNat if Address.blake3 bytes != addr then throw s!"Env.get: blob bytes hash mismatch for {reprStr (toString addr)}" @@ -3210,22 +3335,22 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do env := { env with blobs := env.blobs.insert addr bytes } reserCheck "§1 blob" eStart <| runPut do Serialize.put addr - putTag0 ⟨bytes.size.toUInt64⟩ + putTagN 0 0 bytes.size.toUInt64 putBytes bytes -- Section 2: Consts. The body is parsed with the pure reader and -- re-serialized with the pure writer (the gate's core), then retained -- only as a zero-copy window. let s2Start := (← get).idx - let numConsts := (← getTag0).size - reserCheck "§2 count" s2Start <| runPut (putTag0 ⟨numConsts⟩) + let numConsts := (← getTagN 0).value + reserCheck "§2 count" s2Start <| runPut (putTagN 0 0 numConsts) loadTrace s!"§2 consts: {numConsts}" let mut constOrder : Array Address := #[] let backing := (← get).bytes for _ in [:numConsts.toNat] do let eStart := (← get).idx let addr ← Serialize.get - let len := (← getTag0).size + let len := (← getTagN 0).value let bodyStart := (← get).idx let bytes ← getBytes len.toNat if Address.blake3 bytes != addr then @@ -3240,7 +3365,7 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do | .ok constant => reserCheck "§2 const" eStart <| runPut do Serialize.put addr - putTag0 ⟨len⟩ + putTagN 0 0 len putBytes (serConstant constant) env := { env with consts := env.consts.insert addr @@ -3254,8 +3379,8 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do -- Section 3: anon_hints (delta-coded §2 ranks; ascending by design). let s3Start := (← get).idx - let numHints := (← getTag0).size - reserCheck "§3 count" s3Start <| runPut (putTag0 ⟨numHints⟩) + let numHints := (← getTagN 0).value + reserCheck "§3 count" s3Start <| runPut (putTagN 0 0 numHints) if numHints.toNat > constOrder.size then throw s!"Env.get: hint count {numHints} exceeds const count \ {constOrder.size} — possibly a pre-compact-keys .ixe; \ @@ -3263,7 +3388,7 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do let mut cursor : Nat := 0 for _ in [:numHints.toNat] do let eStart := (← get).idx - let delta := (← getTag0).size + let delta := (← getTagN 0).value if delta == 0 then throw "Env.get: zero hint index delta (§3 must be strictly \ ascending) — possibly a pre-compact-keys .ixe; recompile it" @@ -3277,14 +3402,14 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do env := { env with anonHints := env.anonHints.insert addr hints } cursor := idx + 1 reserCheck "§3 hint" eStart <| runPut do - putTag0 ⟨delta⟩ + putTagN 0 0 delta putFusedHint hints -- Section 4: Names. Order must equal the writer's topological sort of -- the parsed set (the whole-image compare used to pin this). let s4Start := (← get).idx - let numNames := (← getTag0).size - reserCheck "§4 count" s4Start <| runPut (putTag0 ⟨numNames⟩) + let numNames := (← getTagN 0).value + reserCheck "§4 count" s4Start <| runPut (putTagN 0 0 numNames) loadTrace s!"§3 done; §4 names: {numNames}" let mut namesLookup : Std.HashMap Address Ix.Name := {} let mut nameRev : NameReverseIndex := #[] @@ -3313,22 +3438,22 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do -- Section 5: Named — header fields eager, metadata parsed and -- writer-checked transiently, retained as a window. let s5Start := (← get).idx - let numNamed := (← getTag0).size - reserCheck "§5 count" s5Start <| runPut (putTag0 ⟨numNamed⟩) + let numNamed := (← getTagN 0).value + reserCheck "§5 count" s5Start <| runPut (putTagN 0 0 numNamed) loadTrace s!"§5 named: {numNamed}" let mut namedRows : Array NamedRow := #[] let mut rowIdx : Std.HashMap Ix.Name Nat := {} let mut prevName : Option Ix.Name := none for _ in [:numNamed.toNat] do let eStart := (← get).idx - let nameIdx := (← getTag0).size + let nameIdx := (← getTagN 0).value let nameAddr ← match nameRev[nameIdx.toNat]? with | some a => pure (a : Address) | none => throw s!"Env.get: §5 name index {nameIdx} out of range \ ({nameRev.size} names) — possibly a pre-compact-keys .ixe; \ recompile it" - let constRank := (← getTag0).size + let constRank := (← getTagN 0).value let constAddr ← match constOrder[constRank.toNat]? with | some a => pure a | none => @@ -3336,7 +3461,7 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do ({constOrder.size} consts) — possibly a pre-compact-keys \ .ixe; recompile it" let hints ← getFusedOptHint - let metaLen := (← getTag0).size.toNat + let metaLen := (← getTagN 0).value.toNat let stBefore ← get if stBefore.bytes.size - stBefore.idx < metaLen then throw s!"Env.get: §5 metadata blob needs {metaLen} bytes, have \ @@ -3365,8 +3490,8 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do throw "serde gate (§5): named entries not in ascending name order" prevName := some name reserCheck "§5 named" eStart <| runPut do - putTag0 ⟨nameIdx⟩ - putTag0 ⟨constRank⟩ + putTagN 0 0 nameIdx + putTagN 0 0 constRank putFusedOptHint hints let blob := runPut do putConstantMetaIndexed constMeta fileNameIdx @@ -3376,7 +3501,7 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do putU8 1 Serialize.put origAddr putConstantMetaIndexed origMeta fileNameIdx - putTag0 ⟨blob.size.toUInt64⟩ + putTagN 0 0 blob.size.toUInt64 putBytes blob rowIdx := rowIdx.insert name namedRows.size namedRows := namedRows.push @@ -3388,8 +3513,8 @@ def getEnvVerifiedLazy : GetM LazyEnvParts := do -- Section 6: Comms. let s6Start := (← get).idx - let numComms := (← getTag0).size - reserCheck "§6 count" s6Start <| runPut (putTag0 ⟨numComms⟩) + let numComms := (← getTagN 0).value + reserCheck "§6 count" s6Start <| runPut (putTagN 0 0 numComms) let mut prevCommAddr : Option Address := none for _ in [:numComms.toNat] do let eStart := (← get).idx @@ -3463,16 +3588,16 @@ def envSectionSizes (env : Env) : Nat × Nat × Nat × Nat × Nat × Nat := Id.r -- Blobs section let blobsBytes := runPut do let blobs := env.blobs.toList.toArray.qsort fun a b => (compare a.1 b.1).isLT - putTag0 ⟨blobs.size.toUInt64⟩ + putTagN 0 0 blobs.size.toUInt64 for (addr, bytes) in blobs do Serialize.put addr - putTag0 ⟨bytes.size.toUInt64⟩ + putTagN 0 0 bytes.size.toUInt64 putBytes bytes -- Consts section let constsBytes := runPut do let consts := env.consts.toList.toArray.qsort fun a b => (compare a.1 b.1).isLT - putTag0 ⟨consts.size.toUInt64⟩ + putTagN 0 0 consts.size.toUInt64 for (addr, lc) in consts do Serialize.put addr putBytes lc.rawBytes @@ -3488,18 +3613,18 @@ def envSectionSizes (env : Env) : Nat × Nat × Nat × Nat × Nat × Nat := Id.r let hintsBytes := runPut do let hintPairs := env.anonHints.toList.toArray.qsort fun a b => (compare a.1 b.1).isLT - putTag0 ⟨hintPairs.size.toUInt64⟩ + putTagN 0 0 hintPairs.size.toUInt64 let mut prevRank : UInt64 := 0 for (addr, hints) in hintPairs do let rank := constIdx.get? addr |>.getD 0 - putTag0 ⟨rank + 1 - prevRank⟩ + putTagN 0 0 (rank + 1 - prevRank) putFusedHint hints prevRank := rank + 1 -- Names section let namesBytes := runPut do let sortedNames := Env.topologicalSortNames env.names - putTag0 ⟨sortedNames.size.toUInt64⟩ + putTagN 0 0 sortedNames.size.toUInt64 for (addr, name) in sortedNames do Serialize.put addr Env.putNameComponent name @@ -3513,10 +3638,10 @@ def envSectionSizes (env : Env) : Nat × Nat × Nat × Nat × Nat × Nat := Id.r let nameIdx : NameIndex := sortedNames.zipIdx.foldl (fun acc ((addr, _), i) => acc.insert addr i.toUInt64) {} let named := env.named.toList.toArray.qsort fun a b => (compare a.1 b.1).isLT - putTag0 ⟨named.size.toUInt64⟩ + putTagN 0 0 named.size.toUInt64 for (name, namedEntry) in named do - putTag0 ⟨nameIdx.get? name.getHash |>.getD 0⟩ - putTag0 ⟨constIdx.get? namedEntry.addr |>.getD 0⟩ + putTagN 0 0 (nameIdx.get? name.getHash |>.getD 0) + putTagN 0 0 (constIdx.get? namedEntry.addr |>.getD 0) putFusedOptHint namedEntry.hints let blob := runPut do putConstantMetaIndexed namedEntry.constMeta nameIdx @@ -3526,13 +3651,13 @@ def envSectionSizes (env : Env) : Nat × Nat × Nat × Nat × Nat × Nat := Id.r putU8 1 Serialize.put origAddr putConstantMetaIndexed origMeta nameIdx - putTag0 ⟨blob.size.toUInt64⟩ + putTagN 0 0 blob.size.toUInt64 putBytes blob -- Comms section let commsBytes := runPut do let comms := env.comms.toList.toArray.qsort fun a b => (compare a.1 b.1).isLT - putTag0 ⟨comms.size.toUInt64⟩ + putTagN 0 0 comms.size.toUInt64 for (addr, comm) in comms do Serialize.put addr putComm comm @@ -3780,7 +3905,7 @@ Compute the canonical merkle root over an Ixon env's `consts.keys()` via the Rust implementation. Returns `none` for an empty const set, otherwise the 32-byte root wrapped in `some`. -The same value is stored in the env's on-disk Tag4 header (see +The same value is stored in the env's on-disk TagN header (see `Env::put`/`Env::get` in `src/ix/ixon/serialize.rs`). -/ def rsEnvMerkleRoot (env : Env) : Option Address := diff --git a/Ix/IxonContract.lean b/Ix/IxonContract.lean index 3208ed196..2ac491c15 100644 --- a/Ix/IxonContract.lean +++ b/Ix/IxonContract.lean @@ -161,7 +161,7 @@ def lean (nonDep : Bool) : LetContract := { nonDep } def borrow (nonDep : Bool) (uses : Uses := .many) : LetContract := { nonDep, kind := .borrowShared, binder := ⟨uses, .localShared⟩ } -/-- The existing let Tag4 size holds the dependency and borrow-kind flags. -/ +/-- The let header's TagN value holds the dependency and borrow-kind flags. -/ def flags (c : LetContract) : UInt64 := (if c.nonDep then 1 else 0) ||| (match c.kind with | .value => 0 | .borrowShared => 2) diff --git a/Ix/IxonMode.lean b/Ix/IxonMode.lean index 045a48453..9271d7a76 100644 --- a/Ix/IxonMode.lean +++ b/Ix/IxonMode.lean @@ -4,7 +4,7 @@ public import Ix.Common /-! # Ixon binder modes -Ixon v3 carries independent usage, ownership, and locality contracts. Ordinary +Ixon carries independent usage, ownership, and locality contracts. Ordinary Lean compilation inhabits the conservative fragment: every lambda/forall binder is `.many`, and every forall result is `.shared`. -/ diff --git a/Ix/Resource/Addressed.lean b/Ix/Resource/Addressed.lean index 8060d3cbc..c207d6f15 100644 --- a/Ix/Resource/Addressed.lean +++ b/Ix/Resource/Addressed.lean @@ -18,7 +18,10 @@ namespace Ix.Resource open Ixon -def validatorId : String := "ixon-v3/resource-v1" +/-- The resource validator's identifier, `"ixon-v4/resource-v1"`: the wire +format (`Ixon.wireFormatId`) it reads, so a format version bump moves profile +addresses to a new domain. Mirrors Rust `VALIDATOR_ID`. -/ +def validatorId : String := wireFormatId ++ "/resource-v1" structure Profile where assumptions : Array Address := #[] @@ -53,14 +56,14 @@ Lists are validated before these bytes are used as a commitment. -/ def Profile.bytes (profile : Profile) : ByteArray := (validatorId ++ "/profile\x00").toUTF8 ++ runPut do for addresses in #[profile.assumptions, profile.shareableTypes, profile.choices] do - putTag0 ⟨addresses.size.toUInt64⟩ + putTagN 0 0 addresses.size.toUInt64 for address in addresses do Serialize.put address for address in #[profile.natType, profile.stringType] do match address with | none => putU8 0 | some address => putU8 1; Serialize.put address - putTag0 ⟨profile.limits.depth.toUInt64⟩ - putTag0 ⟨profile.limits.steps.toUInt64⟩ + putTagN 0 0 profile.limits.depth.toUInt64 + putTagN 0 0 profile.limits.steps.toUInt64 def Profile.address (profile : Profile) : Except String Address := do profile.validate @@ -71,7 +74,7 @@ def Profile.ofBytes (bytes : ByteArray) : Except String Profile := do let header := (validatorId ++ "/profile\x00").toUTF8 unless (← getBytes header.size) == header do throw "resource profile: wrong validator identifier" let list : GetM (Array Address) := do - let count := (← getTag0).size.toNat + let count := (← getTagN 0).value.toNat let state ← get if count > (state.bytes.size - state.idx) / 32 then throw "resource profile: impossible address count" let mut result := #[] @@ -87,8 +90,8 @@ def Profile.ofBytes (bytes : ByteArray) : Except String Profile := do let choices ← list let natType ← optional let stringType ← optional - let depth := (← getTag0).size.toNat - let steps := (← getTag0).size.toNat + let depth := (← getTagN 0).value.toNat + let steps := (← getTagN 0).value.toNat return { assumptions, shareableTypes, choices, natType, stringType, limits := { depth, steps } }) bytes profile.validate return profile diff --git a/Ix/Resource/Claim.lean b/Ix/Resource/Claim.lean index 0b7fd2efb..d7ec71fd5 100644 --- a/Ix/Resource/Claim.lean +++ b/Ix/Resource/Claim.lean @@ -3,7 +3,7 @@ module public import Ix.Claim public import Ix.Resource.Validate -/-! A resource claim binds the complete constant set, format v3, +/-! A resource claim binds the complete constant set, format v4, resource-v1 validator, and the canonical policy bytes. -/ @[expose] public section diff --git a/Ix/Resource/Validate.lean b/Ix/Resource/Validate.lean index c668d7286..4f9b1350f 100644 --- a/Ix/Resource/Validate.lean +++ b/Ix/Resource/Validate.lean @@ -4,7 +4,7 @@ public import Ix.Resource.Addressed public import Ix.Tc.Driver /-! The combined native validation boundary. Both validators consume the same -addressed v3 bytes. Kernel typechecking alone has no resource meaning. -/ +addressed v4 bytes. Kernel typechecking alone has no resource meaning. -/ @[expose] public section diff --git a/Ix/SemanticContract.lean b/Ix/SemanticContract.lean index 4ee692adb..a55811b2e 100644 --- a/Ix/SemanticContract.lean +++ b/Ix/SemanticContract.lean @@ -157,24 +157,27 @@ def Contract.ixMetadata (contract : Contract) : Array (Ix.Name × Ix.DataValue) (Ix.Name.mkStr key "code", .ofNat contract.code) ] /-- Read-only presence scan used to reject optional structural rewrites that -would remove contracts, including contracts hidden behind sharing. -/ -def containsIxon (sharing : Array Ixon.Expr) (top : Ixon.Expr) : Except String Bool := do - let mut seen : Std.HashSet Ixon.Expr := {} - let mut stack := #[top] +would remove contracts, including contracts hidden behind sharing. A `share` +node met in index space `scope` is expanded by `resolve`, which returns the +target and the index space the target's own `share` nodes are read in (the +decompiler's primary/metadata share scopes). -/ +def containsIxon {σ ε : Type} [BEq σ] [Hashable σ] [Inhabited σ] + (resolve : σ → UInt64 → Except ε (Ixon.Expr × σ)) (scope : σ) + (top : Ixon.Expr) : Except ε Bool := do + let mut seen : Std.HashSet (Ixon.Expr × σ) := {} + let mut stack := #[(top, scope)] while !stack.isEmpty do - let e := stack.back! + let (e, s) := stack.back! stack := stack.pop - if seen.contains e then continue - seen := seen.insert e + if seen.contains (e, s) then continue + seen := seen.insert (e, s) if (ofIxon? e).isSome then return true match e with - | .share index => - let some value := sharing[index.toNat]? | throw "semantic scan: invalid sharing index" - stack := stack.push value - | .app f a => stack := stack.push f |>.push a - | .lam _ t b | .all _ _ t b => stack := stack.push t |>.push b - | .letE _ t v b => stack := stack.push t |>.push v |>.push b - | .prj _ _ v => stack := stack.push v + | .share index => stack := stack.push (← resolve s index) + | .app f a => stack := stack.push (f, s) |>.push (a, s) + | .lam _ t b | .all _ _ t b => stack := stack.push (t, s) |>.push (b, s) + | .letE _ t v b => stack := stack.push (t, s) |>.push (v, s) |>.push (b, s) + | .prj _ _ v => stack := stack.push (v, s) | _ => pure () return false diff --git a/Ix/Sharing.lean b/Ix/Sharing.lean deleted file mode 100644 index 24b0e6c8d..000000000 --- a/Ix/Sharing.lean +++ /dev/null @@ -1,484 +0,0 @@ -/- - Sharing Analysis for expression deduplication within mutual blocks. - - This module provides alpha-invariant sharing analysis using Merkle-tree hashing. - Expressions that are structurally identical get the same hash, and we decide - which subterms to share based on a profitability heuristic. - - Algorithm: - 1. Post-order traversal with Merkle hashing (blake3) - 2. Count usage of each unique subterm - 3. Profitability: share if (count - 1) * size > count * ref_size - 4. Build sharing vector in topological order (leaves first) - 5. Rewrite expressions with Share(idx) references --/ -module - -public import Ix.Ixon -public import Ix.Address -public import Ix.Common -public import Std.Data.HashMap -public import Blake3.Rust - -public section - -namespace Ix.Sharing - -/-- Convert UInt64 to ByteArray (little-endian, fixed 8 bytes). - This MUST match Rust's `u64.to_le_bytes()` for hash compatibility. -/ -def uint64ToBytes (x : UInt64) : ByteArray := - let arr : Array UInt8 := #[ - (x &&& 0xFF).toUInt8, - ((x >>> 8) &&& 0xFF).toUInt8, - ((x >>> 16) &&& 0xFF).toUInt8, - ((x >>> 24) &&& 0xFF).toUInt8, - ((x >>> 32) &&& 0xFF).toUInt8, - ((x >>> 40) &&& 0xFF).toUInt8, - ((x >>> 48) &&& 0xFF).toUInt8, - ((x >>> 56) &&& 0xFF).toUInt8 - ] - ByteArray.mk arr - -/-- Compute encoded size of Tag0 (variable-length u64). - If value < 128: 1 byte, else 1 + byteCount bytes. - Must match Rust's Tag0::encoded_size(). -/ -def tag0EncodedSize (value : UInt64) : Nat := - if value < 128 then 1 else 1 + value.byteCount.toNat - -/-- Compute encoded size of Tag4 (4-bit flag + variable-length size). - If size < 8: 1 byte, else 1 + byteCount bytes. - Must match Rust's Tag4::encoded_size(). -/ -def tag4EncodedSize (size : UInt64) : Nat := - if size < 8 then 1 else 1 + size.byteCount.toNat - -/-- Canonical scalar/contract bytes, followed by fixed-size child hashes. - This grammar agrees with Rust's structural sharing hash. -/ -def putNodeHeader : Ixon.Expr → Ixon.PutM Unit - | e@(.sort _) | e@(.var _) | e@(.ref ..) | e@(.recur ..) | - e@(.str _) | e@(.nat _) | e@(.share _) => Ixon.putExpr e - | .prj idx field _ => do - Ixon.putTag4 ⟨Ixon.Expr.FLAG_PRJ, field⟩ - Ixon.putTag0 ⟨idx⟩ - | .app .. => Ixon.putTag4 ⟨Ixon.Expr.FLAG_APP, 1⟩ - | .lam contract .. => do - Ixon.putTag4 ⟨Ixon.Expr.FLAG_LAM, 1⟩ - Ixon.putBinderContract contract - | .all contract result .. => do - Ixon.putTag4 ⟨Ixon.Expr.FLAG_ALL, 1⟩ - Ixon.putU8 (Ixon.packAllContract contract result) - | .letE contract .. => do - Ixon.putTag4 ⟨Ixon.Expr.FLAG_LET, contract.flags⟩ - Ixon.putBinderContract contract.binder - -def computeNodeHash (e : Ixon.Expr) (childHashes : Array Address) : Address := - Address.blake3 <| childHashes.foldl (fun bytes h => bytes ++ h.hash) - (Ixon.runPut (putNodeHeader e)) - -/-- Compute the sharing hash of an expression recursively (for testing). - Uses computeNodeHash as the single source of truth. -/ -def computeExprHash (e : Ixon.Expr) : Address := - let childHashes := match e with - | .sort _ | .var _ | .ref _ _ | .recur _ _ | .str _ | .nat _ | .share _ => #[] - | .prj _ _ val => #[computeExprHash val] - | .app fun_ arg => #[computeExprHash fun_, computeExprHash arg] - | .lam _ ty body | .all _ _ ty body => #[computeExprHash ty, computeExprHash body] - | .letE _ ty val body => #[computeExprHash ty, computeExprHash val, computeExprHash body] - computeNodeHash e childHashes - -/-- Information about a subterm for sharing analysis. -/ -structure SubtermInfo where - /-- Base size of this node alone (Tag4 header, not including children) for Ixon format -/ - baseSize : Nat - /-- Number of occurrences within this block -/ - usageCount : Nat - /-- Canonical representative expression -/ - expr : Ixon.Expr - /-- Hashes of child subterms (for topological ordering) -/ - children : Array Address - deriving Inhabited - -/-- Compute the base size of a node (Tag4 header size) for Ixon serialization. -/ -def computeBaseSize (e : Ixon.Expr) : Nat := - (Ixon.runPut (putNodeHeader e)).size - -/-- Get the memory address of an expression for identity-based caching. - This is safe because we only use it within a single analysis pass - where expressions are not modified. -/ -@[inline] -def exprPtr (e : Ixon.Expr) : USize := unsafe ptrAddrUnsafe e - -/-- State for the analysis monad. -/ -structure AnalyzeState where - /-- Map from content hash to subterm info -/ - infoMap : Std.HashMap Address SubtermInfo := {} - /-- Map from expression pointer to its content hash (for O(1) lookup during rewrite) -/ - ptrToHash : Std.HashMap USize Address := {} - /-- Topological order built during traversal (leaves first) -/ - topoOrder : Array Address := #[] - deriving Inhabited - -/-- Analysis monad. -/ -abbrev AnalyzeM := StateM AnalyzeState - -/-- Record a node after its children have been analyzed. -/ -def recordAnalyzedNode (e : Ixon.Expr) (childHashes : Array Address) : AnalyzeM Address := do - let hash := computeNodeHash e childHashes - let ptr := exprPtr e - - -- Add the node to the identity cache. - let st ← get - set { st with ptrToHash := st.ptrToHash.insert ptr hash } - - -- Keep the first representative for each content hash. - let st ← get - if !st.infoMap.contains hash then - let baseSize := computeBaseSize e - set { st with - infoMap := st.infoMap.insert hash { - baseSize - usageCount := 0 - expr := e - children := childHashes - } - topoOrder := st.topoOrder.push hash - } - - return hash - -/-- Hash an expression and its children recursively, returning the content hash. - Phase 1 of the efficient algorithm: builds DAG structure without computing usage counts. - Uses computeNodeHash as the single source of truth for hash computation. -/ -def hashAndAnalyze (e : Ixon.Expr) : AnalyzeM Address := do - -- Check if we've already processed this exact pointer - let st ← get - let ptr := exprPtr e - if let some hash := st.ptrToHash.get? ptr then - -- Already processed - just return the hash (no subtree walk needed) - return hash - - -- Recursively process children first and collect their hashes - let childHashes ← match e with - | .sort _ | .var _ | .ref _ _ | .recur _ _ | .str _ | .nat _ | .share _ => - pure #[] - | .prj _ _ val => - let valHash ← hashAndAnalyze val - pure #[valHash] - | .app fun_ arg => - let funHash ← hashAndAnalyze fun_ - let argHash ← hashAndAnalyze arg - pure #[funHash, argHash] - | .lam _ ty body | .all _ _ ty body => - let tyHash ← hashAndAnalyze ty - let bodyHash ← hashAndAnalyze body - pure #[tyHash, bodyHash] - | .letE _ ty val body => - let tyHash ← hashAndAnalyze ty - let valHash ← hashAndAnalyze val - let bodyHash ← hashAndAnalyze body - pure #[tyHash, valHash, bodyHash] - recordAnalyzedNode e childHashes -termination_by e - -/-- Result of sharing analysis. -/ -structure AnalyzeResult where - /-- Map from content hash to subterm info -/ - infoMap : Std.HashMap Address SubtermInfo - /-- Map from expression pointer to content hash -/ - ptrToHash : Std.HashMap USize Address - /-- Topological order (leaves first) - built during traversal -/ - topoOrder : Array Address - -/-- Analyze each root from left to right, threading the analysis state. -/ -def analyzeExprs (exprs : Array Ixon.Expr) (state : AnalyzeState := {}) : AnalyzeState := - exprs.foldl (init := state) fun state expr => - (hashAndAnalyze expr).run state |>.2 - -/-- Add a usage contribution to a previously analyzed subterm. -/ -def addUsage (infoMap : Std.HashMap Address SubtermInfo) - (hash : Address) (count : Nat) : Std.HashMap Address SubtermInfo := - match infoMap.get? hash with - | some info => - infoMap.insert hash { info with usageCount := info.usageCount + count } - | none => infoMap - -/-- Count one use for every analyzed block root. -/ -def countRootUsages (exprs : Array Ixon.Expr) - (ptrToHash : Std.HashMap USize Address) - (infoMap : Std.HashMap Address SubtermInfo) : Std.HashMap Address SubtermInfo := - exprs.foldl (init := infoMap) fun infoMap expr => - match ptrToHash.get? (exprPtr expr) with - | some hash => addUsage infoMap hash 1 - | none => infoMap - -/-- Propagate one subterm's usage count to each of its children. -/ -def propagateUsage (infoMap : Std.HashMap Address SubtermInfo) - (hash : Address) : Std.HashMap Address SubtermInfo := - match infoMap.get? hash with - | some info => - info.children.foldl (init := infoMap) fun infoMap childHash => - addUsage infoMap childHash info.usageCount - | none => infoMap - -/-- Propagate usages from roots to leaves in reverse topological order. -/ -def propagateUsageCounts (topoOrder : Array Address) - (infoMap : Std.HashMap Address SubtermInfo) : Std.HashMap Address SubtermInfo := - topoOrder.reverse.foldl (init := infoMap) propagateUsage - -/-- Analyze expressions for sharing opportunities within a block. - Uses a two-phase O(n) algorithm: - 1. Build DAG structure via post-order traversal with Merkle-tree hashing - 2. Propagate usage counts structurally from roots to leaves - Returns AnalyzeResult with infoMap, ptrToHash, and topoOrder. -/ -def analyzeBlock (exprs : Array Ixon.Expr) : AnalyzeResult := - -- Phase 1: Build DAG structure - let st := analyzeExprs exprs - - -- Phase 2: Propagate usage counts structurally from roots to leaves - -- This is O(n) total - no subtree walks needed - let infoMap := countRootUsages exprs st.ptrToHash st.infoMap - let infoMap := propagateUsageCounts st.topoOrder infoMap - { infoMap, ptrToHash := st.ptrToHash, topoOrder := st.topoOrder } - -/-- Visit state for topological sort. -/ -inductive VisitState where - | inProgress - | done - -/-- Topological sort of subterms (leaves first, parents last). - CRITICAL: Keys are sorted by hash bytes for deterministic output. - This ensures Lean and Rust produce the same topological order. -/ -partial def topologicalSort (infoMap : Std.HashMap Address SubtermInfo) : Array Address := Id.run do - let mut state : Std.HashMap Address VisitState := {} - let mut result : Array Address := #[] - - -- Sort keys deterministically by hash bytes (lexicographic comparison) - let sortedKeys := infoMap.toArray.map (·.1) |>.qsort fun a b => - a.hash.data < b.hash.data - - for hash in sortedKeys do - (state, result) := visit hash infoMap state result - - result -where - visit (hash : Address) (infoMap : Std.HashMap Address SubtermInfo) - (state : Std.HashMap Address VisitState) (result : Array Address) - : Std.HashMap Address VisitState × Array Address := Id.run do - let mut state := state - let mut result := result - - match state.get? hash with - | some .done => return (state, result) - | some .inProgress => return (state, result) -- Cycle (shouldn't happen) - | none => pure () - - state := state.insert hash .inProgress - - if let some info := infoMap.get? hash then - for child in info.children do - (state, result) := visit child infoMap state result - - state := state.insert hash .done - result := result.push hash - (state, result) - -/-- Compute effective sizes for all subterms in topological order. - Returns a map from hash to effective size (total serialized bytes). -/ -def computeEffectiveSizes (infoMap : Std.HashMap Address SubtermInfo) - (topoOrder : Array Address) : Std.HashMap Address Nat := Id.run do - let mut sizes : Std.HashMap Address Nat := {} - - for hash in topoOrder do - if let some info := infoMap.get? hash then - let mut size := info.baseSize - for childHash in info.children do - size := size + sizes.getD childHash 0 - sizes := sizes.insert hash size - - sizes - -/-- Compute the encoded size of a Share(idx) tag. -/ -def shareRefSize (idx : Nat) : Nat := - let idx64 := idx.toUInt64 - if idx64 < 8 then 1 else 1 + idx64.byteCount.toNat - -/-- Candidate for sharing: (hash, term_size, usage_count, potential_savings). -/ -structure SharingCandidate where - hash : Address - termSize : Nat - usageCount : Nat - potential : _root_.Int -- (N-1) * size - N (assuming ref_size=1) - deriving Inhabited - -/-- Decide which subterms to share based on profitability. - - Sharing is profitable when: (N - 1) * term_size > N * share_ref_size - where N is usage count, term_size is effective size, and share_ref_size - is the size of a Share(idx) reference at the current index. - - Returns a set of hashes to share. -/ -def decideSharing (infoMap : Std.HashMap Address SubtermInfo) - (topoOrder : Array Address) : Array Address := Id.run do - let effectiveSizes := computeEffectiveSizes infoMap topoOrder - - -- Pre-filter and collect candidates - let mut candidates : Array SharingCandidate := #[] - for (hash, info) in infoMap do - if info.usageCount < 2 then continue - let termSize := effectiveSizes.getD hash 0 - let n := info.usageCount - -- Potential savings assuming ref_size = 1 (minimum) - let potential : _root_.Int := (n - 1 : _root_.Int) * termSize - n - if potential > 0 then - candidates := candidates.push { hash, termSize, usageCount := n, potential } - - -- Sort by decreasing gross benefit ((n-1) * size), with hash bytes as tie-breaker - -- NOTE: Rust sorts by gross benefit, not net potential. Hash tie-breaker ensures determinism. - candidates := candidates.qsort fun a b => - let grossA := (a.usageCount - 1) * a.termSize - let grossB := (b.usageCount - 1) * b.termSize - if grossA != grossB then grossA > grossB - else a.hash.hash.data < b.hash.hash.data -- lexicographic tie-breaker - - let mut shared : Array Address := #[] - - -- Process ALL candidates - don't break early! - for cand in candidates do - let nextIdx := shared.size - let nextRefSize := shareRefSize nextIdx - let n := cand.usageCount - let savings : _root_.Int := (n - 1 : _root_.Int) * cand.termSize - n * nextRefSize - if savings > 0 then - shared := shared.push cand.hash - - shared - -/-- Rewrite an expression tree to use `Share(idx)` references. Sharing -decisions still use the pointer-to-hash table produced by analysis, but the -rewrite itself is structurally recursive and proof-visible. Reconstructing -unchanged nodes affects allocation only; serialized output is unchanged. -/ -def rewriteWithSharing (e : Ixon.Expr) - (hashToIdx : Std.HashMap Address Nat) - (ptrToHash : Std.HashMap USize Address) : Ixon.Expr := - match (ptrToHash.get? (exprPtr e)).bind (hashToIdx.get? ·) with - | some idx => .share idx.toUInt64 - | none => - match e with - | .sort _ | .var _ | .ref _ _ | .recur _ _ | .str _ | .nat _ | .share _ => e - | .prj typeRefIdx fieldIdx value => - .prj typeRefIdx fieldIdx - (rewriteWithSharing value hashToIdx ptrToHash) - | .app fn arg => - .app (rewriteWithSharing fn hashToIdx ptrToHash) - (rewriteWithSharing arg hashToIdx ptrToHash) - | .lam uses ty body => - .lam uses (rewriteWithSharing ty hashToIdx ptrToHash) - (rewriteWithSharing body hashToIdx ptrToHash) - | .all uses owned ty body => - .all uses owned (rewriteWithSharing ty hashToIdx ptrToHash) - (rewriteWithSharing body hashToIdx ptrToHash) - | .letE nonDep ty value body => - .letE nonDep (rewriteWithSharing ty hashToIdx ptrToHash) - (rewriteWithSharing value hashToIdx ptrToHash) - (rewriteWithSharing body hashToIdx ptrToHash) - -termination_by e - -/-- State threaded while sharing-vector entries are built. -/ -structure SharingBuildState where - sharingVec : Array Ixon.Expr := #[] - hashToIdx : Std.HashMap Address Nat := {} - -/-- Add one available representative to the sharing vector. -/ -def addSharingEntry (infoMap : Std.HashMap Address SubtermInfo) - (ptrToHash : Std.HashMap USize Address) (state : SharingBuildState) - (hash : Address) : SharingBuildState := - match infoMap.get? hash with - | some info => - let rewritten := rewriteWithSharing info.expr state.hashToIdx ptrToHash - let idx := state.sharingVec.size - { sharingVec := state.sharingVec.push rewritten - hashToIdx := state.hashToIdx.insert hash idx } - | none => state - -/-- Build selected sharing entries from left to right. -/ -def buildSharingEntries (hashes : Array Address) - (infoMap : Std.HashMap Address SubtermInfo) - (ptrToHash : Std.HashMap USize Address) : SharingBuildState := - hashes.foldl (init := {}) (addSharingEntry infoMap ptrToHash) - -/-- Rewrite block roots using every sharing entry built so far. -/ -def rewriteExprs (exprs : Array Ixon.Expr) - (hashToIdx : Std.HashMap Address Nat) - (ptrToHash : Std.HashMap USize Address) : Array Ixon.Expr := - exprs.map fun expr => rewriteWithSharing expr hashToIdx ptrToHash - -/-- Rewrite expressions to use Share(idx) references for shared subterms. - - Returns the rewritten expressions and the sharing vector. - The sharing vector is sorted in topological order (leaves first). -/ -def buildSharingVec (exprs : Array Ixon.Expr) (sharedHashes : Array Address) - (infoMap : Std.HashMap Address SubtermInfo) - (ptrToHash : Std.HashMap USize Address) : Array Ixon.Expr × Array Ixon.Expr := - - -- CRITICAL: Re-sort shared_hashes in topological order (leaves first). - -- Use topologicalSort instead of filtering topoOrder from traversal. - -- This ensures deterministic ordering by sorting keys by hash bytes. - let topoOrder := topologicalSort infoMap - let sharedSet : Std.HashMap Address Unit := sharedHashes.foldl (init := {}) fun s h => s.insert h () - let sharedInTopoOrder : Array Address := topoOrder.filter fun h => sharedSet.contains h - - -- Build sharing vector incrementally to avoid forward references - let state := buildSharingEntries sharedInTopoOrder infoMap ptrToHash - - -- Rewrite the root expressions (can use all Share indices) - let rewrittenExprs := rewriteExprs exprs state.hashToIdx ptrToHash - - (rewrittenExprs, state.sharingVec) - -/-- Select the empty or nonempty sharing result after analysis and -profitability decisions have completed. -/ -def finishSharing (exprs : Array Ixon.Expr) (result : AnalyzeResult) - (sharedHashes : Array Address) : Array Ixon.Expr × Array Ixon.Expr := - if sharedHashes.isEmpty then - (exprs, #[]) - else - let built := - buildSharingVec exprs sharedHashes result.infoMap result.ptrToHash - if built.2.size < UInt64.size then built else (exprs, #[]) - -/-- Emit sharing diagnostics before returning an already computed plan. -/ -def finishSharingWithTrace (exprs : Array Ixon.Expr) (result : AnalyzeResult) - (sharedHashes : Array Address) : Array Ixon.Expr × Array Ixon.Expr := Id.run do - dbg_trace s!"[Sharing] analyzed {exprs.size} exprs, found {result.infoMap.size} unique subterms, {sharedHashes.size} to share" - dbg_trace s!"[Sharing] ptrToHash has {result.ptrToHash.size} entries" - -- Debug: show usage counts for all subterms with usage >= 2 - let effectiveSizes := computeEffectiveSizes result.infoMap result.topoOrder - for (hash, info) in result.infoMap do - if info.usageCount >= 2 then - let size := effectiveSizes.getD hash 0 - let potential : _root_.Int := - (info.usageCount - 1 : _root_.Int) * size - info.usageCount - dbg_trace s!" usage={info.usageCount} size={size} potential={potential} expr={repr info.expr}" - return finishSharing exprs result sharedHashes - -/-- Analyze, select, and construct sharing without diagnostic output. -/ -def applySharingCore (exprs : Array Ixon.Expr) : - Array Ixon.Expr × Array Ixon.Expr := - let result := analyzeBlock exprs - let sharedHashes := decideSharing result.infoMap result.topoOrder - finishSharing exprs result sharedHashes - -/-- Apply sharing analysis to a set of expressions. - Returns (rewritten_exprs, sharing_vector). -/ -def applySharing (exprs : Array Ixon.Expr) (dbg : Bool := false) : - Array Ixon.Expr × Array Ixon.Expr := - if dbg then - let result := analyzeBlock exprs - let sharedHashes := decideSharing result.infoMap result.topoOrder - finishSharingWithTrace exprs result sharedHashes - else - applySharingCore exprs - -end Ix.Sharing - -end diff --git a/Ix/Sharing/Exact.lean b/Ix/Sharing/Exact.lean new file mode 100644 index 000000000..2df24d235 --- /dev/null +++ b/Ix/Sharing/Exact.lean @@ -0,0 +1,278 @@ +/- + Sharing tables of anonymous Ixon constants: the canonical construction and + its reference searches (`docs/sharing-minimum.md`). + + The compiler shares every block with the tiered canonical construction + `canonicalSharingTiered` (`Exact.Tiered`; Rust + `ixon::sharing_exact::canonical_sharing_tiered`): phase 1 is the exact + uniform-width optimizer (`Exact.Uniform`) at widths 1, 2 and 3, phase 2 + allocates the table slots, phase 3 re-materializes every part under the + real TagN widths, and the candidate with the fewest bytes wins. + + The global exact minimum of `docs/sharing-minimum.md` §3 is computed by the + width-state search (`optimizeSharing`, `normalizeConstantSharing`, + `Exact.Search`): for a resolved Constant, the feasible backward-reference + encoding with the least key + + (complete serialized length, table structural-ID vector, bytes) + + over all table choices, table orders and per-occurrence inline/reference + choices, with every non-sharing field, the refs and univs tables and the + ordered roots fixed. Only strictly backward table references are feasible + (entry `i` may use entries `< i`, roots may use every entry); forward and + self references are rejected rather than optimized over. The search is + exponential in the candidates: it is a test oracle for small inputs, not + the compiler path. + + Every operation is pure over Ixon data (no Lean frontend) and returns an + explicit error instead of an uncertified result. Resource limits may turn a + success into `resourceExhausted`, but never change a successful result. + + Modules. A specification module defines what the theorems + (`Ix.Compile.Verify`) describe; a fast twin holds a faster body proved equal + to a specification for every input by a `@[csimp]` theorem `@f = @fFast`, + so compiled code runs the twin while every theorem keeps talking about the + specification. All 19 csimp theorems are audit roots + (`Ix.Compile.Verify.Audit.CompiledCode` fails the build otherwise), and a + twin that drifts from its specification breaks its equality proof. + + Specifications (with the csimp theorems declared in the same module): + * `Exact.Basic` exact serializer lengths, node alphabet, errors, limits + (`tagNByteWidth_eq_fast`) + * `Exact.Dag` bounded share expansion, structural IDs, root API + (`propagateCounts_eq_fast`) + * `Exact.Dictionary` fixed-dictionary optimizer `C_M` and materialization + (`build_eq_fast`, `inlineCost_eq_fast`) + * `Exact.Search` width-state search for the global minimum (test oracle), + and the table materialization the construction uses + (`materializeTable_eq_fast`, whose fast body walks + `Exact.Phase3`) + * `Exact.UniformSearch` graph facts, classes, components and the + per-component exact search of the uniform optimizer + (`SCtx.phiE_eq_fast`) + * `Exact.Uniform` exact optimizer for a uniform Share width (phase 1) + (`searchComponents_eq_via`, `csBase_eq_fast`) + * `Exact.Tiered` the canonical tiered construction (TagN layout) + + Fast twins (the csimp theorem; the specification it replaces): + * `Exact.Phase3` re-evaluation after one dictionary change by a walk up + the parent lists (proved equal to `evalUp`; used by + the fast `materializeTable`) + * `Exact.Reexpand` re-expansion without hashing whole nodes + (`reexpand_eq_fast`; `reexpand`) + * `Exact.UniformSearchLocal` the component search on the components' areas + and closures (`searchComponentsWith_eq_fast`; the loop + of `searchComponents`) + * `Exact.TierFast` the first-tier search with a derived excluded set + (`firstTier_eq_fast`; `firstTier`) + * `Exact.PinnedDeps` nearest stored descendants with one stamp array + (`pinnedDeps_eq_fast`; `pinnedDeps`) + * `Exact.PinnedFast` the pinned table order with a priority set of ready + terms (`pinnedOrder_eq_fast`; `pinnedOrder`) + * `Exact.KnapsackFast` the rank-based table-count knapsack + (`uniformKnapsack_eq_fast`; `uniformKnapsack`) + * `Exact.TieredFast` recompiled copies of `allocate`, `tieredAtWidth`, + `canonicalTieredCore`, `canonicalTieredExpanded` and + `optimizeUniformExpanded` (`*_eq_C`), so their callers + reach the fast parts above (a csimp applies only to + code compiled after it) + + Shared helpers and oracles: + * `Exact.SortedSets` ascending lists as sets: first differences, the tie + order, range minima (sparse table) + * `Exact.Oracle` tiny exhaustive reference search (test oracle) + + Names of twins: `fFast` is a fast twin attached by `f_eq_fast`; `fC` is a + recompiled copy attached by `f_eq_C` (`Exact.TieredFast`); `fF` and `fP` + take precomputed tables (`Prep`, graph facts) as arguments and are proved + equal by unfolding (`f_eq_F`, `rematerialize_eq_P`); `fL` is the area- and + closure-local form of a uniform-search step; `searchComponentsVia` is + `searchComponents` written as `searchComponentsWith` on the stage's tables, + so that compiled code reaches `searchComponentsWithFast`. +-/ +module + +public import Ix.Sharing.Exact.Basic +public import Ix.Sharing.Exact.Dag +public import Ix.Sharing.Exact.Dictionary +public import Ix.Sharing.Exact.Search +public import Ix.Sharing.Exact.Oracle +public import Ix.Sharing.Exact.Uniform +public import Ix.Sharing.Exact.Tiered +public import Ix.Sharing.Exact.TieredFast + +public section + +namespace Ix.Sharing.Exact + +open Ixon + +/-- Exact minimum sharing of expanded (Share-free) roots: the width-state +search, a test oracle (the compiler path is `canonicalSharingTiered`). A +`Share` leaf in the input is an error. -/ +def optimizeSharing (roots : Array Ixon.Expr) (limits : Limits := {}) : + Except SharingError ExactSharingResult := do + let ex ← expand limits #[] roots false + optimizeExpanded limits ex + +/-- Exact minimum sharing (test oracle, `optimizeSharing`) of roots given with +an existing sharing table, which is first expanded logically (backward +references only). -/ +def optimizeSharingTable (sharing roots : Array Ixon.Expr) (limits : Limits := {}) : + Except SharingError ExactSharingResult := do + let ex ← expand limits sharing roots true + optimizeExpanded limits ex + +/-- The Share-free equivalent of a Constant: roots expanded (with pointer +sharing, no occurrence-tree allocation) and an empty table. -/ +def expandConstantSharing (c : Constant) (limits : Limits := {}) : + Except SharingError Constant := do + let ex ← expand limits c.sharing (constantInfoRoots c.info) true + let exprs := ex.dag.toExprs + let info ← withRoots c.info (ex.roots.map (exprs[·]!)) + return { c with info, sharing := #[] } + +/-- The exact-minimum sharing of a Constant (test oracle, `optimizeSharing`): +expand its table, optimize, and reassemble the same ConstantInfo, refs and +univs. -/ +def normalizeConstantSharing (c : Constant) (limits : Limits := {}) : + Except SharingError Constant := do + let r ← optimizeSharingTable c.sharing (constantInfoRoots c.info) limits + let info ← withRoots c.info r.roots + return { c with info, sharing := r.sharing } + +/-- Outcome of `checkExactMinimum` (Rust `ExactMinimumCheck`). -/ +inductive ExactMinimumCheck where + /-- The Constant is its exact-minimum encoding. -/ + | minimum + /-- The exact-minimum serialized Constant differs; here are its bytes. -/ + | notMinimum (expected : ByteArray) + deriving Inhabited + +/-- Whether `c` is byte-identical to its exact-minimum sharing: a check +against the test oracle `normalizeConstantSharing`, not against the +compiler's canonical construction (`canonicalSharingTiered`). Rust +`check_exact_minimum`. -/ +def checkExactMinimum (c : Constant) (limits : Limits := {}) : + Except SharingError ExactMinimumCheck := do + let n ← normalizeConstantSharing c limits + let expected := serConstant n + return if serConstant c == expected then .minimum else .notMinimum expected + +/-- Bytes of `c`'s serialization that do not depend on sharing: everything +except the expression roots, the sharing count and the table bodies. Then +`(serConstant c).size = fixedConstantBytes c + Σ exprSize roots ++ tag0Size c.sharing.size + Σ exprSize c.sharing`. -/ +def fixedConstantBytes (c : Constant) : Nat := + let roots := constantInfoRoots c.info + let info := mapRoots (fun _ => Ixon.Expr.var 0) c.info + (serConstant { c with info, sharing := #[] }).size - roots.size - tag0Size 0 + +/-- Size profile of a Constant's sharing problem, without running the search +(for corpus measurements). All byte counts are variable bytes: roots, table +count and table bodies. -/ +structure SharingProfile where + /-- Distinct subterms of the expanded roots (`N`). -/ + distinctSubterms : Nat + /-- Subterms with at least two logical occurrences. -/ + repeated : Nat + /-- Search candidates after R1 and R2. -/ + candidates : Nat + /-- Height of the expanded DAG. -/ + height : Nat + /-- Variable bytes of the unshared encoding. -/ + unsharedBytes : Nat + /-- Variable bytes of the input encoding as stored. -/ + inputBytes : Nat + deriving Repr, Inhabited + +/-- Expand `c` and report its sharing-problem profile. -/ +def sharingProfile (c : Constant) (limits : Limits := {}) : + Except SharingError SharingProfile := do + let roots := constantInfoRoots c.info + let ex ← expand limits c.sharing roots true + let p := Prep.ofDag ex.dag + let occ := occurrences ex.dag ex.roots + let unshared := tag0Size 0 + rootsCost p.base ex.roots + return { + distinctSubterms := ex.dag.size + repeated := (occ.filter (· ≥ 2)).size + candidates := (candidateTerms p occ).size + height := (nodeHeights ex.dag.nodes).foldl max 0 + unsharedBytes := unshared + inputBytes := tag0Size c.sharing.size + exprsSize c.sharing + exprsSize roots } + +/-- Writer of complete candidate Constants for the oracle. -/ +def constantWriter (c : Constant) (sharing roots : Array Ixon.Expr) : + Except SharingError ByteArray := do + let info ← withRoots c.info roots + return serConstant { c with info, sharing } + +/-- Run the exhaustive oracle (`product := true` for the full Cartesian +product) on a Constant and return the oracle's canonical Constant. -/ +def oracleConstant (c : Constant) (limits : Limits := {}) (product : Bool := false) : + Except SharingError (Constant × OracleResult) := do + let ex ← expand limits c.sharing (constantInfoRoots c.info) true + let r ← (if product then oracleProduct else oracle) ex.dag ex.roots (constantWriter c) limits + let info ← withRoots c.info r.roots + return ({ c with info, sharing := r.sharing }, r) + +/-! ## Uniform Share width -/ + +/-- Exact minimum sharing of Share-free roots when every Share costs `w` +bytes (see `Exact.Uniform`). `result.modelBytes` is the minimum model +length; `result.variableBytes` is the real serialized length of the output. -/ +def optimizeSharingUniform (w : Nat) (roots : Array Ixon.Expr) (limits : Limits := {}) : + Except SharingError UniformSharingResult := do + let ex ← expand limits #[] roots false + optimizeUniformExpanded w limits ex + +/-- `optimizeSharingUniform` for roots given with an existing sharing table. -/ +def optimizeSharingUniformTable (w : Nat) (sharing roots : Array Ixon.Expr) + (limits : Limits := {}) : Except SharingError UniformSharingResult := do + let ex ← expand limits sharing roots true + optimizeUniformExpanded w limits ex + +/-- Re-share a Constant with the uniform-width optimum. -/ +def normalizeConstantSharingUniform (w : Nat) (c : Constant) (limits : Limits := {}) : + Except SharingError Constant := do + let r ← optimizeSharingUniformTable w c.sharing (constantInfoRoots c.info) limits + let info ← withRoots c.info r.result.roots + return { c with info, sharing := r.result.sharing } + +/-- Reference for the uniform model: the width-state search with every Share +priced `w` (exponential in the candidates; for tests). With `minInDegree2` +it searches the same candidate space as the uniform optimizer. -/ +def optimizeSharingUniformReference (w : Nat) (roots : Array Ixon.Expr) + (limits : Limits := {}) (minInDegree2 : Bool := false) : + Except SharingError ExactSharingResult := do + let ex ← expand limits #[] roots false + optimizeExpanded limits ex (some w) minInDegree2 + +/-! ## Tiered construction -/ + +/-- Tiered canonical sharing of Share-free roots under a Share layout: the +fewest final layout bytes over the phase-1 widths 1, 2, 3 (see +`Exact.Tiered` for the claim of each phase). This is the compiler's sharing +(`Ix.CompileM.buildConstantWithSharing`). -/ +def canonicalSharingTiered (layout : ShareLayout) (roots : Array Ixon.Expr) + (limits : Limits := {}) : Except SharingError TieredSharingResult := do + let ex ← expand limits #[] roots false + canonicalTieredExpanded layout limits ex + +/-- `canonicalSharingTiered` for roots given with an existing sharing table. -/ +def canonicalSharingTieredTable (layout : ShareLayout) (sharing roots : Array Ixon.Expr) + (limits : Limits := {}) : Except SharingError TieredSharingResult := do + let ex ← expand limits sharing roots true + canonicalTieredExpanded layout limits ex + +/-- Re-share a Constant with the tiered construction. -/ +def normalizeConstantSharingTiered (layout : ShareLayout) (c : Constant) + (limits : Limits := {}) : Except SharingError Constant := do + let r ← canonicalSharingTieredTable layout c.sharing (constantInfoRoots c.info) limits + let info ← withRoots c.info r.result.roots + return { c with info, sharing := r.result.sharing } + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/Basic.lean b/Ix/Sharing/Exact/Basic.lean new file mode 100644 index 000000000..75e074b92 --- /dev/null +++ b/Ix/Sharing/Exact/Basic.lean @@ -0,0 +1,532 @@ +/- + Exact minimum sharing: shared vocabulary. + + This file fixes the pieces every other part of the exact optimizer uses: + + * exact serializer lengths for the Ixon TagN integers (`tag0Size` for + `f = 0`, `tag4Size` for `f = 4`) and for complete expressions + (`exprSize`), mirroring `Ixon.putTagN` and `Ixon.putExpr` byte for byte; + * the structural node alphabet (`Head`, `Node`) and the §3.2 key order; + * unsigned byte-lexicographic comparison; + * errors, resource limits and deterministic work counters. + + Everything is pure Ixon data. Costs are `Nat`; values that must be written + as a `UInt64` are checked against `2^64` before conversion. +-/ +module + +public import Ix.Ixon +import all Ix.Ixon +public import Std.Data.HashMap + +public section + +namespace Ix.Sharing.Exact + +open Ixon + +/-- The memory address of an expression, for pointer-identity caches within +one pass over expressions that are not modified meanwhile. -/ +@[inline] +def exprPtr (e : Ixon.Expr) : USize := unsafe ptrAddrUnsafe e + +/-! ## Unsigned integer widths -/ + +/-- `Ixon.tagNByteWidth` with the rung ends of the two flags used here +(`f = 0`, `f = 4`) as literals; the general case is the definition. The +definition computes the rung ends with `Nat.pow` on every call, so compiled +code runs this instead (`tagNByteWidth_eq_fast`). -/ +def tagNByteWidthFast (f value : Nat) : Nat := + if f = 4 then + if value < 8 then 1 + else if value < 1032 then 2 + else if value < 66568 then 3 + else if value < 16843784 then 4 + else if value < 4311811080 then 5 + else 9 + else if f = 0 then + if value < 128 then 1 + else if value < 16512 then 2 + else if value < 82048 then 3 + else if value < 16859264 then 4 + else if value < 4311826560 then 5 + else 9 + else Ixon.tagNByteWidth f value + +@[csimp] theorem tagNByteWidth_eq_fast : @Ixon.tagNByteWidth = @tagNByteWidthFast := by + funext f value + unfold tagNByteWidthFast + split + · subst f; rfl + · split + · subst f; rfl + · rfl + +/-- Exact byte length of `Ixon.putTagN 0 0 n`, for `n < 2^64`: 1, 2, 3, 4, 5 or 9 +(`Ixon.tagNByteWidth 0`). -/ +def tag0Size (n : Nat) : Nat := Ixon.tagNByteWidth 0 n + +/-- Exact byte length of `Ixon.putTagN 4 flag n`, for `n < 2^64` (independent of +the flag): 1, 2, 3, 4, 5 or 9 (`Ixon.tagNByteWidth 4`). -/ +def tag4Size (n : Nat) : Nat := Ixon.tagNByteWidth 4 n + +/-- Width in bytes of `Share(idx)` (`Ixon.putTagN 4 0xB idx`): 1 byte below +index 8, 2 below 1032, 3 below 66568, 4 below 16843784, 5 below 4311811080, +then 9. -/ +def shareWidth (idx : Nat) : Nat := tag4Size idx + +/-- Values written through a `UInt64` wire field must be below this bound. -/ +def wordBound : Nat := UInt64.size + +/-- `f` applied to the state at `k, k + 1, …, k + i - 1` in order (a +tail-recursive counted loop). -/ +@[specialize] def foldRange {σ : Type} (f : σ → Nat → σ) : Nat → Nat → σ → σ + | _, 0, st => st + | k, i + 1, st => foldRange f (k + 1) i (f st k) + + +/-! ## Wire representability -/ + +/-- The telescope counts at the top of an expression (`App` arguments, +`Lam` binders, `All` binders), provided every `UInt64` count the expression +codec writes in it is representable (the public `wireWF` domain); `none` +otherwise. Linear in the expression. -/ +def wireCounts : Ixon.Expr → Option (Nat × Nat × Nat) + | .sort _ | .var _ | .str _ | .nat _ | .share _ => some (0, 0, 0) + | .ref _ us | .recur _ us => if us.size < UInt64.size then some (0, 0, 0) else none + | .prj _ _ v => (wireCounts v).map fun _ => (0, 0, 0) + | .app f a => + match wireCounts f, wireCounts a with + | some (n, _, _), some _ => if n + 1 < UInt64.size then some (n + 1, 0, 0) else none + | _, _ => none + | .lam _ ty b => + match wireCounts ty, wireCounts b with + | some _, some (_, n, _) => if n + 1 < UInt64.size then some (0, n + 1, 0) else none + | _, _ => none + | .all _ _ ty b => + match wireCounts ty, wireCounts b with + | some _, some (_, _, n) => if n + 1 < UInt64.size then some (0, 0, n + 1) else none + | _, _ => none + | .letE _ ty v b => + match wireCounts ty, wireCounts v, wireCounts b with + | some _, some _, some _ => some (0, 0, 0) + | _, _, _ => none + +/-! ## Exact expression length -/ + +/-- Size facts about one expression, computed bottom-up. `full` is the +standalone serialized length. For a telescope family `appCont` (resp. +`lamCont`, `allCont`) is `(n, b)`: if the expression is a node of that +family, `n` is the number of nodes in its maximal same-family spine and `b` +the spine's bytes excluding the one TagN header; otherwise `(0, full)`. -/ +structure SizeInfo where + full : Nat + appCont : Nat × Nat + lamCont : Nat × Nat + allCont : Nat × Nat + deriving Repr, Inhabited + +/-- Size facts of a node that continues no telescope. -/ +def SizeInfo.plain (n : Nat) : SizeInfo := ⟨n, (0, n), (0, n), (0, n)⟩ + +/-- Sum of the TagN (`f = 0`) lengths of universe indices. -/ +def univIdxsSize (us : Array UInt64) : Nat := + us.foldl (fun acc u => acc + tag0Size u.toNat) 0 + +/-- Size facts of an Ixon expression (which may contain `Share` leaves), with +`Share(i)` priced `shareCost i`. Structurally recursive; mirrors the +maximal-telescope rule of `putExpr`. -/ +def sizeInfoWith (shareCost : Nat → Nat) : Ixon.Expr → SizeInfo + | .sort i => .plain (tag4Size i.toNat) + | .var i => .plain (tag4Size i.toNat) + | .ref r us => .plain (tag4Size us.size + tag0Size r.toNat + univIdxsSize us) + | .recur r us => .plain (tag4Size us.size + tag0Size r.toNat + univIdxsSize us) + | .prj t f v => .plain (tag4Size f.toNat + tag0Size t.toNat + (sizeInfoWith shareCost v).full) + | .str i => .plain (tag4Size i.toNat) + | .nat i => .plain (tag4Size i.toNat) + | .app f a => + let (n, b) := (sizeInfoWith shareCost f).appCont + let n' := n + 1 + let b' := b + (sizeInfoWith shareCost a).full + let full := tag4Size n' + b' + ⟨full, (n', b'), (0, full), (0, full)⟩ + | .lam _ ty body => + let (n, b) := (sizeInfoWith shareCost body).lamCont + let n' := n + 1 + let b' := 1 + (sizeInfoWith shareCost ty).full + b + let full := tag4Size n' + b' + ⟨full, (0, full), (n', b'), (0, full)⟩ + | .all _ _ ty body => + let (n, b) := (sizeInfoWith shareCost body).allCont + let n' := n + 1 + let b' := 1 + (sizeInfoWith shareCost ty).full + b + let full := tag4Size n' + b' + ⟨full, (0, full), (0, full), (n', b')⟩ + | .letE c ty v body => + .plain (tag4Size c.flags.toNat + 1 + (sizeInfoWith shareCost ty).full + (sizeInfoWith shareCost v).full + + (sizeInfoWith shareCost body).full) + | .share i => .plain (shareCost i.toNat) + +/-- Size facts with the real `Share` widths. -/ +def sizeInfo : Ixon.Expr → SizeInfo := sizeInfoWith tag4Size + +/-- Exact byte length of `Ixon.runPut (Ixon.putExpr e)` whenever every +telescope count and payload is below `2^64` (the codec `wireWF` domain). -/ +def exprSize (e : Ixon.Expr) : Nat := (sizeInfo e).full + +/-- Sum of `exprSize` over an array. -/ +def exprsSize (es : Array Ixon.Expr) : Nat := es.foldl (fun acc e => acc + exprSize e) 0 + +/-! ## Byte and vector order -/ + +/-- Unsigned lexicographic comparison of byte strings; a proper prefix sorts +first (core `List.compareLex` on the bytes, a lawful total order). -/ +def compareBytes (a b : ByteArray) : Ordering := + List.compareLex compare a.data.toList b.data.toList + +/-- Lexicographic comparison of natural-number vectors, numeric on entries; a +proper prefix sorts first (core `List.compareLex`, a lawful total order). -/ +def lexCompare (a b : List Nat) : Ordering := List.compareLex compare a b + +/-- `Array` form of `lexCompare`. -/ +def compareNatArray (a b : Array Nat) : Ordering := lexCompare a.toList b.toList + +/-! ## Structural node alphabet (§3.2) -/ + +/-- The scalar part of an expanded (Share-free) Ixon expression node. -/ +inductive Head where + | sort (idx : UInt64) + | var (idx : UInt64) + | ref (refIdx : UInt64) (univIdxs : Array UInt64) + | recur (recIdx : UInt64) (univIdxs : Array UInt64) + | prj (typeRefIdx : UInt64) (fieldIdx : UInt64) + | str (refIdx : UInt64) + | nat (refIdx : UInt64) + | app + | lam (contract : BinderContract) + | all (contract : BinderContract) (result : ValueContract) + | letE (contract : LetContract) + deriving BEq, Hashable, Repr, Inhabited + +namespace Head + +/-- §3.2 constructor tag (equal to the Ixon expression flag). -/ +def tag : Head → Nat + | .sort _ => 0x0 + | .var _ => 0x1 + | .ref .. => 0x2 + | .recur .. => 0x3 + | .prj .. => 0x4 + | .str _ => 0x5 + | .nat _ => 0x6 + | .app => 0x7 + | .lam _ => 0x8 + | .all .. => 0x9 + | .letE _ => 0xA + +/-- §3.2 scalar payload vector, compared numerically. -/ +def scalars : Head → List Nat + | .sort i => [i.toNat] + | .var i => [i.toNat] + | .ref r us => r.toNat :: us.size :: us.toList.map UInt64.toNat + | .recur r us => r.toNat :: us.size :: us.toList.map UInt64.toNat + | .prj t f => [t.toNat, f.toNat] + | .str i => [i.toNat] + | .nat i => [i.toNat] + | .app => [] + | .lam c => [c.toBits.toNat] + | .all c r => [(packAllContract c r).toNat] + | .letE c => [c.flags.toNat, c.binder.toBits.toNat] + +/-- Number of ordered children. -/ +def arity : Head → Nat + | .prj .. => 1 + | .app | .lam _ | .all .. => 2 + | .letE _ => 3 + | _ => 0 + +/-- Ixon expression flag of the inline node. -/ +def flag : Head → UInt8 + | .sort _ => Ixon.Expr.FLAG_SORT + | .var _ => Ixon.Expr.FLAG_VAR + | .ref .. => Ixon.Expr.FLAG_REF + | .recur .. => Ixon.Expr.FLAG_REC + | .prj .. => Ixon.Expr.FLAG_PRJ + | .str _ => Ixon.Expr.FLAG_STR + | .nat _ => Ixon.Expr.FLAG_NAT + | .app => Ixon.Expr.FLAG_APP + | .lam _ => Ixon.Expr.FLAG_LAM + | .all .. => Ixon.Expr.FLAG_ALL + | .letE _ => Ixon.Expr.FLAG_LET + +/-- The TagN (`f = 4`) value written by `putExpr` for a non-telescope head. -/ +def tag4Field : Head → UInt64 + | .sort i => i + | .var i => i + | .ref _ us => us.size.toUInt64 + | .recur _ us => us.size.toUInt64 + | .prj _ f => f + | .str i => i + | .nat i => i + | .letE c => c.flags + | .app | .lam _ | .all .. => 0 + +/-- Bytes a non-telescope node writes itself, excluding its children. +Telescope heads (`app`/`lam`/`all`) are priced by the telescope recurrence +and return 0 here. -/ +def ownBytes : Head → Nat + | .sort i => tag4Size i.toNat + | .var i => tag4Size i.toNat + | .ref r us => tag4Size us.size + tag0Size r.toNat + univIdxsSize us + | .recur r us => tag4Size us.size + tag0Size r.toNat + univIdxsSize us + | .prj t f => tag4Size f.toNat + tag0Size t.toNat + | .str i => tag4Size i.toNat + | .nat i => tag4Size i.toNat + | .letE c => tag4Size c.flags.toNat + 1 + | .app | .lam _ | .all .. => 0 + +end Head + +/-- A structural node: head scalars plus ordered child term IDs. -/ +structure Node where + head : Head + children : Array Nat + deriving BEq, Hashable, Repr, Inhabited + +/-- The §3.2 total key order: constructor tag, then scalar vector, then the +ordered child-ID vector, each compared numerically/lexicographically with a +proper prefix first. -/ +def Node.compareKey (x y : Node) : Ordering := + (compare x.head.tag y.head.tag).then + ((lexCompare x.head.scalars y.head.scalars).then + (lexCompare x.children.toList y.children.toList)) + +/-- The `i`-th child ID (the arity invariant makes the default unreachable). -/ +@[inline] def Node.child (n : Node) (i : Nat) : Nat := n.children.getD i 0 + +/-- Rebuild an Ixon expression node from its head and child expressions. -/ +def Node.toExpr (n : Node) (child : Nat → Ixon.Expr) : Ixon.Expr := + match n.head with + | .sort i => .sort i + | .var i => .var i + | .ref r us => .ref r us + | .recur r us => .recur r us + | .prj t f => .prj t f (child (n.child 0)) + | .str i => .str i + | .nat i => .nat i + | .app => .app (child (n.child 0)) (child (n.child 1)) + | .lam c => .lam c (child (n.child 0)) (child (n.child 1)) + | .all c r => .all c r (child (n.child 0)) (child (n.child 1)) + | .letE c => .letE c (child (n.child 0)) (child (n.child 1)) (child (n.child 2)) + +/-! ## Errors, limits and work counters -/ + +/-- Metered resources. -/ +inductive Resource where + | exprVisits + | depth + | nodes + | states + | transitions + | costEvals + | outputBytes + | materialize + | materializeWork + | oracleTables + | oracleVariants + | knapsackCells + deriving BEq, Repr, Inhabited + +/-- The name of a resource in error messages and in limit overrides +(`Limits.withOverrides`, `ix compile --sharing-limits`). -/ +def Resource.key : Resource → String + | .exprVisits => "expr_visits" + | .depth => "depth" + | .nodes => "nodes" + | .states => "states" + | .transitions => "transitions" + | .costEvals => "cost_evals" + | .outputBytes => "output_bytes" + | .materialize => "materialize" + | .materializeWork => "materialize_work" + | .oracleTables => "oracle_tables" + | .oracleVariants => "oracle_variants" + | .knapsackCells => "knapsack_cells" + +/-- Why an exact sharing operation did not produce a certified result. -/ +inductive SharingError where + /-- A `Share` leaf where an expanded (Share-free) AST was required. -/ + | shareInExpandedInput (rootIdx : Nat) (shareIdx : UInt64) + /-- A `Share` index that does not name any table entry. `entry = none` + means a root. -/ + | shareOutOfRange (entry : Option Nat) (shareIdx : UInt64) (tableSize : Nat) + /-- Entry `entry` refers to itself or to a later entry. Only strictly + backward references are admitted, which also excludes cycles. -/ + | nonBackwardShare (entry : Nat) (shareIdx : UInt64) + /-- A count or index that cannot be written through a `UInt64` field. -/ + | formatBound (what : String) (value : Nat) + /-- Root reassembly received a different number of roots than extraction + produced. -/ + | rootCountMismatch (expected actual : Nat) + /-- A deterministic resource limit was reached before certification. -/ + | resourceExhausted (resource : Resource) (limit : Nat) + /-- An internal self-check failed. Never returned for a correct + implementation; reported instead of an unverified result. -/ + | internal (msg : String) + deriving BEq, Repr, Inhabited + +instance : ToString SharingError where + toString e := reprStr e + +/-- Deterministic resource limits. Exceeding any limit returns +`SharingError.resourceExhausted`; limits never change a successful result. + +The defaults are a safety net, not a budget: each is at least 2^6 times the +previous default, under which every Init constant and the Mathlib sample +(every constant with more than 2,000 candidates among them) built without +exhaustion. A run that reaches a limit fails closed and names the resource +(`Resource.key`); `Limits.withOverrides` raises it. `maxDepth` also bounds +the native recursion of the expression walks: expansion and serialization +ran at depth 2^20 without exhausting the stack. -/ +structure Limits where + /-- Expression nodes walked while expanding input (tables, roots, and the + self-check of the output). -/ + maxExprVisits : Nat := 1 <<< 40 + /-- Recursion depth of expression walks (the DAG height). -/ + maxDepth : Nat := 1 <<< 20 + /-- Distinct structural subterms. -/ + maxNodes : Nat := 1 <<< 32 + /-- Width states inserted into the search frontier. -/ + maxStates : Nat := 1 <<< 40 + /-- Cells (components × capacity) of the uniform optimizer's count-bracket + knapsack table; matches the Rust `max_knapsack_cells`. -/ + maxKnapsackCells : Nat := 1 <<< 28 + /-- Transitions (state, appended term) examined. -/ + maxTransitions : Nat := 1 <<< 40 + /-- Term cost evaluations plus telescope spine steps. -/ + maxCostEvals : Nat := 1 <<< 50 + /-- Variable bytes (roots, table count, table bodies) of the result. -/ + maxOutputBytes : Nat := 1 <<< 40 + /-- Predicted size of the materialized output (an upper bound on the + expression nodes built), checked before materializing. -/ + maxMaterialize : Nat := 1 <<< 40 + /-- Cumulative evaluation work of materializing a table entry by entry (the + tiered phase re-evaluates the DAG once per entry, about `2·k·N`). -/ + maxMaterializeWork : Nat := 1 <<< 56 + /-- Tables enumerated by the exhaustive oracle. -/ + maxOracleTables : Nat := 1 <<< 20 + /-- Representations enumerated by the exhaustive oracle. -/ + maxOracleVariants : Nat := 1 <<< 24 + /-- Lower-bound pruning. Disabling it (for testing) explores every + reachable width state; the result must not change. -/ + prune : Bool := true + /-- Uniform width: search each component by plain subset enumeration + instead of the reclassifying branch and bound. A test oracle, not the + compiler path (off by default; the optimality theorems of + `Ix.Compile.Verify.UniformOptimality` assume it is off). The result must + not change. -/ + uniformSubsetSearch : Bool := false + deriving Repr, Inhabited + +/-- The value `max` in a limit override: `2^64 − 1`, the largest value Rust's +`u64` limits hold. -/ +def limitMax : Nat := 2 ^ 64 - 1 + +/-- Limit keys of the Rust implementation (`ExactSharingLimits`) that the Lean +limits do not have. `Limits.withOverrides` accepts and ignores them, so one +override string serves both compilers; `states`, `transitions` and +`output_bytes` name a limit in both. -/ +def rustOnlyLimitKeys : List String := + ["input_nodes", "distinct_nodes", "height", "candidates", "layer_states", "work"] + +/-- Set the limit named `key` (`Resource.key`, oracle limits excluded). -/ +def Limits.set? (l : Limits) (key : String) (v : Nat) : Option Limits := + match key with + | "expr_visits" => some { l with maxExprVisits := v } + | "depth" => some { l with maxDepth := v } + | "nodes" => some { l with maxNodes := v } + | "states" => some { l with maxStates := v } + | "transitions" => some { l with maxTransitions := v } + | "cost_evals" => some { l with maxCostEvals := v } + | "output_bytes" => some { l with maxOutputBytes := v } + | "materialize" => some { l with maxMaterialize := v } + | "materialize_work" => some { l with maxMaterializeWork := v } + | "knapsack_cells" => some { l with maxKnapsackCells := v } + | _ => none + +/-- Every production limit set to `v` (the oracle limits are unchanged). -/ +def Limits.setAll (l : Limits) (v : Nat) : Limits := + { l with maxExprVisits := v, maxDepth := v, maxNodes := v, maxStates := v, + maxTransitions := v, maxCostEvals := v, maxOutputBytes := v, + maxMaterialize := v, maxMaterializeWork := v, maxKnapsackCells := v } + +/-- A limit value: ASCII decimal digits, `2^k` (`k ≤ 63`) or `max`. No sign or +`_` separator (`String.toNat?` alone would accept `1_000`), so the grammar is +Rust's `parse_limit_value`. -/ +def parseLimitValue (raw : String) : Except String Nat := + let s := raw.trimAscii.toString + if s.any (· == '_') then .error s!"sharing limit value {s}: expected digits, 2^k or max" + else if s == "max" then .ok limitMax + else if s.startsWith "2^" then + match (s.drop 2).toString.toNat? with + | some k => if k ≤ 63 then .ok (2 ^ k) else .error s!"sharing limit value {s}: exponent above 63" + | none => .error s!"sharing limit value {s}: expected digits, 2^k or max" + else + match s.toNat? with + | some n => if n ≤ limitMax then .ok n else .error s!"sharing limit value {s}: above 2^64 - 1" + | none => .error s!"sharing limit value {s}: expected digits, 2^k or max" + +/-- Apply a limit override: comma-separated items, each `key=value` +(`Resource.key` names; values as `parseLimitValue`) or `unbounded` (every +production limit at `max`), applied left to right. Rust-only keys +(`rustOnlyLimitKeys`) are accepted and ignored; any other key is an error. +This is the format of `ix compile --sharing-limits` and of the +`IX_SHARING_LIMITS` environment variable, which Rust's +`compiler_sharing_limits` parses the same way. -/ +def Limits.withOverrides (l : Limits) (spec : String) : Except String Limits := do + let mut l := l + for raw in spec.splitOn "," do + let item := raw.trimAscii.toString + if item.isEmpty then continue + if item == "unbounded" then + l := l.setAll limitMax + continue + match item.splitOn "=" with + | [k, v] => + let key := k.trimAscii.toString + let v ← parseLimitValue v + match l.set? key v with + | some l' => l := l' + | none => + unless rustOnlyLimitKeys.contains key do + throw s!"unknown sharing limit {key} (expected expr_visits, depth, nodes, states, \ + transitions, cost_evals, output_bytes, materialize, materialize_work, knapsack_cells, or a Rust key: \ + {", ".intercalate rustOnlyLimitKeys})" + | _ => throw s!"sharing limit item {item}: expected key=value or unbounded" + return l + +/-- Nonsemantic work statistics. -/ +structure Stats where + exprVisits : Nat := 0 + internedNodes : Nat := 0 + distinctSubterms : Nat := 0 + candidates : Nat := 0 + layers : Nat := 0 + statesReached : Nat := 0 + statesExpanded : Nat := 0 + statesPruned : Nat := 0 + transitions : Nat := 0 + transitionsPruned : Nat := 0 + costEvals : Nat := 0 + materializedNodes : Nat := 0 + outputBytes : Nat := 0 + deriving BEq, Repr, Inhabited + +/-- Checked counter increment: `count + n` must stay within `limit`. -/ +@[inline] def bump (count n limit : Nat) (r : Resource) : Except SharingError Nat := + let count' := count + n + if count' > limit then .error (.resourceExhausted r limit) else .ok count' + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/Dag.lean b/Ix/Sharing/Exact/Dag.lean new file mode 100644 index 000000000..8309ffb01 --- /dev/null +++ b/Ix/Sharing/Exact/Dag.lean @@ -0,0 +1,467 @@ +/- + Exact minimum sharing: expanded structural DAG. + + * `ingestTable` expands an existing sharing table and its roots into a + hash-consed DAG without materializing the occurrence tree. Entry `i` may + refer only to entries `< i` (the backward-reference class of + `Ix.Compile.Verify.ExprTableWF`); forward/self references, out-of-range + indices, excessive depth and excessive work are reported as errors. + * `canonicalize` keeps the subterms reachable from the roots and assigns + the §3.2 structural IDs: increasing height, then the + `(tag, scalars, child IDs)` key order. Children always have smaller IDs. + * `occurrences` counts logical occurrences through every DAG edge. + * `constantInfoRoots` / `withRoots` extract and reassemble the ordered + expression roots of a `ConstantInfo`, mirroring + `Ix.CompileM.constantInfoRootExprs` (checked equal in the tests), with an + exact root-count check instead of out-of-range fallbacks. + + Structural equality is decided by `Node` keys (`BEq`), never by a hash + alone; the pointer cache only skips re-walking the same live object. +-/ +module + +public import Ix.Sharing.Exact.Basic + +public section + +namespace Ix.Sharing.Exact + +open Ixon + +/-! ## Hash-consing interner -/ + +/-- Hash-consed nodes. Children are interned before their parent, so every +child ID is smaller than its parent's ID. -/ +structure Interner where + nodes : Array Node := #[] + index : Std.HashMap Node Nat := {} + deriving Inhabited + +/-- Return the ID of `n`, adding it if it is new. Lookup is by the full +structural key. -/ +def Interner.intern (s : Interner) (n : Node) : Interner × Nat := + match s.index.get? n with + | some i => (s, i) + | none => + let i := s.nodes.size + ({ nodes := s.nodes.push n, index := s.index.insert n i }, i) + +/-- An interner whose IDs are exactly the given nodes' positions. -/ +def Interner.ofNodes (nodes : Array Node) : Interner := + { nodes, index := nodes.zipIdx.foldl (fun m (n, i) => m.insert n i) {} } + +/-- State of one expansion pass. -/ +structure IngestState where + interner : Interner := {} + /-- Live input object address ↦ term ID. Every object walked in one pass + was allocated before the pass and is alive while walked, so two walked + objects with the same address are the same object. -/ + ptrCache : Std.HashMap USize Nat := {} + visits : Nat := 0 + deriving Inhabited + +abbrev IngestM := StateT IngestState (Except SharingError) + +@[inline] def liftExcept {α} (x : Except SharingError α) : IngestM α := + match x with + | .ok a => pure a + | .error e => throw e + +/-- How `Share` leaves resolve during one walk. -/ +structure ShareCtx where + /-- Term IDs of the entries this walk may reference (a strict prefix of + the table for an entry, the whole table for a root). -/ + resolved : Array Nat + tableSize : Nat + /-- The entry being expanded, or `none` for a root. -/ + entry : Option Nat + /-- Index of the root being walked (error reporting). -/ + root : Nat + /-- `false` when the input must already be expanded. -/ + allowShare : Bool + +/-- Resolve `Share(j)` in context. -/ +def resolveShare (ctx : ShareCtx) (j : UInt64) : Except SharingError Nat := + if !ctx.allowShare then .error (.shareInExpandedInput ctx.root j) + else match ctx.resolved[j.toNat]? with + | some id => .ok id + | none => + match ctx.entry with + | some i => + if j.toNat < ctx.tableSize then .error (.nonBackwardShare i j) + else .error (.shareOutOfRange (some i) j ctx.tableSize) + | none => .error (.shareOutOfRange none j ctx.tableSize) + +/-- Intern one node, enforcing the node limit. -/ +def internNode (limits : Limits) (n : Node) : IngestM Nat := do + let s ← get + let (interner, id) := s.interner.intern n + if interner.nodes.size > limits.maxNodes then + throw (.resourceExhausted .nodes limits.maxNodes) + set { s with interner } + return id + +/-- Expand one expression into the interner and return its term ID. -/ +def ingestExpr (limits : Limits) (ctx : ShareCtx) (depth : Nat) (e : Ixon.Expr) : + IngestM Nat := do + let ptr := exprPtr e + match (← get).ptrCache.get? ptr with + | some id => return id + | none => + if depth > limits.maxDepth then + throw (.resourceExhausted .depth limits.maxDepth) + let s ← get + let visits ← liftExcept (bump s.visits 1 limits.maxExprVisits .exprVisits) + set { s with visits } + let id ← match e with + | .sort i => internNode limits ⟨.sort i, #[]⟩ + | .var i => internNode limits ⟨.var i, #[]⟩ + | .ref r us => internNode limits ⟨.ref r us, #[]⟩ + | .recur r us => internNode limits ⟨.recur r us, #[]⟩ + | .prj t f v => do + let vi ← ingestExpr limits ctx (depth + 1) v + internNode limits ⟨.prj t f, #[vi]⟩ + | .str i => internNode limits ⟨.str i, #[]⟩ + | .nat i => internNode limits ⟨.nat i, #[]⟩ + | .app f a => do + let fi ← ingestExpr limits ctx (depth + 1) f + let ai ← ingestExpr limits ctx (depth + 1) a + internNode limits ⟨.app, #[fi, ai]⟩ + | .lam c ty body => do + let ti ← ingestExpr limits ctx (depth + 1) ty + let bi ← ingestExpr limits ctx (depth + 1) body + internNode limits ⟨.lam c, #[ti, bi]⟩ + | .all c r ty body => do + let ti ← ingestExpr limits ctx (depth + 1) ty + let bi ← ingestExpr limits ctx (depth + 1) body + internNode limits ⟨.all c r, #[ti, bi]⟩ + | .letE c ty v body => do + let ti ← ingestExpr limits ctx (depth + 1) ty + let vi ← ingestExpr limits ctx (depth + 1) v + let bi ← ingestExpr limits ctx (depth + 1) body + internNode limits ⟨.letE c, #[ti, vi, bi]⟩ + | .share j => liftExcept (resolveShare ctx j) + modify fun s => { s with ptrCache := s.ptrCache.insert ptr id } + return id + +/-- Expand a sharing table and then the roots. Entry `i` is expanded +against entries `0..i-1` only; roots may use the whole table. Returns the +root term IDs. With `allowShare = false` the table must be empty and any +`Share` is an error. Returns the entry term IDs and the root term IDs. -/ +def ingestTable (limits : Limits) (sharing roots : Array Ixon.Expr) + (allowShare : Bool) : IngestM (Array Nat × Array Nat) := do + if sharing.size ≥ wordBound then + throw (.formatBound "sharing table size" sharing.size) + let mut resolved : Array Nat := #[] + for h : i in [0:sharing.size] do + let ctx : ShareCtx := + { resolved, tableSize := sharing.size, entry := some i, root := 0, allowShare } + let id ← ingestExpr limits ctx 0 sharing[i] + resolved := resolved.push id + let mut out : Array Nat := #[] + for h : r in [0:roots.size] do + let ctx : ShareCtx := + { resolved, tableSize := sharing.size, entry := none, root := r, allowShare } + let id ← ingestExpr limits ctx 0 roots[r] + out := out.push id + return (resolved, out) + +/-! ## Canonical structural IDs (§3.2) -/ + +/-- The canonical DAG: `nodes[i]` is the node with structural ID `i`; every +child ID is smaller than its parent's ID. -/ +structure Dag where + nodes : Array Node := #[] + deriving Inhabited, Repr, BEq + +/-- Number of distinct subterms. -/ +@[inline] def Dag.size (d : Dag) : Nat := d.nodes.size + +/-- Node with the given ID (default for an out-of-range ID). -/ +@[inline] def Dag.node (d : Dag) (t : Nat) : Node := d.nodes[t]?.getD default + +/-- Heights of the given nodes, which must have children before parents. -/ +def nodeHeights (nodes : Array Node) : Array Nat := + (List.range nodes.size).foldl (fun height t => + height.set! t (nodes[t]!.children.foldl (fun acc c => max acc (height[c]! + 1)) 0)) + (Array.replicate nodes.size 0) + +/-- Check that every child ID is smaller than its parent's ID. -/ +def childrenPrecede (nodes : Array Node) : Bool := + nodes.zipIdx.all fun (n, t) => n.children.all (· < t) + +/-- Mark the nodes reachable from `roots`: the roots, then the children of +every marked node, visiting parents before children (descending IDs, as +children precede parents). -/ +def reachMarks (temp : Array Node) (roots : Array Nat) : Array Bool := + (List.range temp.size).foldr + (fun t reach => + if reach[t]! then temp[t]!.children.foldl (fun r c => r.set! c true) reach else reach) + (roots.foldl (fun r t => r.set! t true) (Array.replicate temp.size false)) + +/-- The marked nodes grouped by height, each group in increasing ID order. -/ +def heightBuckets (reach : Array Bool) (height : Array Nat) (maxH n : Nat) : + Array (Array Nat) := + (List.range n).foldl + (fun buckets t => if reach[t]! then buckets.modify height[t]! (·.push t) else buckets) + (Array.replicate (maxH + 1) #[]) + +/-- Assign the next IDs to a key-sorted group, checking that the keys +strictly increase. -/ +def placeSorted : List (Nat × Node) → Option Node → Array Nat × Array Node → + Except SharingError (Array Nat × Array Node) + | [], _, st => pure st + | (t, node) :: rest, prev, (canon, out) => do + if let some p := prev then + unless Node.compareKey p node == .lt do + throw (.internal "structural keys not strictly increasing within a height") + placeSorted rest (some node) (canon.set! t out.size, out.push node) + +/-- Renumber one height group: key every node by its head and the canonical +IDs of its (lower) children, sort by key, and append. -/ +def placeBucket (temp : Array Node) (st : Array Nat × Array Node) (bucket : Array Nat) : + Except SharingError (Array Nat × Array Node) := + let keyed := bucket.toList.map fun t => + let node := temp[t]! + (t, { node with children := node.children.map (st.1[·]!) }) + let sorted := keyed.mergeSort fun x y => Node.compareKey x.2 y.2 != .gt + placeSorted sorted none st + +/-- Keep the nodes reachable from `rootTemps` and renumber them by the §3.2 +rule: increasing height, then increasing `(tag, scalars, child IDs)`. +Returns the canonical DAG and the canonical root IDs. -/ +def canonicalize (temp : Array Node) (rootTemps : Array Nat) : + Except SharingError (Dag × Array Nat) := do + let n := temp.size + unless childrenPrecede temp do + throw (.internal "interner produced a child after its parent") + unless rootTemps.all (· < n) do + throw (.internal "root ID out of range") + let reach := reachMarks temp rootTemps + let height := nodeHeights temp + let maxH := (List.range n).foldl + (fun acc t => if reach[t]! then max acc height[t]! else acc) 0 + let buckets := heightBuckets reach height maxH n + let (canon, out) ← (List.range (maxH + 1)).foldlM + (fun st h => placeBucket temp st buckets[h]!) (Array.replicate n 0, #[]) + return (⟨out⟩, rootTemps.map (canon[·]!)) + +/-- Result of expanding input into a canonical DAG. -/ +structure Expanded where + dag : Dag + roots : Array Nat + visits : Nat + internedNodes : Nat + deriving Inhabited + +/-- Expand `(sharing, roots)` into the canonical DAG of the roots' distinct +subterms. The DAG height (which bounds the nesting depth of every later +recursive walk, including of the optimizer's output) must not exceed +`limits.maxDepth`. -/ +def expand (limits : Limits) (sharing roots : Array Ixon.Expr) (allowShare : Bool) : + Except SharingError Expanded := do + let ((_, rootTemps), st) ← (ingestTable limits sharing roots allowShare).run {} + let (dag, rootIds) ← canonicalize st.interner.nodes rootTemps + if (nodeHeights dag.nodes).any (· > limits.maxDepth) then + throw (.resourceExhausted .depth limits.maxDepth) + return { dag, roots := rootIds, visits := st.visits, + internedNodes := st.interner.nodes.size } + +/-- Re-expand an encoding against an existing canonical DAG and return its +entry term IDs, root term IDs and walk count. A term absent from `dag` +receives an ID `≥ dag.size`. -/ +def reexpand (limits : Limits) (dag : Dag) (sharing roots : Array Ixon.Expr) : + Except SharingError (Array Nat × Array Nat × Nat) := do + let st : IngestState := { interner := .ofNodes dag.nodes } + let ((entryIds, rootIds), st) ← (ingestTable limits sharing roots true).run st + return (entryIds, rootIds, st.visits) + +/-! ## Occurrences and materialized expressions -/ + +/-- Whether the edge from `parent` to its `i`-th child continues the parent's +telescope. -/ +def continuationEdge (parent : Node) (i : Nat) (child : Node) : Bool := + match parent.head, child.head with + | .app, .app => i == 0 + | .lam _, .lam _ => i == 1 + | .all .., .all .. => i == 1 + | _, _ => false + +/-- Counts pushed from parents to children, the largest ID first: every root +occurrence counts 1, and each term `y`, whose own count `c` is final by then, +adds `weight y c` per edge into each child. The second array counts only the +head (non-continuation) edges. -/ +def propagateCounts (dag : Dag) (roots : Array Nat) (weight : Nat → Nat → Nat) : + Array Nat × Array Nat := + let n := dag.size + let base := roots.foldl (fun acc r => acc.modify r (· + 1)) (Array.replicate n 0) + foldRange (fun (st : Array Nat × Array Nat) k => + let y := n - 1 - k + let wy := weight y st.1[y]! + let node := dag.node y + (List.range node.children.size).foldl (fun (st : Array Nat × Array Nat) i => + let c := node.child i + (st.1.modify c (· + wy), + if continuationEdge node i (dag.node c) then st.2 else st.2.modify c (· + wy))) + st) + 0 n (base, base) + +/-- `propagateCounts` with the pair of counts taken apart before it is +updated, so that both arrays are updated in place. -/ +def propagateCountsFast (dag : Dag) (roots : Array Nat) (weight : Nat → Nat → Nat) : + Array Nat × Array Nat := + let n := dag.size + let base := roots.foldl (fun acc r => acc.modify r (· + 1)) (Array.replicate n 0) + foldRange (fun (st : Array Nat × Array Nat) k => + match st with + | (ds, hs) => + let y := n - 1 - k + let wy := weight y ds[y]! + let node := dag.node y + (List.range node.children.size).foldl (fun (st : Array Nat × Array Nat) i => + match st with + | (ds, hs) => + let c := node.child i + (ds.modify c (· + wy), + if continuationEdge node i (dag.node c) then hs else hs.modify c (· + wy))) + (ds, hs)) + 0 n (base, base) + +@[csimp] theorem propagateCounts_eq_fast : @propagateCounts = @propagateCountsFast := by + funext dag roots weight + unfold propagateCounts propagateCountsFast + rfl + +/-- Logical occurrence count of every term in the expanded roots, counted +through every DAG edge with multiplicity and every root occurrence. -/ +def occurrences (dag : Dag) (roots : Array Nat) : Array Nat := + (propagateCounts dag roots fun _ c => c).1 + +/-- One expanded expression per term, built bottom-up with maximal pointer +sharing (no occurrence-tree allocation). -/ +def Dag.toExprs (dag : Dag) : Array Ixon.Expr := Id.run do + let mut out : Array Ixon.Expr := Array.mkEmpty dag.size + for node in dag.nodes do + let e := node.toExpr fun c => out[c]! + out := out.push e + return out + +/-! ## Ordered expression roots of a `ConstantInfo` -/ + +/-- Roots of one mutual member, in the order of +`Ix.CompileM.mutConstRootExprs`. -/ +def mutConstRoots : Ixon.MutConst → List Ixon.Expr + | .defn d => [d.typ, d.value] + | .indc i => i.typ :: i.ctors.toList.map (·.typ) + | .recr r => r.typ :: r.rules.toList.map (·.rhs) + +/-- All ordered expression roots of a `ConstantInfo`, in the order of +`Ix.CompileM.constantInfoRootExprs`: definitions type/value, axioms and +quotients type, recursors type then rule bodies, mutual blocks each member +in member order (inductives type then constructor types), projections none. -/ +def constantInfoRoots : Ixon.ConstantInfo → Array Ixon.Expr + | .defn d => (mutConstRoots (.defn d)).toArray + | .recr r => (mutConstRoots (.recr r)).toArray + | .axio a => #[a.typ] + | .quot q => #[q.typ] + | .cPrj _ | .rPrj _ | .iPrj _ | .dPrj _ => #[] + | .muts ms => (ms.toList.flatMap mutConstRoots).toArray + +/-- Apply `f` to every root of a mutual member, in `mutConstRoots` order. -/ +def mapMutConstRoots (f : Ixon.Expr → Ixon.Expr) : Ixon.MutConst → Ixon.MutConst + | .defn d => .defn { d with typ := f d.typ, value := f d.value } + | .indc i => .indc { i with typ := f i.typ, ctors := i.ctors.map fun c => { c with typ := f c.typ } } + | .recr r => .recr { r with typ := f r.typ, rules := r.rules.map fun rl => { rl with rhs := f rl.rhs } } + +/-- Apply `f` to every root of a `ConstantInfo`, in `constantInfoRoots` order, +leaving every other field unchanged (a pure, total form of +`withRoots info ((constantInfoRoots info).map f)`). -/ +def mapRoots (f : Ixon.Expr → Ixon.Expr) : Ixon.ConstantInfo → Ixon.ConstantInfo + | .defn d => .defn { d with typ := f d.typ, value := f d.value } + | .recr r => .recr { r with typ := f r.typ, rules := r.rules.map fun rl => { rl with rhs := f rl.rhs } } + | .axio a => .axio { a with typ := f a.typ } + | .quot q => .quot { q with typ := f q.typ } + | .cPrj p => .cPrj p + | .rPrj p => .rPrj p + | .iPrj p => .iPrj p + | .dPrj p => .dPrj p + | .muts ms => .muts (ms.map (mapMutConstRoots f)) + +/-- The next root of the cursor, or an underflow error. -/ +def takeRoot : List Ixon.Expr → Except SharingError (Ixon.Expr × List Ixon.Expr) + | e :: rest => .ok (e, rest) + | [] => .error (.internal "root cursor underflow") + +/-- The next `k` roots of the cursor, or an underflow error. -/ +def takeRoots : Nat → List Ixon.Expr → + Except SharingError (List Ixon.Expr × List Ixon.Expr) + | 0, rest => .ok ([], rest) + | k + 1, rest => do + let (e, rest) ← takeRoot rest + let (es, rest) ← takeRoots k rest + return (e :: es, rest) + +/-- Replace the roots of one mutual member from the cursor, in `mutConstRoots` +order; the rest of the cursor. -/ +def withMutConstRoots (m : Ixon.MutConst) (rs : List Ixon.Expr) : + Except SharingError (Ixon.MutConst × List Ixon.Expr) := + match m with + | .defn d => do + let (typ, rs) ← takeRoot rs + let (value, rs) ← takeRoot rs + return (.defn { d with typ, value }, rs) + | .indc i => do + let (typ, rs) ← takeRoot rs + let (tys, rs) ← takeRoots i.ctors.size rs + let ctors := (i.ctors.toList.zip tys).toArray.map fun (c, t) => { c with typ := t } + return (.indc { i with typ, ctors }, rs) + | .recr r => do + let (typ, rs) ← takeRoot rs + let (rhss, rs) ← takeRoots r.rules.size rs + let rules := (r.rules.toList.zip rhss).toArray.map fun (rule, rhs) => { rule with rhs } + return (.recr { r with typ, rules }, rs) + +/-- Replace the roots of `info` by `roots`, which must have exactly as many +entries as `constantInfoRoots info`, consumed in the same order. -/ +def withRoots (info : Ixon.ConstantInfo) (roots : Array Ixon.Expr) : + Except SharingError Ixon.ConstantInfo := do + let expected := (constantInfoRoots info).size + if roots.size != expected then + throw (.rootCountMismatch expected roots.size) + let rs := roots.toList + let (info', rest) ← match info with + | .defn d => do + let (m, rest) ← withMutConstRoots (.defn d) rs + match m with + | .defn d' => pure (Ixon.ConstantInfo.defn d', rest) + | _ => throw (.internal "member kind changed") + | .recr r => do + let (m, rest) ← withMutConstRoots (.recr r) rs + match m with + | .recr r' => pure (Ixon.ConstantInfo.recr r', rest) + | _ => throw (.internal "member kind changed") + | .axio a => do + let (typ, rest) ← takeRoot rs + pure (Ixon.ConstantInfo.axio { a with typ }, rest) + | .quot q => do + let (typ, rest) ← takeRoot rs + pure (Ixon.ConstantInfo.quot { q with typ }, rest) + | .cPrj p => pure (Ixon.ConstantInfo.cPrj p, rs) + | .rPrj p => pure (Ixon.ConstantInfo.rPrj p, rs) + | .iPrj p => pure (Ixon.ConstantInfo.iPrj p, rs) + | .dPrj p => pure (Ixon.ConstantInfo.dPrj p, rs) + | .muts ms => do + let mut out : Array Ixon.MutConst := #[] + let mut rest := rs + for m in ms do + let (m', rest') ← withMutConstRoots m rest + out := out.push m' + rest := rest' + pure (Ixon.ConstantInfo.muts out, rest) + unless rest.isEmpty do + throw (.internal "root cursor not exhausted") + return info' + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/Dictionary.lean b/Ix/Sharing/Exact/Dictionary.lean new file mode 100644 index 000000000..70a3b816e --- /dev/null +++ b/Ix/Sharing/Exact/Dictionary.lean @@ -0,0 +1,842 @@ +/- + Exact minimum sharing: fixed-dictionary optimizer (§5). + + For a dictionary `M` (available term IDs with their Share widths), + `Prep.eval` computes `C_M(t)`, the minimum byte length of a standalone + expression expanding to `t`, for every term in increasing ID order + (children first). Leaves, `Prj` and `Let` add their fixed header to optimal + children. `App`, `Lam` and `All` have a maximal same-family spine + `t = t₀, t₁, …, t_{l-1}` with natural tail `t_l` of another family, and every + inline prefix length `j ∈ 1..l` is a candidate: + + * Tag4 header for `j`, plus every emitted contract byte and every side + child's optimal standalone cost along the prefix; + * for `j < l` the prefix ends at the same-family node `t_j`, which can only + be written as a Share (an inline tail would be merged back by the + canonical writer), so the cut is legal only if `t_j` is available; + * for `j = l` the natural tail is written at its optimal standalone cost. + + Whole-term sharing is another option when `t` itself is available. + + Evaluation is O(1 + number of available spine descendants) per term: the + per-dictionary suffix sum `sides[t]` of spine bytes gives every prefix sum + as `sides[t] - sides[t_j]`, and `below[t]` links each telescope node to its + nearest available spine descendant, so only legal cuts are visited. This is + the same recurrence as a walk over all `j` (the tests compare it with that + walk and with exhaustive enumeration). + + `materialize` rebuilds, for a dictionary with actual table indices, the + byte-lexicographically least encoding among the minimum-length ones. At + every node the competing options (Share, or inline with a different spine + length) have distinct Tag4 headers that differ inside the header, so the + header alone decides their byte order; children are independent, + fixed-length parts, so choosing each child's least encoding yields the + least concatenation. +-/ +module + +public import Ix.Sharing.Exact.Dag + +public section + +namespace Ix.Sharing.Exact + +open Ixon + +/-! ## Telescope structure -/ + +/-- Telescope family of a node. -/ +inductive Family where + | app + | lam + | all + | none + deriving BEq, Repr, Inhabited + +/-- Family of a head. -/ +def Head.family : Head → Family + | .app => .app + | .lam _ => .lam + | .all .. => .all + | _ => .none + +/-- Next node on a telescope spine: the function of an `App`, the body of a +`Lam`/`All`. -/ +@[inline] def Node.spineNext (n : Node) : Nat := + match n.head with + | .app => n.child 0 + | _ => n.child 1 + +/-- Side child of a telescope node: the argument of an `App`, the binder type +of a `Lam`/`All`. -/ +@[inline] def Node.sideChild (n : Node) : Nat := + match n.head with + | .app => n.child 1 + | _ => n.child 0 + +/-- Bytes a telescope node emits besides its side child: the contract byte of +a `Lam`/`All` binder. -/ +@[inline] def Node.sideExtra (n : Node) : Nat := + match n.head with + | .app => 0 + | _ => 1 + +/-- One dictionary evaluation. `cost[t] = C_M(t)`. For a telescope node `t`, +`sides[t]` is the byte sum of the contract bytes and side-child costs along +its maximal spine, and `below[t]` is the nearest available node strictly +below `t` on that spine. Non-telescope nodes have `sides = 0`, +`below = none`. -/ +structure DictEval where + cost : Array Nat + sides : Array Nat + below : Array (Option Nat) + /-- Terms evaluated plus available spine descendants visited. -/ + work : Nat := 0 + deriving Inhabited + +/-- Per-DAG tables shared by every dictionary evaluation. -/ +structure Prep where + dag : Dag + family : Array Family + /-- For a telescope node, the number of nodes in its maximal same-family + spine (at least 1); 0 for other nodes. -/ + spineLen : Array Nat + /-- For a telescope node, the natural tail below its maximal spine. -/ + tail : Array Nat + /-- Evaluation under the empty dictionary (`empty.cost = C_∅`). -/ + empty : DictEval + deriving Inhabited + +/-- `C_∅`: the standalone unshared length of every term. -/ +@[inline] def Prep.base (p : Prep) : Array Nat := p.empty.cost + +/-- One step of `spineTables`: the spine length and natural tail of `t` from +those of its spine successor. -/ +def spineStep (dag : Dag) (family : Array Family) (st : Array Nat × Array Nat) (t : Nat) : + Array Nat × Array Nat := + let fam := family[t]! + if fam != .none then + let nxt := (dag.node t).spineNext + if family[nxt]! == fam then (st.1.set! t (st.1[nxt]! + 1), st.2.set! t st.2[nxt]!) + else (st.1.set! t 1, st.2.set! t nxt) + else st + +/-- Spine lengths and natural tails, children before parents. -/ +def spineTables (dag : Dag) (family : Array Family) : Array Nat × Array Nat := + foldRange (spineStep dag family) 0 dag.size + (Array.replicate dag.size 0, Array.replicate dag.size 0) + +/-- Width of term `t` in a dictionary (`none` when unavailable). -/ +@[inline] def widthOf (width : Array (Option Nat)) (t : Nat) : Option Nat := + width[t]?.getD none + +/-- The internal cuts of one telescope node: follow the `below` links through +the available spine descendants (at most `fuel` of them), keeping the +cheapest option. Returns the best cost and the work count. -/ +def cutScan (spineLen sides : Array Nat) (below : Array (Option Nat)) + (width : Array (Option Nat)) (l s : Nat) : Nat → Option Nat → Nat → Nat → Nat × Nat + | 0, _, best, work => (best, work) + | _ + 1, none, best, work => (best, work) + | fuel + 1, some u, best, work => + let cand := tag4Size (l - spineLen[u]!) + (s - sides[u]!) + (widthOf width u).getD 0 + cutScan spineLen sides below width l s fuel below[u]! (if cand < best then cand else best) + (work + 1) + +/-- One step of `evalFrom`: evaluate term `t` from its children's entries. -/ +def evalStep (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (affected : Array Bool) (st : DictEval) (t : Nat) : + DictEval := + if affected[t]! then + let node := dag.node t + let fam := family[t]! + if fam == .none then + let inl := node.children.foldl (fun acc c => acc + st.cost[c]!) node.head.ownBytes + let c := match widthOf width t with + | some w => min inl w + | none => inl + { st with cost := st.cost.set! t c, work := st.work + 1 } + else + let nxt := node.spineNext + let same := family[nxt]! == fam + let s := node.sideExtra + st.cost[node.sideChild]! + (if same then st.sides[nxt]! else 0) + let bl : Option Nat := + if same then (if (widthOf width nxt).isSome then some nxt else st.below[nxt]!) + else none + let sides := st.sides.set! t s + let below := st.below.set! t bl + let l := spineLen[t]! + -- Natural end: all `l` spine nodes inline, then the tail; then the + -- internal cuts at available spine descendants. + let (inl, work) := cutScan spineLen sides below width l s l bl + (tag4Size l + s + st.cost[tail[t]!]!) st.work + let c := match widthOf width t with + | some w => min inl w + | none => inl + { cost := st.cost.set! t c, sides, below, work := work + 1 } + else st + +/-! ### One term's cost with its own Share hidden, in place + +`(evalStep … (width.set! t none) affected st t).cost[t]!` is the cost of `t` +written inline (its own Share hidden). Computing it that way copies `width` +and the three tables of `st`, which the caller keeps; `evalHidden` reads them +in place instead (`evalHidden_eq`). -/ + +theorem getElem!_setBang {α : Type} [Inhabited α] (a : Array α) (i j : Nat) (v : α) : + (a.set! i v)[j]! = if j = i ∧ i < a.size then v else a[j]! := by + simp only [Array.set!, getElem!_def, Array.getElem?_setIfInBounds] + by_cases hij : i = j + · subst hij + by_cases hi : i < a.size <;> simp [hi] + · simp [hij, Ne.symm hij] + +theorem widthOf_setBang_none (width : Array (Option Nat)) (t u : Nat) : + widthOf (width.set! t none) u = if u = t then none else widthOf width u := by + unfold widthOf + simp only [Array.set!, Array.getElem?_setIfInBounds] + by_cases hut : u = t + · subst hut + by_cases hu : u < width.size <;> simp [hu] + · simp [hut, Ne.symm hut] + +/-- `cutScan` over `sides.set! t s'`, `below.set! t bl'` and +`width.set! t none`, read in place. -/ +def cutScanAt (spineLen sides : Array Nat) (below : Array (Option Nat)) + (width : Array (Option Nat)) (t s' : Nat) (bl' : Option Nat) (l s : Nat) : + Nat → Option Nat → Nat → Nat → Nat × Nat + | 0, _, best, work => (best, work) + | _ + 1, none, best, work => (best, work) + | fuel + 1, some u, best, work => + let su := if u = t ∧ t < sides.size then s' else sides[u]! + let wu := if u = t then none else widthOf width u + let cand := tag4Size (l - spineLen[u]!) + (s - su) + wu.getD 0 + cutScanAt spineLen sides below width t s' bl' l s fuel + (if u = t ∧ t < below.size then bl' else below[u]!) (if cand < best then cand else best) + (work + 1) + +theorem cutScan_setBang (spineLen sides : Array Nat) (below : Array (Option Nat)) + (width : Array (Option Nat)) (t s' : Nat) (bl' : Option Nat) (l s : Nat) : + ∀ fuel cur best work, + cutScan spineLen (sides.set! t s') (below.set! t bl') (width.set! t none) l s fuel cur + best work = + cutScanAt spineLen sides below width t s' bl' l s fuel cur best work + | 0, _, _, _ => rfl + | _ + 1, none, _, _ => rfl + | fuel + 1, some u, best, work => by + simp only [cutScan, cutScanAt, getElem!_setBang, widthOf_setBang_none] + exact cutScan_setBang spineLen sides below width t s' bl' l s fuel _ _ _ + +/-- The cost of `t` with its own Share hidden under the evaluation `st` and +the widths `width` (`evalHidden_eq`), without copying either. -/ +def evalHidden (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (affected : Array Bool) (st : DictEval) (t : Nat) : Nat := + if affected[t]! then + let node := dag.node t + let fam := family[t]! + if fam == .none then + if t < st.cost.size then + node.children.foldl (fun acc c => acc + st.cost[c]!) node.head.ownBytes + else st.cost[t]! + else + let nxt := node.spineNext + let same := family[nxt]! == fam + let s := node.sideExtra + st.cost[node.sideChild]! + (if same then st.sides[nxt]! else 0) + let bl : Option Nat := + if same then + (if (if nxt = t then none else widthOf width nxt).isSome then some nxt + else st.below[nxt]!) + else none + let l := spineLen[t]! + if t < st.cost.size then + (cutScanAt spineLen st.sides st.below width t s bl l s l bl + (tag4Size l + s + st.cost[tail[t]!]!) st.work).1 + else st.cost[t]! + else st.cost[t]! + +theorem evalHidden_eq (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (affected : Array Bool) (st : DictEval) (t : Nat) : + (evalStep dag family spineLen tail (width.set! t none) affected st t).cost[t]! = + evalHidden dag family spineLen tail width affected st t := by + unfold evalStep evalHidden + by_cases ha : affected[t]! = true + · simp only [ha, if_true] + split + · simp only [widthOf_setBang_none, getElem!_setBang] + by_cases ht : t < st.cost.size <;> simp [ht] + · simp only [widthOf_setBang_none, getElem!_setBang, ← cutScan_setBang] + by_cases ht : t < st.cost.size <;> simp [ht] + · simp only [ha] + rfl + +/-- Evaluate a dictionary. Terms with `affected[t] = false` keep their `init` +entries (sound when no available term occurs inside them, since then their +cost, spine sums and descendant links are those of the empty dictionary). -/ +def evalFrom (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (init : DictEval) (width : Array (Option Nat)) (affected : Array Bool) : + DictEval := + foldRange (evalStep dag family spineLen tail width affected) 0 dag.size + { init with work := 0 } + +/-- Build the per-DAG tables, including the empty-dictionary evaluation. -/ +def Prep.ofDag (dag : Dag) : Prep := + let family := dag.nodes.map (·.head.family) + let (spineLen, tail) := spineTables dag family + let n := dag.size + let zero : DictEval := + { cost := Array.replicate n 0, sides := Array.replicate n 0, + below := Array.replicate n none } + let empty := evalFrom dag family spineLen tail zero (Array.replicate n none) + (Array.replicate n true) + { dag, family, spineLen, tail, empty := { empty with work := 0 } } + +/-- Evaluate `width`, recomputing only `affected` terms. -/ +def Prep.eval (p : Prep) (width : Array (Option Nat)) (affected : Array Bool) : DictEval := + evalFrom p.dag p.family p.spineLen p.tail p.empty width affected + +/-- Evaluate `width`, recomputing every term. -/ +def Prep.evalAll (p : Prep) (width : Array (Option Nat)) : DictEval := + p.eval width (Array.replicate p.dag.size true) + +/-- Marks of `t` and of the terms above it (those with `t` among their +descendants). Only terms from `t` on can lie above it. -/ +def ancestorMarks (dag : Dag) (t : Nat) : Array Bool := + foldRange (fun (acc : Array Bool) u => + acc.set! u (u == t || (dag.node u).children.any (acc[·]!))) t (dag.size - t) + (Array.replicate dag.size false) + +/-- Re-evaluate after the dictionary changed only at `t` (now `width`): only +`t` and the terms above it are recomputed, starting from the evaluation `ev` +of the previous dictionary. -/ +def Prep.evalUp (p : Prep) (ev : DictEval) (width : Array (Option Nat)) (t : Nat) : DictEval := + foldRange (evalStep p.dag p.family p.spineLen p.tail width (ancestorMarks p.dag t)) t + (p.dag.size - t) { ev with work := 0 } + +/-- `C_M` for every term under `width` (recomputing `affected` terms) and the +work performed. -/ +def Prep.costs (p : Prep) (width : Array (Option Nat)) (affected : Array Bool) : + Array Nat × Nat := + let ev := p.eval width affected + (ev.cost, ev.work) + +/-- `C_M` for every term, recomputing everything. -/ +def Prep.costsAll (p : Prep) (width : Array (Option Nat)) : Array Nat × Nat := + let ev := p.evalAll width + (ev.cost, ev.work) + +/-! ## Materialization with the byte-least tie-break -/ + +/-- One way to write a term at the top of a standalone expression. -/ +inductive Choice where + /-- `Share(index)`. -/ + | share + /-- The inline node of a non-telescope head. -/ + | inline + /-- An inline telescope of `j` spine nodes; if `j` is less than the spine + length the tail is a Share. -/ + | cut (j : Nat) + deriving BEq, Repr, Inhabited + +/-- Widths of a dictionary given by table indices. -/ +def widthsOfIndex (index : Array (Option Nat)) : Array (Option Nat) := + index.map (·.map shareWidth) + +/-- Tag4 header bytes from the production encoder. -/ +def tag4Bytes (flag : UInt8) (n : Nat) : ByteArray := runPut (putTagN 4 flag n.toUInt64) + +/-- The internal-cut options of a telescope node: follow the `below` links +through the available spine descendants (at most `fuel`), adding a cut for +each one present in `index`. -/ +def Prep.cutOptions (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (flag : UInt8) (l s : Nat) : + Nat → Option Nat → Array (Choice × Nat × ByteArray) → Array (Choice × Nat × ByteArray) + | 0, _, opts => opts + | _ + 1, none, opts => opts + | fuel + 1, some u, opts => + let j := l - p.spineLen[u]! + let opts := if (index[u]?.getD none).isSome then + opts.push (.cut j, tag4Size j + (s - ev.sides[u]!) + (widthOf width u).getD 0, + tag4Bytes flag j) + else opts + p.cutOptions ev index width flag l s fuel ev.below[u]! opts + +/-- Every legal option at `t` with its exact cost and header bytes, given the +evaluation `ev` of the dictionary with Share widths `width`; headers use the +actual table indices `index`. -/ +def Prep.options (p : Prep) (ev : DictEval) (index : Array (Option Nat)) + (width : Array (Option Nat)) (t : Nat) : + Array (Choice × Nat × ByteArray) := + let node := p.dag.node t + let opts : Array (Choice × Nat × ByteArray) := + match index[t]?.getD none with + | some i => #[(.share, (widthOf width t).getD 0, tag4Bytes Ixon.Expr.FLAG_SHARE i)] + | none => #[] + if p.family[t]! == .none then + let c := node.children.foldl (fun acc c => acc + ev.cost[c]!) node.head.ownBytes + opts.push (.inline, c, runPut (putTagN 4 node.head.flag node.head.tag4Field)) + else + let l := p.spineLen[t]! + let s := ev.sides[t]! + let opts := opts.push (.cut l, tag4Size l + s + ev.cost[p.tail[t]!]!, + tag4Bytes node.head.flag l) + p.cutOptions ev index width node.head.flag l s l ev.below[t]! opts + +/-- The minimum-cost option whose header is byte-least. -/ +def pickOption (opts : Array (Choice × Nat × ByteArray)) : Option (Choice × Nat) := + let best := opts.foldl (init := none) fun best o => + match best with + | none => some o + | some b => + if o.2.1 < b.2.1 then some o + else if o.2.1 == b.2.1 && compareBytes o.2.2 b.2.2 == .lt then some o + else best + best.map fun o => (o.1, o.2.1) + +/-- The first `j` nodes of the telescope spine from `t`, outermost first, +and the term after them. -/ +def Prep.spineWalk (p : Prep) : Nat → Nat → List Node × Nat + | 0, t => ([], t) + | j + 1, t => + let n := p.dag.node t + let (ns, e) := p.spineWalk j n.spineNext + (n :: ns, e) + +/-- Rebuild one telescope node around its rebuilt continuation (`inner`) +and side child. -/ +def rebuildSpineNode (n : Node) (inner side : Ixon.Expr) : Except SharingError Ixon.Expr := + match n.head with + | .app => .ok (.app inner side) + | .lam bc => .ok (.lam bc side inner) + | .all bc r => .ok (.all bc r side inner) + | _ => .error (.internal "spine node is not a telescope node") + +/-- Build the chosen encoding of `t`. With `entry = true` the top may not be +`Share(t)` (the body of `t`'s own table entry); nested terms always use +their standalone choice. Pure and structurally recursive on `fuel`; every +recursive call descends to a strictly smaller term ID, so `dag.size + 1` +suffices. Each call emits one node of the output, so the work is bounded +by the output size. Every inconsistency is an internal error, including a +cut of zero spine nodes (`options` never offers one). -/ +def Prep.build (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) : + Bool → Nat → Nat → Except SharingError Ixon.Expr + | _, 0, _ => throw (.internal "materialization fuel exhausted") + | entry, fuel + 1, t => do + let opts := p.options ev index width t + let opts := if entry then opts.filter (·.1 != .share) else opts + let some (choice, c) := pickOption opts + | throw (.internal s!"no option for term {t}") + unless entry || c == ev.cost[t]! do + throw (.internal s!"option cost {c} differs from C_M = {ev.cost[t]!} at term {t}") + let node := p.dag.node t + match choice with + | .share => + match index[t]?.getD none with + | some i => pure (Ixon.Expr.share i.toUInt64) + | none => throw (.internal "share choice without index") + | .inline => + match node.head with + | .prj ti f => do + let v ← p.build ev index width false fuel (node.child 0) + pure (Ixon.Expr.prj ti f v) + | .letE lc => do + let ty ← p.build ev index width false fuel (node.child 0) + let v ← p.build ev index width false fuel (node.child 1) + let b ← p.build ev index width false fuel (node.child 2) + pure (Ixon.Expr.letE lc ty v b) + | .app | .lam _ | .all .. => throw (.internal "inline choice at a telescope head") + | _ => pure (node.toExpr fun _ => default) + | .cut j => + if j = 0 then throw (.internal "empty telescope cut") else do + let (spine, cur) := p.spineWalk j t + let tail ← if j < p.spineLen[t]! then + match index[cur]?.getD none with + | some i => pure (Ixon.Expr.share i.toUInt64) + | none => throw (.internal "telescope cut at unavailable term") + else p.build ev index width false fuel cur + spine.foldrM (fun n acc => do + let side ← p.build ev index width false fuel n.sideChild + rebuildSpineNode n acc side) tail + +/-! ### Options with their headers encoded only on a cost tie + +`options` encodes the Tag4 header of every option into a `ByteArray`, but +`pickOption` reads the bytes only when two options cost the same. +`optionsLazy` keeps each header as its flag and value (`LazyOpt.bytes` +encodes it), and `pickLazy` encodes the two headers only on a cost tie; +`options_eq_lazy` and `pickOption_lazy` prove them equal to the byte form. +`buildFast` is `build` over them (`build_eq_fast`). -/ + +/-- An option with its header as a flag and a value. -/ +abbrev LazyOpt := Choice × Nat × UInt8 × Nat + +/-- The option with its header bytes. -/ +@[inline] def LazyOpt.bytes (o : LazyOpt) : Choice × Nat × ByteArray := + (o.1, o.2.1, tag4Bytes o.2.2.1 o.2.2.2) + +/-- `cutOptions` with lazy headers. -/ +def Prep.cutOptionsLazy (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (flag : UInt8) (l s : Nat) : Nat → Option Nat → Array LazyOpt → Array LazyOpt + | 0, _, opts => opts + | _ + 1, none, opts => opts + | fuel + 1, some u, opts => + let j := l - p.spineLen[u]! + let opts := if (index[u]?.getD none).isSome then + opts.push (.cut j, tag4Size j + (s - ev.sides[u]!) + (widthOf width u).getD 0, flag, j) + else opts + p.cutOptionsLazy ev index width flag l s fuel ev.below[u]! opts + +/-- `options` with lazy headers. -/ +def Prep.optionsLazy (p : Prep) (ev : DictEval) (index : Array (Option Nat)) + (width : Array (Option Nat)) (t : Nat) : Array LazyOpt := + let node := p.dag.node t + let opts : Array LazyOpt := + match index[t]?.getD none with + | some i => #[(.share, (widthOf width t).getD 0, Ixon.Expr.FLAG_SHARE, i)] + | none => #[] + if p.family[t]! == .none then + let c := node.children.foldl (fun acc c => acc + ev.cost[c]!) node.head.ownBytes + opts.push (.inline, c, node.head.flag, node.head.tag4Field.toNat) + else + let l := p.spineLen[t]! + let s := ev.sides[t]! + let opts := opts.push (.cut l, tag4Size l + s + ev.cost[p.tail[t]!]!, node.head.flag, l) + p.cutOptionsLazy ev index width node.head.flag l s l ev.below[t]! opts + +/-- One step of `pickLazy`: `o` replaces `best` if cheaper, or as cheap with +a byte-smaller header. -/ +@[inline] def pickLazyStep (best : Option LazyOpt) (o : LazyOpt) : Option LazyOpt := + match best with + | none => some o + | some b => + if o.2.1 < b.2.1 then some o + else if o.2.1 == b.2.1 && compareBytes o.bytes.2.2 b.bytes.2.2 == .lt then some o + else best + +/-- `pickOption` with lazy headers. -/ +def pickLazy (opts : Array LazyOpt) : Option (Choice × Nat) := + (opts.foldl pickLazyStep none).map fun o => (o.1, o.2.1) + +theorem cutOptions_eq_lazy (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (flag : UInt8) (l s : Nat) : + ∀ (fuel : Nat) (cur : Option Nat) (opts : Array LazyOpt), + p.cutOptions ev index width flag l s fuel cur (opts.map LazyOpt.bytes) = + (p.cutOptionsLazy ev index width flag l s fuel cur opts).map LazyOpt.bytes + | 0, _, _ => rfl + | _ + 1, none, _ => rfl + | fuel + 1, some u, opts => by + unfold Prep.cutOptions Prep.cutOptionsLazy + split + · rw [← cutOptions_eq_lazy p ev index width flag l s fuel, Array.map_push] + rfl + · exact cutOptions_eq_lazy p ev index width flag l s fuel _ opts + +theorem options_eq_lazy (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (t : Nat) : p.options ev index width t = (p.optionsLazy ev index width t).map LazyOpt.bytes := by + unfold Prep.options Prep.optionsLazy + generalize index[t]?.getD none = o + by_cases hf : (p.family[t]! == Family.none) = true + · cases o <;> simp [hf, LazyOpt.bytes, tag4Bytes] + · simp only [hf, if_false, Bool.false_eq_true] + rw [← cutOptions_eq_lazy] + cases o <;> simp [LazyOpt.bytes, tag4Bytes] + +theorem pickOption_lazy (opts : Array LazyOpt) : + pickOption (opts.map LazyOpt.bytes) = pickLazy opts := by + unfold pickOption pickLazy + rw [Array.foldl_map] + suffices h : ∀ (l : List LazyOpt) (b : Option LazyOpt), + l.foldl (fun best y => match best with + | none => some y.bytes + | some b => + if y.bytes.2.1 < b.2.1 then some y.bytes + else if y.bytes.2.1 == b.2.1 && compareBytes y.bytes.2.2 b.2.2 == .lt then some y.bytes + else best) (b.map LazyOpt.bytes) = + (l.foldl pickLazyStep b).map LazyOpt.bytes by + rw [← Array.foldl_toList, ← Array.foldl_toList, ← Option.map_none (f := LazyOpt.bytes), h, + Option.map_map] + rfl + intro l + induction l with + | nil => intro b; rfl + | cons o l ih => + intro b + simp only [List.foldl_cons] + rw [← ih] + congr 1 + cases b with + | none => rfl + | some b => + simp only [Option.map_some, pickLazyStep] + by_cases h1 : o.2.1 < b.2.1 + · simp [h1, LazyOpt.bytes] + · by_cases h2 : (o.2.1 == b.2.1 && compareBytes o.bytes.2.2 b.bytes.2.2 == .lt) = true + · simp only [LazyOpt.bytes] at h2 ⊢ + simp [h1, h2, LazyOpt.bytes] + · simp only [LazyOpt.bytes] at h2 ⊢ + simp [h1, h2, LazyOpt.bytes] + +/-! ### The pick without the option array + +`pickBuild` makes the choice of `pickLazy` over the options of `t` (all of +them, or those other than the Share of `t`) as the options are generated, +without collecting them in an array (`pickLazy_eq_pickBuild`). -/ + +/-- `cutOptionsLazy` folded into the running pick. -/ +def Prep.cutPickLazy (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (flag : UInt8) (l s : Nat) : Nat → Option Nat → Option LazyOpt → Option LazyOpt + | 0, _, best => best + | _ + 1, none, best => best + | fuel + 1, some u, best => + let j := l - p.spineLen[u]! + let best := if (index[u]?.getD none).isSome then + pickLazyStep best (.cut j, tag4Size j + (s - ev.sides[u]!) + (widthOf width u).getD 0, flag, j) + else best + p.cutPickLazy ev index width flag l s fuel ev.below[u]! best + +/-- The option `pickLazy` picks among the options of `t` (without the Share of +`t` when `entry`). -/ +def Prep.pickBuild (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) (entry : Bool) + (t : Nat) : Option (Choice × Nat) := + let node := p.dag.node t + let best : Option LazyOpt := if entry then none else + match index[t]?.getD none with + | some i => some (.share, (widthOf width t).getD 0, Ixon.Expr.FLAG_SHARE, i) + | none => none + let best := if p.family[t]! == .none then + pickLazyStep best (.inline, node.children.foldl (fun acc c => acc + ev.cost[c]!) + node.head.ownBytes, node.head.flag, node.head.tag4Field.toNat) + else + let l := p.spineLen[t]! + let s := ev.sides[t]! + p.cutPickLazy ev index width node.head.flag l s l ev.below[t]! + (pickLazyStep best (.cut l, tag4Size l + s + ev.cost[p.tail[t]!]!, node.head.flag, l)) + best.map fun o => (o.1, o.2.1) + +/-- `Array.foldl_push` without the choice axiom. -/ +theorem foldl_push_eq {α β : Type} (f : β → α → β) (init : β) (a : Array α) (x : α) : + (a.push x).foldl f init = f (a.foldl f init) x := by + rw [← Array.foldl_toList, ← Array.foldl_toList, Array.toList_push, List.foldl_append] + rfl + +theorem cutOptionsLazy_fold (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (flag : UInt8) (l s : Nat) : + ∀ (fuel : Nat) (cur : Option Nat) (opts : Array LazyOpt), + (p.cutOptionsLazy ev index width flag l s fuel cur opts).foldl pickLazyStep none = + p.cutPickLazy ev index width flag l s fuel cur (opts.foldl pickLazyStep none) + | 0, _, _ => rfl + | _ + 1, none, _ => rfl + | fuel + 1, some u, opts => by + simp only [Prep.cutOptionsLazy, Prep.cutPickLazy] + split + · rw [cutOptionsLazy_fold p ev index width flag l s fuel, foldl_push_eq] + · exact cutOptionsLazy_fold p ev index width flag l s fuel _ opts + +theorem cutOptionsLazy_filter (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (flag : UInt8) (l s : Nat) : + ∀ (fuel : Nat) (cur : Option Nat) (opts : Array LazyOpt), + (p.cutOptionsLazy ev index width flag l s fuel cur opts).filter (·.1 != .share) = + p.cutOptionsLazy ev index width flag l s fuel cur (opts.filter (·.1 != .share)) + | 0, _, _ => rfl + | _ + 1, none, _ => rfl + | fuel + 1, some u, opts => by + simp only [Prep.cutOptionsLazy] + split + · rw [cutOptionsLazy_filter p ev index width flag l s fuel, Array.filter_push] + rfl + · exact cutOptionsLazy_filter p ev index width flag l s fuel _ opts + +/-- **Streaming pick.** `pickBuild` picks what `pickLazy` picks from the +options of `t`. -/ +theorem pickLazy_eq_pickBuild (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (entry : Bool) (t : Nat) : + pickLazy (if entry then (p.optionsLazy ev index width t).filter (·.1 != .share) + else p.optionsLazy ev index width t) = p.pickBuild ev index width entry t := by + unfold pickLazy Prep.pickBuild Prep.optionsLazy + generalize index[t]?.getD none = o + cases entry <;> cases o <;> + by_cases hf : (p.family[t]! == Family.none) = true <;> + simp only [hf, if_true, if_false, Bool.false_eq_true, Array.filter_push, + cutOptionsLazy_filter, cutOptionsLazy_fold, foldl_push_eq] <;> rfl + +/-- `build` over the lazy options (`build_eq_fast`). -/ +def Prep.buildFast (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) : + Bool → Nat → Nat → Except SharingError Ixon.Expr + | _, 0, _ => throw (.internal "materialization fuel exhausted") + | entry, fuel + 1, t => do + let some (choice, c) := p.pickBuild ev index width entry t + | throw (.internal s!"no option for term {t}") + unless entry || c == ev.cost[t]! do + throw (.internal s!"option cost {c} differs from C_M = {ev.cost[t]!} at term {t}") + let node := p.dag.node t + match choice with + | .share => + match index[t]?.getD none with + | some i => pure (Ixon.Expr.share i.toUInt64) + | none => throw (.internal "share choice without index") + | .inline => + match node.head with + | .prj ti f => do + let v ← p.buildFast ev index width false fuel (node.child 0) + pure (Ixon.Expr.prj ti f v) + | .letE lc => do + let ty ← p.buildFast ev index width false fuel (node.child 0) + let v ← p.buildFast ev index width false fuel (node.child 1) + let b ← p.buildFast ev index width false fuel (node.child 2) + pure (Ixon.Expr.letE lc ty v b) + | .app | .lam _ | .all .. => throw (.internal "inline choice at a telescope head") + | _ => pure (node.toExpr fun _ => default) + | .cut j => + if j = 0 then throw (.internal "empty telescope cut") else do + let (spine, cur) := p.spineWalk j t + let tail ← if j < p.spineLen[t]! then + match index[cur]?.getD none with + | some i => pure (Ixon.Expr.share i.toUInt64) + | none => throw (.internal "telescope cut at unavailable term") + else p.buildFast ev index width false fuel cur + spine.foldrM (fun n acc => do + let side ← p.buildFast ev index width false fuel n.sideChild + rebuildSpineNode n acc side) tail + +/-- The option `build` picks at `t`, from the lazy options. -/ +theorem pick_options_lazy (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (entry : Bool) (t : Nat) : + pickOption (if entry then (p.options ev index width t).filter (·.1 != .share) + else p.options ev index width t) = + pickLazy (if entry then (p.optionsLazy ev index width t).filter (·.1 != .share) + else p.optionsLazy ev index width t) := by + rw [options_eq_lazy] + cases entry + · exact pickOption_lazy _ + · simp only [if_true] + rw [Array.filter_map] + exact pickOption_lazy _ + +@[csimp] theorem build_eq_fast : @Prep.build = @Prep.buildFast := by + funext p ev index width entry fuel t + induction fuel generalizing entry t with + | zero => rfl + | succ fuel ih => + have ih' : p.build ev index width false fuel = p.buildFast ev index width false fuel := by + funext t'; exact ih false t' + unfold Prep.build Prep.buildFast + simp only [ih', pick_options_lazy, pickLazy_eq_pickBuild] + +/-- Materialize the byte-least minimum-cost standalone encodings of `targets` +under the dictionary `index` (term ID ↦ table index), pricing each Share by +`width` (which must be `some` exactly where `index` is). The predicted +output size, which bounds the nodes built, is checked against +`maxMaterialize` first. Returns the expressions, the costs used, and the +work performed. -/ +def Prep.materializeWith (p : Prep) (index width : Array (Option Nat)) (targets : Array Nat) + (limits : Limits) : Except SharingError (Array Ixon.Expr × Array Nat × Nat) := do + for i in index do + if let some i := i then + if i ≥ wordBound then throw (.formatBound "share index" i) + let ev := p.evalAll width + let total := targets.foldl (fun acc t => acc + ev.cost[t]!) 0 + if total > limits.maxMaterialize then + throw (.resourceExhausted .materialize limits.maxMaterialize) + let out ← targets.mapM fun t => p.build ev index width false (p.dag.size + 1) t + return (out, ev.cost, ev.work + total) + +/-- Materialize the byte-least minimum-length standalone encodings of +`targets` under the dictionary `index` (term ID ↦ table index), with the +real Share widths. Returns the expressions, the costs `C_M` used, and the +work performed. -/ +def Prep.materialize (p : Prep) (index : Array (Option Nat)) (targets : Array Nat) + (limits : Limits) : Except SharingError (Array Ixon.Expr × Array Nat × Nat) := + p.materializeWith index (widthsOfIndex index) targets limits + +/-- A dictionary index from `(term, table index)` pairs. -/ +def indexOfPairs (size : Nat) (pairs : List (Nat × Nat)) : Array (Option Nat) := + pairs.foldl (fun acc (t, i) => acc.set! t (some i)) (Array.replicate size none) + +/-- The dictionary of the first `k` entries of a table sequence. -/ +def indexOfPrefix (size : Nat) (table : Array Nat) (k : Nat) : Array (Option Nat) := + indexOfPairs size ((table.toList.take k).zipIdx) + +/-- Minimum cost of `t` written with an inline top (the body of its own table +entry) under the evaluation `ev`. -/ +def Prep.inlineCost (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) (t : Nat) : + Nat := + ((pickOption ((p.options ev index width t).filter (·.1 != .share))).map (·.2)).getD 0 + +/-- `inlineCost` over the lazy options (`inlineCost_eq_fast`). -/ +def Prep.inlineCostFast (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) + (t : Nat) : Nat := + ((p.pickBuild ev index width true t).map (·.2)).getD 0 + +@[csimp] theorem inlineCost_eq_fast : @Prep.inlineCost = @Prep.inlineCostFast := by + funext p ev index width t + unfold Prep.inlineCost Prep.inlineCostFast + rw [options_eq_lazy, Array.filter_map, pickOption_lazy, ← pickLazy_eq_pickBuild] + rfl + +/-- The body of a table entry at `t` under a dictionary that contains `t` +itself: `build` with the top Share excluded, the chosen option's cost checked +against `cost` (the cost of `t` with its own Share hidden), and every nested +term built as by `build`. -/ +def Prep.buildTop (p : Prep) (ev : DictEval) (index width : Array (Option Nat)) (cost : Nat) : + Nat → Nat → Except SharingError Ixon.Expr + | 0, _ => throw (.internal "materialization fuel exhausted") + | fuel + 1, t => do + let some (choice, c) := p.pickBuild ev index width true t + | throw (.internal s!"no option for term {t}") + unless c == cost do + throw (.internal s!"option cost {c} differs from C_M = {cost} at term {t}") + let node := p.dag.node t + match choice with + | .share => + match index[t]?.getD none with + | some i => pure (Ixon.Expr.share i.toUInt64) + | none => throw (.internal "share choice without index") + | .inline => + match node.head with + | .prj ti f => do + let v ← p.build ev index width false fuel (node.child 0) + pure (Ixon.Expr.prj ti f v) + | .letE lc => do + let ty ← p.build ev index width false fuel (node.child 0) + let v ← p.build ev index width false fuel (node.child 1) + let b ← p.build ev index width false fuel (node.child 2) + pure (Ixon.Expr.letE lc ty v b) + | .app | .lam _ | .all .. => throw (.internal "inline choice at a telescope head") + | _ => pure (node.toExpr fun _ => default) + | .cut j => + if j = 0 then throw (.internal "empty telescope cut") else do + let (spine, cur) := p.spineWalk j t + let tail ← if j < p.spineLen[t]! then + match index[cur]?.getD none with + | some i => pure (Ixon.Expr.share i.toUInt64) + | none => throw (.internal "telescope cut at unavailable term") + else p.build ev index width false fuel cur + spine.foldrM (fun n acc => do + let side ← p.build ev index width false fuel n.sideChild + rebuildSpineNode n acc side) tail + +/-- Materialize a table given in dependency order (every stored descendant of +an entry precedes it) and the roots, from one evaluation of the whole +dictionary. In such an order the entry for `t` can use every stored term +that can occur inside `t`, and no other stored term can occur there, so the +full dictionary prices and builds its body exactly. Shares are priced by +`width` (`some` exactly on the table's terms). Returns entries, roots, the +total variable cost (table count, entry bodies, roots) and the work. The +caller must re-expand the output: a table that is not in dependency order +is rejected there as a non-backward reference. -/ +def Prep.materializeDependent (p : Prep) (table roots : Array Nat) + (width : Array (Option Nat)) (limits : Limits) : + Except SharingError (Array Ixon.Expr × Array Ixon.Expr × Nat × Nat) := do + if table.size ≥ wordBound then throw (.formatBound "share index" table.size) + let index := indexOfPairs p.dag.size table.toList.zipIdx + let ev := p.evalAll width + let entryCost := table.foldl (fun acc t => acc + p.inlineCost ev index width t) 0 + let rootCost := roots.foldl (fun acc r => acc + ev.cost[r]!) 0 + let total := tag0Size table.size + entryCost + rootCost + if total > limits.maxMaterialize then + throw (.resourceExhausted .materialize limits.maxMaterialize) + let es ← table.mapM fun t => p.build ev index width true (p.dag.size + 1) t + let rs ← roots.mapM fun r => p.build ev index width false (p.dag.size + 1) r + return (es, rs, total, ev.work + total) + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/KnapsackFast.lean b/Ix/Sharing/Exact/KnapsackFast.lean new file mode 100644 index 000000000..69086d237 --- /dev/null +++ b/Ix/Sharing/Exact/KnapsackFast.lean @@ -0,0 +1,2001 @@ +/- + Rank-based table-count knapsack (phase 1, `uniformKnapsack`). + + The knapsack over the component tables keeps, per count `c`, the least + `(Δ, set)` (Δ, then `setPrec`) over one entry per component with counts + summing to `c`. The specification (`knapStep`) builds the merged set of + every candidate and compares sets element by element: cubic in the count + bracket. The fast version keeps per cell only Δ, the entry it took, and the + rank of its set among the layer's sets in `setPrec` order, with a sparse + table over the first differences of rank-adjacent sets. Comparing + `S_a ∪ X` with `S_b ∪ Y` (`S` from earlier components, `X`, `Y` entries of + the next one, over disjoint domains) needs the least element of their + symmetric difference: the smaller of that of `S_a, S_b` (the least + first difference of the rank-adjacent sets between them) and that of + `X, Y`; the set without it precedes. The chosen cell's set is rebuilt from + the entries taken. (Rust: `Knapsack`, `sharing_exact/uniform.rs`.) + + `uniformKnapsack_eq_fast : @uniformKnapsack = @uniformKnapsackFast` + (`@[csimp]`) holds for every input; the fast knapsack runs when every + table entry is an ascending list of its count's length and the tables' + terms are disjoint across components (true of the component tables), + the specification otherwise. Both check `knapsackCells` the same way. +-/ +module + +public import Ix.Sharing.Exact.SortedSets +public import Ix.Sharing.Exact.PinnedFast +public import Ix.Sharing.Exact.Uniform +import all Ix.Sharing.Exact.Uniform +import all Ix.Sharing.Exact.UniformSearch +import all Ix.Common +import all Ix.Sharing.Exact.PinnedFast +import all Ix.Sharing.Exact.SortedSets + +public section + +namespace Ix.Sharing.Exact + +/-! ## The tie order is a strict total order -/ + +instance compareDesc_transCmp : Std.TransCmp compareDesc := + inferInstanceAs (Std.TransCmp fun x y : Nat => compare y x) + +instance compareDesc_lawfulEqCmp : Std.LawfulEqCmp compareDesc := + inferInstanceAs (Std.LawfulEqCmp fun x y : Nat => compare y x) + +theorem setPrec_eq_lt (a b : Array Nat) : + setPrec a b = true ↔ Array.compareLex compareDesc a b = .lt := by + unfold setPrec + cases Array.compareLex compareDesc a b <;> decide + +theorem setPrec_irrefl' (a : Array Nat) : setPrec a a = false := by + unfold setPrec + rw [Std.ReflCmp.compare_self (cmp := Array.compareLex compareDesc)] + decide + +theorem setPrec_trans' {a b c : Array Nat} (h₁ : setPrec a b = true) + (h₂ : setPrec b c = true) : setPrec a c = true := by + rw [setPrec_eq_lt] at * + exact Std.TransCmp.lt_trans h₁ h₂ + +theorem setPrec_asymm' {a b : Array Nat} (h : setPrec a b = true) : setPrec b a = false := by + rw [setPrec_eq_lt] at h + unfold setPrec + rw [Std.OrientedCmp.eq_swap (cmp := Array.compareLex compareDesc), h] + decide + +theorem setPrec_total' {a b : Array Nat} (h : a ≠ b) : + setPrec a b = true ∨ setPrec b a = true := by + rw [setPrec_eq_lt, setPrec_eq_lt] + cases hc : Array.compareLex compareDesc a b + · exact Or.inl rfl + · exact absurd (Std.LawfulEqCmp.eq_of_compare hc) h + · right + rw [Std.OrientedCmp.eq_swap (cmp := Array.compareLex compareDesc), hc] + rfl + +/-- The order of `betterEntry` on values. -/ +def entryLt (x y : _root_.Int × Array Nat) : Bool := + x.1 < y.1 || (x.1 == y.1 && setPrec x.2 y.2) + +theorem betterEntry_some (x y : _root_.Int × Array Nat) : + betterEntry x (some y) = entryLt x y := by + unfold betterEntry entryLt + rfl + +theorem entryLt_irrefl (x : _root_.Int × Array Nat) : entryLt x x = false := by + unfold entryLt + simp [setPrec_irrefl'] + +theorem entryLt_trans {x y z : _root_.Int × Array Nat} (h₁ : entryLt x y = true) + (h₂ : entryLt y z = true) : entryLt x z = true := by + unfold entryLt at * + simp only [Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq] at * + rcases h₁ with h₁ | ⟨h₁, h₁'⟩ <;> rcases h₂ with h₂ | ⟨h₂, h₂'⟩ + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inl (by omega) + · exact Or.inr ⟨by omega, setPrec_trans' h₁' h₂'⟩ + +theorem entryLt_total {x y : _root_.Int × Array Nat} (h : x ≠ y) : + entryLt x y = true ∨ entryLt y x = true := by + unfold entryLt + simp only [Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq] + rcases Int.lt_trichotomy x.1 y.1 with hlt | heq | hgt + · exact Or.inl (Or.inl hlt) + · have hne : x.2 ≠ y.2 := fun h2 => h (Prod.ext heq h2) + rcases setPrec_total' hne with h' | h' + · exact Or.inl (Or.inr ⟨heq, h'⟩) + · exact Or.inr (Or.inr ⟨heq.symm, h'⟩) + · exact Or.inr (Or.inl hgt) + +/-! ## Folds that keep the least element -/ + +/-- A fold that replaces its value by a strictly smaller element ends with an +element that no element of the list is below, and that is the initial value +or below it (on the elements satisfying `P`, where the step compares by +`lt` through `abs`). -/ +theorem foldl_least {α β : Type} (P : α → Prop) (abs : α → β) (lt : β → β → Bool) + (hirr : ∀ x, lt x x = false) + (htrans : ∀ x y z, lt x y = true → lt y z = true → lt x z = true) + (f : Option α → α → Option α) (hf1 : ∀ x, f none x = some x) + (hf2 : ∀ a x, P a → P x → f (some a) x = if lt (abs x) (abs a) then some x else some a) : + ∀ (L : List α) (acc : Option α), (∀ x ∈ L, P x) → (∀ a, acc = some a → P a) → + (L.foldl f acc = none ↔ acc = none ∧ L = []) ∧ + ∀ m, L.foldl f acc = some m → (m ∈ L ∨ acc = some m) ∧ + (∀ x ∈ L, lt (abs x) (abs m) = false) ∧ + (∀ a, acc = some a → m = a ∨ lt (abs m) (abs a) = true) := by + have hasymm : ∀ x y, lt x y = true → lt y x = false := by + intro x y h + cases h' : lt y x + · rfl + · have := htrans _ _ _ h h'; rw [hirr] at this; cases this + intro L + induction L with + | nil => + intro acc _ _ + simp only [List.foldl_nil] + refine ⟨by simp, fun m hm => ⟨Or.inr hm, fun x hx => by simp at hx, fun a ha => ?_⟩⟩ + rw [hm] at ha; cases ha; exact Or.inl rfl + | cons t ts ih => + intro acc hL hacc + have ht := hL t List.mem_cons_self + have hts : ∀ x ∈ ts, P x := fun x hx => hL x (List.mem_cons_of_mem _ hx) + simp only [List.foldl_cons] + cases acc with + | none => + rw [hf1] + obtain ⟨hnone, hsome⟩ := ih (some t) hts (fun a ha => by cases ha; exact ht) + refine ⟨⟨fun h => absurd (hnone.mp h).1 (by simp), fun h => by simp at h⟩, fun m hm => ?_⟩ + obtain ⟨hmem, hle, hlea⟩ := hsome m hm + refine ⟨?_, fun x hx => ?_, fun a ha => by cases ha⟩ + · rcases hmem with h | h + · exact Or.inl (List.mem_cons_of_mem _ h) + · cases h; exact Or.inl List.mem_cons_self + · rcases List.mem_cons.mp hx with h | h + · subst h + rcases hlea x rfl with h | h + · subst h; exact hirr _ + · exact hasymm _ _ h + · exact hle x h + | some a => + have ha := hacc a rfl + rw [hf2 a t ha ht] + by_cases hb : lt (abs t) (abs a) = true + · simp only [hb, if_true] + obtain ⟨hnone, hsome⟩ := ih (some t) hts (fun a ha => by cases ha; exact ht) + refine ⟨⟨fun h => absurd (hnone.mp h).1 (by simp), fun h => by simp at h⟩, fun m hm => ?_⟩ + obtain ⟨hmem, hle, hlea⟩ := hsome m hm + have hmt := hlea t rfl + refine ⟨?_, fun x hx => ?_, fun a' ha' => ?_⟩ + · rcases hmem with h | h + · exact Or.inl (List.mem_cons_of_mem _ h) + · cases h; exact Or.inl List.mem_cons_self + · rcases List.mem_cons.mp hx with h | h + · subst h + rcases hmt with h | h + · subst h; exact hirr _ + · exact hasymm _ _ h + · exact hle x h + · cases ha' + rcases hmt with h | h + · subst h; exact Or.inr hb + · exact Or.inr (htrans _ _ _ h hb) + · simp only [hb, Bool.false_eq_true, if_false] + obtain ⟨hnone, hsome⟩ := ih (some a) hts (fun a' ha' => by cases ha'; exact ha) + refine ⟨⟨fun h => absurd (hnone.mp h).1 (by simp), fun h => by simp at h⟩, fun m hm => ?_⟩ + obtain ⟨hmem, hle, hlea⟩ := hsome m hm + refine ⟨?_, fun x hx => ?_, hlea⟩ + · rcases hmem with h | h + · exact Or.inl (List.mem_cons_of_mem _ h) + · exact Or.inr h + · rcases List.mem_cons.mp hx with h | h + · subst h + cases h : lt (abs x) (abs m) + · rfl + · exfalso + rcases hlea a rfl with h' | h' + · subst h'; exact hb h + · exact hb (htrans _ _ _ h h') + · exact hle x h + +/-- Two least elements of the same list are equal when the order is total. -/ +theorem least_unique {β : Type} (lt : β → β → Bool) + (htot : ∀ x y, x ≠ y → lt x y = true ∨ lt y x = true) {L : List β} {m m' : β} + (hm : m ∈ L) (hm' : m' ∈ L) (h : ∀ x ∈ L, lt x m = false) (h' : ∀ x ∈ L, lt x m' = false) : + m = m' := by + by_cases he : m = m' + · exact he + · rcases htot m m' he with h1 | h1 + · rw [h' m hm] at h1; cases h1 + · rw [h m' hm'] at h1; cases h1 + +/-! ## The specification's step, cell by cell -/ + +/-- The candidate of a knapsack layer from cell `c` (value `e`) and table +entry `k` (value `x`): the summed Δ and the merged set. -/ +def knapCand (e x : _root_.Int × Array Nat) : _root_.Int × Array Nat := + (e.1 + x.1, mergeSorted e.2 x.2) + +/-- The inner update of `knapStep` for source cell `c` with value `e`. -/ +def knapInner (cap c : Nat) (e : _root_.Int × Array Nat) (bySize : CTable) + (ndp : Array (Option (_root_.Int × Array Nat))) (k : Nat) : + Array (Option (_root_.Int × Array Nat)) := + (bySize[k]!).elim ndp fun x => + if c + k > cap then ndp + else if betterEntry (knapCand e x) ndp[c + k]! then ndp.set! (c + k) (some (knapCand e x)) + else ndp + +/-- `knapStep` with the matches written as `Option.elim`. -/ +def knapStepElim (cap : Nat) (dp : Array (Option (_root_.Int × Array Nat))) (bySize : CTable) : + Array (Option (_root_.Int × Array Nat)) := + (List.range dp.size).foldl (fun ndp c => + (dp[c]!).elim ndp fun e => (List.range bySize.size).foldl (knapInner cap c e bySize) ndp) + (Array.replicate (cap + 1) none) + +theorem knapStep_eq_elim : @knapStep = @knapStepElim := by + funext cap dp bySize + unfold knapStep knapStepElim + congr 1 + funext ndp c + cases dp[c]! with + | none => rfl + | some e => + obtain ⟨d, s⟩ := e + simp only [Option.elim] + congr 1 + funext ndp k + unfold knapInner knapCand + cases bySize[k]! with + | none => rfl + | some x => obtain ⟨dk, sk⟩ := x; rfl + +/-- The step of the least-candidate fold. -/ +def betterStep (acc : Option (_root_.Int × Array Nat)) (x : _root_.Int × Array Nat) : + Option (_root_.Int × Array Nat) := + if betterEntry x acc then some x else acc + +/-- The candidate of the source cell `c` (value `e`) for the target `t`, among the +table entries below `n`: at most one. -/ +def srcCands (cap c : Nat) (e : _root_.Int × Array Nat) (bySize : CTable) (n t : Nat) : + List (_root_.Int × Array Nat) := + if c ≤ t ∧ t - c < n ∧ t ≤ cap then (bySize[t - c]!).elim [] fun x => [knapCand e x] else [] + +theorem getElem!_set!_ne' {α : Type} [Inhabited α] (a : Array α) (i j : Nat) (v : α) + (h : i ≠ j) : (a.set! i v)[j]! = a[j]! := by + simp only [Array.set!_eq_setIfInBounds, getElem!_def] + rw [Array.getElem?_setIfInBounds] + simp [h] + +theorem getElem!_set!_self' {α : Type} [Inhabited α] (a : Array α) (i : Nat) (v : α) + (h : i < a.size) : (a.set! i v)[i]! = v := by + simp only [Array.set!_eq_setIfInBounds, getElem!_def] + rw [Array.getElem?_setIfInBounds] + simp [h] + +/-- The inner loop of a source cell updates each target at most once. -/ +theorem knapInner_fold (cap c : Nat) (e : _root_.Int × Array Nat) (bySize : CTable) : + ∀ (n : Nat) (ndp : Array (Option (_root_.Int × Array Nat))), ndp.size = cap + 1 → + ((List.range n).foldl (knapInner cap c e bySize) ndp).size = cap + 1 ∧ + ∀ t, t ≤ cap → ((List.range n).foldl (knapInner cap c e bySize) ndp)[t]! = + (srcCands cap c e bySize n t).foldl betterStep ndp[t]! := by + intro n + induction n with + | zero => intro ndp hs; simp [hs, srcCands] + | succ n ih => + intro ndp hs + simp only [List.range_succ, List.foldl_append, List.foldl_cons, List.foldl_nil] + obtain ⟨hsz, hval⟩ := ih ndp hs + generalize hr : (List.range n).foldl (knapInner cap c e bySize) ndp = r at hsz hval + -- targets other than `c + n` are unchanged by entry `n` + have hsame : ∀ t, t ≤ cap → t ≠ c + n → + srcCands cap c e bySize (n + 1) t = srcCands cap c e bySize n t := by + intro t _ htn + unfold srcCands + by_cases h1 : c ≤ t ∧ t - c < n ∧ t ≤ cap + · have : c ≤ t ∧ t - c < n + 1 ∧ t ≤ cap := ⟨h1.1, by omega, h1.2.2⟩ + rw [if_pos this, if_pos h1] + · have : ¬(c ≤ t ∧ t - c < n + 1 ∧ t ≤ cap) := by omega + rw [if_neg this, if_neg h1] + -- the target `c + n` gets entry `n`'s candidate, if any + have hnew : c + n ≤ cap → srcCands cap c e bySize (n + 1) (c + n) = + (bySize[n]!).elim [] fun x => [knapCand e x] := by + intro hle + unfold srcCands + have : c ≤ c + n ∧ c + n - c < n + 1 ∧ c + n ≤ cap := ⟨by omega, by omega, hle⟩ + rw [if_pos this, Nat.add_sub_cancel_left] + have hold : c + n ≤ cap → srcCands cap c e bySize n (c + n) = [] := by + intro _ + unfold srcCands + have : ¬(c ≤ c + n ∧ c + n - c < n ∧ c + n ≤ cap) := by omega + rw [if_neg this] + unfold knapInner + cases hb : bySize[n]! with + | none => + simp only [Option.elim_none] + refine ⟨hsz, fun t ht => ?_⟩ + rw [hval t ht] + by_cases htn : t = c + n + · subst htn + rw [hnew ht, hold ht, hb] + rfl + · rw [hsame t ht htn] + | some x => + simp only [Option.elim_some] + by_cases hcap : c + n > cap + · simp only [hcap, if_true] + refine ⟨hsz, fun t ht => ?_⟩ + rw [hval t ht] + have htn : t ≠ c + n := by omega + rw [hsame t ht htn] + · simp only [hcap, if_false] + have hle : c + n ≤ cap := by omega + have hlt : c + n < r.size := by omega + have hrcn : r[c + n]! = ndp[c + n]! := by + rw [hval (c + n) hle, hold hle]; rfl + have htgt : (srcCands cap c e bySize (n + 1) (c + n)).foldl betterStep ndp[c + n]! = + betterStep ndp[c + n]! (knapCand e x) := by + rw [hnew hle, hb]; rfl + split + · rename_i hbet + refine ⟨by simp [hsz], fun t ht => ?_⟩ + by_cases htc : t = c + n + · subst htc + rw [getElem!_set!_self' _ _ _ hlt, htgt] + rw [hrcn] at hbet + simp [betterStep, hbet] + · rw [getElem!_set!_ne' _ _ _ _ (fun h => htc h.symm), hval t ht, hsame t ht htc] + · rename_i hbet + refine ⟨hsz, fun t ht => ?_⟩ + by_cases htc : t = c + n + · subst htc + rw [hrcn, htgt] + rw [hrcn] at hbet + simp [betterStep, hbet] + · rw [hval t ht, hsame t ht htc] + +/-- The outer loop of `knapStep`: each target holds the least of the +candidates of the sources so far, in source order. -/ +theorem knapStepElim_fold (cap : Nat) (dp : Array (Option (_root_.Int × Array Nat))) + (bySize : CTable) : + ∀ (m : Nat), + let r := (List.range m).foldl (fun ndp c => + (dp[c]!).elim ndp fun e => (List.range bySize.size).foldl (knapInner cap c e bySize) ndp) + (Array.replicate (cap + 1) none) + r.size = cap + 1 ∧ ∀ t, t ≤ cap → + r[t]! = ((List.range m).flatMap fun c => + (dp[c]!).elim [] fun e => srcCands cap c e bySize bySize.size t).foldl betterStep none := by + intro m + induction m with + | zero => + refine ⟨by simp, fun t ht => ?_⟩ + rw [getElem!_pos _ t (by simp; omega)] + simp + | succ m ih => + obtain ⟨hsz, hval⟩ := ih + simp only [List.range_succ, List.foldl_append, List.foldl_cons, List.foldl_nil, + List.flatMap_append, List.flatMap_cons, List.flatMap_nil, List.append_nil] + generalize hr : (List.range m).foldl (fun ndp c => + (dp[c]!).elim ndp fun e => (List.range bySize.size).foldl (knapInner cap c e bySize) ndp) + (Array.replicate (cap + 1) none) = r at hsz hval + cases hd : dp[m]! with + | none => + simp only [Option.elim_none] + exact ⟨hsz, hval⟩ + | some e => + simp only [Option.elim_some] + obtain ⟨hsz', hval'⟩ := knapInner_fold cap m e bySize bySize.size r hsz + refine ⟨hsz', fun t ht => ?_⟩ + rw [hval' t ht, hval t ht] + +/-- `knapStep`'s cell `t`: the least candidate over the sources. -/ +theorem knapStep_get (cap : Nat) (dp : Array (Option (_root_.Int × Array Nat))) (bySize : CTable) : + (knapStep cap dp bySize).size = cap + 1 ∧ ∀ t, t ≤ cap → + (knapStep cap dp bySize)[t]! = ((List.range dp.size).flatMap fun c => + (dp[c]!).elim [] fun e => srcCands cap c e bySize bySize.size t).foldl betterStep none := by + rw [knapStep_eq_elim] + exact knapStepElim_fold cap dp bySize dp.size + +/-! ## The fast knapsack -/ + +/-- The entry set at count `k` of a table (empty if there is none). -/ +@[inline] def entrySet (tab : CTable) (k : Nat) : Array Nat := (tab[k]!).elim #[] (·.2) + +/-- A knapsack layer: per cell the least Δ (if any), the rank of its set +among the layer's sets in `setPrec` order, and the sparse table of the first +differences of rank-adjacent sets. -/ +structure KLayer where + delta : Array (Option _root_.Int) + rank : Array Nat + sp : Array (Array Nat) + +/-- The least element of the symmetric difference of the sets of two cells of +a layer (`none` for the same cell). -/ +def prevFD (L : KLayer) (a b : Nat) : Option Nat := + if a = b then none + else some (sparseQuery L.sp (min L.rank[a]! L.rank[b]!) (max L.rank[a]! L.rank[b]!)) + +/-- The least element of the symmetric difference of the sets of two +candidates: cell `a` of the previous layer with entry `ka` of the table, and +cell `b` with entry `kb`. -/ +def candFD (L : KLayer) (tab : CTable) (a ka b kb : Nat) : Option Nat := + minOpt (prevFD L a b) (firstDiff (entrySet tab ka).toList (entrySet tab kb).toList) + +/-- Whether the set of candidate `(a, ka)` precedes that of `(b, kb)` in +`setPrec` order: the set without their least differing term. -/ +def candPrec (L : KLayer) (tab : CTable) (a ka b kb : Nat) : Bool := + (candFD L tab a ka b kb).elim false fun m => + if prevFD L a b == some m then decide (L.rank[a]! < L.rank[b]!) + else !(entrySet tab ka).contains m + +/-- A candidate `(Δ, previous cell, entry count)` is better than another. -/ +def candBetter (L : KLayer) (tab : CTable) (x y : _root_.Int × Nat × Nat) : Bool := + x.1 < y.1 || (x.1 == y.1 && candPrec L tab x.2.1 x.2.2 y.2.1 y.2.2) + +/-- The candidates of cell `c`: entry `k` of the table with cell `c - k` of the +previous layer. -/ +def cellCands (L : KLayer) (tab : CTable) (c : Nat) : List (_root_.Int × Nat × Nat) := + (List.range (min c (tab.size - 1) + 1)).filterMap fun k => + (tab[k]!).bind fun x => (L.delta[c - k]!).map fun da => (da + x.1, c - k, k) + +/-- The step of the fold keeping the best candidate. -/ +def candStep (L : KLayer) (tab : CTable) (acc : Option (_root_.Int × Nat × Nat)) + (x : _root_.Int × Nat × Nat) : Option (_root_.Int × Nat × Nat) := + acc.elim (some x) fun y => if candBetter L tab x y then some x else some y + +/-- The best candidate of cell `c`. -/ +def cellBest (L : KLayer) (tab : CTable) (c : Nat) : Option (_root_.Int × Nat × Nat) := + (cellCands L tab c).foldl (candStep L tab) none + +/-- Position of every element of a list (`rank[l[i]] = i`). -/ +def rankOf (n : Nat) (l : List Nat) : Array Nat := + l.zipIdx.foldl (fun rk p => rk.set! p.1 p.2) (Array.replicate n 0) + +/-- The best candidate of every cell. -/ +def knapBest (cap : Nat) (L : KLayer) (tab : CTable) : Array (Option (_root_.Int × Nat × Nat)) := + (Array.range (cap + 1)).map (cellBest L tab) + +/-- The entry count taken by every cell. -/ +def knapTook (best : Array (Option (_root_.Int × Nat × Nat))) : Array Nat := + best.map fun o => o.elim 0 (·.2.2) + +/-- The nonempty cells of the next layer in `setPrec` order of their sets. -/ +def knapOrd (cap : Nat) (L : KLayer) (tab : CTable) (best : Array (Option (_root_.Int × Nat × Nat))) + (took : Array Nat) : List Nat := + ((List.range (cap + 1)).filter fun c => (best[c]!).isSome).mergeSort fun u v => + !candPrec L tab (v - took[v]!) took[v]! (u - took[u]!) took[u]! + +/-- The first differences of rank-adjacent sets of the next layer. -/ +def knapAdj (L : KLayer) (tab : CTable) (took : Array Nat) (ord : List Nat) : Array Nat := + let ordA := ord.toArray + (Array.range (ordA.size - 1)).map fun r => + let u := ordA[r]! + let v := ordA[r + 1]! + (candFD L tab (u - took[u]!) took[u]! (v - took[v]!) took[v]!).getD 0 + +/-- The next layer with table `tab`, and the entry count taken by every cell. -/ +def knapLayer (cap : Nat) (L : KLayer) (tab : CTable) : KLayer × Array Nat := + let best := knapBest cap L tab + let took := knapTook best + let ord := knapOrd cap L tab best took + ({ delta := best.map (·.map (·.1)), rank := rankOf (cap + 1) ord, + sp := sparseBuild (knapAdj L tab took ord) }, took) + +/-- The layer before any table: only the empty set, at count 0. -/ +def knapInit (cap : Nat) : KLayer := + { delta := #[some 0] ++ Array.replicate cap none, rank := Array.replicate (cap + 1) 0, + sp := sparseBuild #[] } + +/-- All layers: the last layer and the entry counts taken at every layer. -/ +def knapRun (cap : Nat) (tabs : List CTable) : KLayer × Array (Array Nat) := + tabs.foldl (fun acc tab => + let r := knapLayer cap acc.1 tab + (r.1, acc.2.push r.2)) (knapInit cap, #[]) + +/-- The set of cell `c` after the first `j` tables, from the entries taken. -/ +def knapRecon (tabs : Array CTable) (tooks : Array (Array Nat)) : Nat → Nat → Array Nat + | 0, _ => #[] + | j + 1, c => + let k := tooks[j]![c]! + mergeSorted (knapRecon tabs tooks j (c - k)) (entrySet tabs[j]! k) + +/-- The terms of the entries taken along the path of cell `c`. -/ +def knapCollect (tabs : Array CTable) (tooks : Array (Array Nat)) : + Nat → Nat → List Nat → List Nat + | 0, _, acc => acc + | j + 1, c, acc => + let k := tooks[j]![c]! + knapCollect tabs tooks j (c - k) ((entrySet tabs[j]! k).toList ++ acc) + +/-- `knapRecon`, merged once. -/ +def knapReconFast (tabs : Array CTable) (tooks : Array (Array Nat)) (j c : Nat) : Array Nat := + ((knapCollect tabs tooks j c []).mergeSort fun x y => decide (x ≤ y)).toArray + +/-- The cell of the least length (then the first set in `setPrec` order, by rank). -/ +def knapBestCell (kCS : Nat) (L : KLayer) (cap : Nat) : Option (_root_.Int × Nat × _root_.Int) := + (List.range (cap + 1)).foldl (fun acc c => + (L.delta[c]!).elim acc fun d => + let l : _root_.Int := d + (tag0Size (kCS + c) : _root_.Int) + acc.elim (some (l, c, d)) fun b => + if l < b.1 || (l == b.1 && decide (L.rank[c]! < L.rank[b.2.1]!)) then some (l, c, d) + else some b) none + +/-- `knapChoose` on the fast layers. -/ +def knapChooseFast (kCS cap : Nat) (tabs : Array CTable) (init : _root_.Int × Array Nat × Bool) : + _root_.Int × Array Nat × Bool := + let r := knapRun cap tabs.toList + (knapBestCell kCS r.1 cap).elim init fun b => + let s := knapReconFast tabs r.2 tabs.size b.2.1 + let l0 : _root_.Int := init.1 + (tag0Size (kCS + init.2.1.size) : _root_.Int) + if b.1 < l0 || (b.1 == l0 && setPrec s init.2.1) then (b.2.2, s, true) else init + +/-- Merge adjacent duplicates. -/ +def dedupSorted : List Nat → List Nat + | a :: b :: l => if a = b then dedupSorted (b :: l) else a :: dedupSorted (b :: l) + | l => l + +/-- The terms of a table's entries, ascending, without repeats (when it is +shaped). -/ +def tableTerms (tab : CTable) : List Nat := + dedupSorted ((tab.toList.flatMap fun o => o.elim [] (·.2.toList)).mergeSort + fun x y => decide (x ≤ y)) + +/-- Every entry of every table is an ascending list of its count's length, and +the terms of different tables are disjoint. -/ +def tablesOK (tabs : Array CTable) : Bool := + tabs.all (fun tab => (List.range tab.size).all fun k => + (tab[k]!).elim true fun x => x.2.size == k && incList x.2.toList) && + incList ((tabs.toList.flatMap tableTerms).mergeSort fun x y => decide (x ≤ y)) + +/-- `uniformKnapsack` with the rank-based knapsack (module doc). -/ +def uniformKnapsackFast (limits : Limits) (kCS : Nat) (results : Array CompResult) : + Except SharingError (_root_.Int × Array Nat × Bool) := do + let bestX := ((results.foldl (fun acc r => acc ++ r.bestSet) #[]).toList.mergeSort + fun x y => decide (x ≤ y)).toArray + let bestDelta := results.foldl (fun acc r => acc + r.bestDelta) (0 : _root_.Int) + let start := tag0BracketStart (kCS + bestX.size) + if start > kCS then + let cap := start - 1 - kCS + if (results.size + 1) * (cap + 1) > limits.maxKnapsackCells then + throw (.resourceExhausted .knapsackCells limits.maxKnapsackCells) + let tabs := results.map (·.bySize) + if tablesOK tabs then + pure (knapChooseFast kCS cap tabs (bestDelta, bestX, false)) + else + let dp := results.foldl (fun dp r => knapStep cap dp r.bySize) + (#[some (0, #[])] ++ Array.replicate cap none) + pure (knapChoose kCS dp (bestDelta, bestX, false)) + else pure (bestDelta, bestX, false) + +/-! ## Sorted merges and the guard -/ + +theorem incList_pairwise : ∀ (l : List Nat), incList l = true → l.Pairwise (· < ·) + | [], _ => List.Pairwise.nil + | [_], _ => by simp + | a :: b :: l, h => by + have hlt := incList_lt a (b :: l) h + have h2 : incList (b :: l) = true := by + simp only [incList, Bool.and_eq_true] at h + exact h.2 + exact List.pairwise_cons.mpr ⟨hlt, incList_pairwise (b :: l) h2⟩ + +theorem le_trans_dec (a b c : Nat) (h₁ : decide (a ≤ b) = true) (h₂ : decide (b ≤ c) = true) : + decide (a ≤ c) = true := by + simp only [decide_eq_true_eq] at *; omega + +theorem le_total_dec (a b : Nat) : (decide (a ≤ b) || decide (b ≤ a)) = true := by + simp only [Bool.or_eq_true, decide_eq_true_eq]; omega + +theorem mergeSorted_perm (a b : Array Nat) : + (mergeSorted a b).toList.Perm (a.toList ++ b.toList) := by + unfold mergeSorted + exact List.mergeSort_perm _ _ + +theorem mem_mergeSorted {a b : Array Nat} {z : Nat} : + z ∈ (mergeSorted a b).toList ↔ z ∈ a.toList ∨ z ∈ b.toList := by + rw [(mergeSorted_perm a b).mem_iff, List.mem_append] + +theorem mergeSorted_size (a b : Array Nat) : (mergeSorted a b).size = a.size + b.size := by + rw [← Array.length_toList, (mergeSorted_perm a b).length_eq] + simp + +/-- An ascending list without repeats is strictly ascending. -/ +theorem pairwise_lt_of_le {l : List Nat} (hle : l.Pairwise fun x y => decide (x ≤ y) = true) + (hnd : l.Nodup) : l.Pairwise (· < ·) := by + have := hle.and hnd + exact this.imp fun ⟨h1, h2⟩ => by simp only [decide_eq_true_eq] at h1; omega + +/-- The merge of two disjoint strictly ascending arrays is strictly ascending. -/ +theorem mergeSorted_sorted {a b : Array Nat} (ha : a.toList.Pairwise (· < ·)) + (hb : b.toList.Pairwise (· < ·)) (hdisj : ∀ z ∈ a.toList, z ∉ b.toList) : + (mergeSorted a b).toList.Pairwise (· < ·) := by + apply pairwise_lt_of_le + · unfold mergeSorted + exact List.pairwise_mergeSort le_trans_dec le_total_dec _ + · apply List.Nodup.perm _ (mergeSorted_perm a b).symm + exact List.nodup_append.mpr ⟨ha.imp Nat.ne_of_lt, hb.imp Nat.ne_of_lt, + fun x hx y hy hxy => hdisj x hx (hxy ▸ hy)⟩ + +theorem firstDiff_comm {A B : List Nat} (hA : A.Pairwise (· < ·)) (hB : B.Pairwise (· < ·)) : + firstDiff A B = firstDiff B A := by + cases h : firstDiff A B with + | none => + have := (firstDiff_none hA hB).mp h + subst this + exact h.symm + | some m => + exact ((firstDiff_eq_some_iff hB hA).mpr ((firstDiff_eq_some_iff hA hB).mp h).symm).symm + +theorem dedupSorted_mem : ∀ (l : List Nat) (z : Nat), z ∈ dedupSorted l ↔ z ∈ l + | [], z => by simp [dedupSorted] + | [a], z => by simp [dedupSorted] + | a :: b :: l, z => by + have ih := dedupSorted_mem (b :: l) z + by_cases hab : a = b + · subst hab + simp only [dedupSorted, if_true, ih, List.mem_cons] + constructor + · intro h; exact Or.inr h + · rintro (h | h) + · exact Or.inl h + · exact h + · simp only [dedupSorted, hab, if_false, List.mem_cons, ih] + +/-- The terms of the entries of a table. -/ +def InTable (tab : CTable) (z : Nat) : Prop := + ∃ k : Nat, ∃ x : _root_.Int × Array Nat, tab[k]! = some x ∧ z ∈ x.2.toList + +/-- The terms of the first `j` tables. -/ +def InPrev (tabs : Array CTable) (j z : Nat) : Prop := ∃ i, i < j ∧ InTable tabs[i]! z + +theorem mem_tableTerms {tab : CTable} {z : Nat} (h : InTable tab z) : z ∈ tableTerms tab := by + obtain ⟨k, x, hk, hz⟩ := h + unfold tableTerms + rw [dedupSorted_mem, List.mem_mergeSort, List.mem_flatMap] + have hks : k < tab.size := by + by_cases hk' : k < tab.size + · exact hk' + · rw [getElem!_neg tab k hk'] at hk; cases hk + refine ⟨some x, ?_, by simpa using hz⟩ + rw [getElem!_pos tab k hks] at hk + rw [← hk] + exact Array.getElem_mem_toList hks + +/-- The entries are shaped: ascending lists of their count's length. -/ +theorem tablesOK_shape {tabs : Array CTable} (h : tablesOK tabs = true) {j : Nat} + (hj : j < tabs.size) {k : Nat} {x : _root_.Int × Array Nat} (hx : tabs[j]![k]! = some x) : + x.2.size = k ∧ x.2.toList.Pairwise (· < ·) := by + unfold tablesOK at h + rw [Bool.and_eq_true, Array.all_eq_true] at h + have hj' := h.1 j hj + rw [getElem!_pos tabs j hj] at hx + have hks : k < tabs[j].size := by + by_cases hk' : k < tabs[j].size + · exact hk' + · rw [getElem!_neg _ k hk'] at hx; cases hx + rw [List.all_eq_true] at hj' + have := hj' k (List.mem_range.mpr hks) + rw [hx] at this + simp only [Option.elim_some, Bool.and_eq_true, beq_iff_eq] at this + exact ⟨this.1, incList_pairwise _ this.2⟩ + +/-- The terms of different tables are disjoint. -/ +theorem tablesOK_disjoint {tabs : Array CTable} (h : tablesOK tabs = true) {i j : Nat} + (hij : i < j) (hj : j < tabs.size) {z : Nat} (hi : InTable tabs[i]! z) : + ¬ InTable tabs[j]! z := by + intro hjz + unfold tablesOK at h + rw [Bool.and_eq_true] at h + have hnd : (tabs.toList.flatMap tableTerms).Nodup := by + have := (incList_pairwise _ h.2).imp Nat.ne_of_lt + exact this.perm (List.mergeSort_perm _ _) (fun h => fun h' => h h'.symm) + rw [List.Nodup, List.pairwise_flatMap] at hnd + have hpw := List.pairwise_iff_getElem.mp hnd.2 i j (by simp; omega) (by simpa using hj) hij + simp only [Array.getElem_toList] at hpw + rw [getElem!_pos tabs i (by omega)] at hi + rw [getElem!_pos tabs j hj] at hjz + exact hpw z (mem_tableTerms hi) z (mem_tableTerms hjz) rfl + +/-! ## The layer invariant -/ + +/-- A fast layer represents the specification's layer `dp` after the first `j` +tables, with the cells' sets `recon`. -/ +structure LayerInv (cap : Nat) (tabs : Array CTable) (j : Nat) + (dp : Array (Option (_root_.Int × Array Nat))) (L : KLayer) (recon : Nat → Array Nat) : + Prop where + size : dp.size = cap + 1 + cell : ∀ c, c ≤ cap → dp[c]! = (L.delta[c]!).map fun d => (d, recon c) + sorted : ∀ c, c ≤ cap → (L.delta[c]!).isSome → (recon c).toList.Pairwise (· < ·) + card : ∀ c, c ≤ cap → (L.delta[c]!).isSome → (recon c).size = c + dom : ∀ c, c ≤ cap → (L.delta[c]!).isSome → ∀ z ∈ (recon c).toList, InPrev tabs j z + rank : ∀ a b, a ≤ cap → b ≤ cap → (L.delta[a]!).isSome → (L.delta[b]!).isSome → a ≠ b → + (L.rank[a]! < L.rank[b]! ↔ setPrec (recon a) (recon b) = true) + fd : ∀ a b, a ≤ cap → b ≤ cap → (L.delta[a]!).isSome → (L.delta[b]!).isSome → + L.rank[a]! < L.rank[b]! → + firstDiff (recon a).toList (recon b).toList = some (sparseQuery L.sp L.rank[a]! L.rank[b]!) + +/-- Sets of distinct nonempty cells differ (their sizes do). -/ +theorem LayerInv.ne {cap : Nat} {tabs : Array CTable} {j : Nat} {dp} {L : KLayer} {recon} + (h : LayerInv cap tabs j dp L recon) {a b : Nat} (ha : a ≤ cap) (hb : b ≤ cap) + (hda : (L.delta[a]!).isSome) (hdb : (L.delta[b]!).isSome) (hab : a ≠ b) : + recon a ≠ recon b := by + intro he + have := congrArg Array.size he + rw [h.card a ha hda, h.card b hb hdb] at this + exact hab this + +theorem LayerInv.prevFD_eq {cap : Nat} {tabs : Array CTable} {j : Nat} {dp} {L : KLayer} {recon} + (h : LayerInv cap tabs j dp L recon) {a b : Nat} (ha : a ≤ cap) (hb : b ≤ cap) + (hda : (L.delta[a]!).isSome) (hdb : (L.delta[b]!).isSome) : + prevFD L a b = firstDiff (recon a).toList (recon b).toList := by + unfold prevFD + by_cases hab : a = b + · subst hab + rw [if_pos rfl, (firstDiff_none (h.sorted a ha hda) (h.sorted a ha hda)).mpr rfl] + · rw [if_neg hab] + rcases Nat.lt_trichotomy L.rank[a]! L.rank[b]! with hlt | heq | hgt + · rw [Nat.min_eq_left (Nat.le_of_lt hlt), Nat.max_eq_right (Nat.le_of_lt hlt)] + exact (h.fd a b ha hb hda hdb hlt).symm + · exfalso + have h1 := (h.rank a b ha hb hda hdb hab) + have h2 := (h.rank b a hb ha hdb hda (fun e => hab e.symm)) + rw [heq] at h1 h2 + simp only [Nat.lt_irrefl, false_iff] at h1 h2 + rcases setPrec_total' (h.ne ha hb hda hdb hab) with h3 | h3 + · rw [h3] at h1; exact h1 rfl + · rw [h3] at h2; exact h2 rfl + · rw [Nat.min_eq_right (Nat.le_of_lt hgt), Nat.max_eq_left (Nat.le_of_lt hgt)] + rw [firstDiff_comm (h.sorted a ha hda) (h.sorted b hb hdb)] + exact (h.fd b a hb ha hdb hda hgt).symm + +/-- The merged set of a candidate: cell `a`'s set with entry `k`. -/ +def candSet (recon : Nat → Array Nat) (tab : CTable) (a k : Nat) : Array Nat := + mergeSorted (recon a) (entrySet tab k) + +theorem minOpt_some {p q : Option Nat} {m : Nat} (h : minOpt p q = some m) : + p = some m ∨ (q = some m ∧ ∀ p', p = some p' → m < p' ∨ m = p') := by + cases p with + | none => cases q with + | none => simp [minOpt] at h + | some b => simp only [minOpt] at h; exact Or.inr ⟨h, fun p' hp => by cases hp⟩ + | some a => cases q with + | none => simp only [minOpt] at h; exact Or.inl h + | some b => + simp only [minOpt, Option.some.injEq] at h + by_cases hab : a ≤ b + · rw [Nat.min_eq_left hab] at h; exact Or.inl (by rw [h]) + · rw [Nat.min_eq_right (by omega)] at h + exact Or.inr ⟨by rw [h], fun p' hp => by cases hp; omega⟩ + +section Step + +variable {cap : Nat} {tabs : Array CTable} {j : Nat} {dp : Array (Option (_root_.Int × Array Nat))} + {L : KLayer} {recon : Nat → Array Nat} + +theorem entrySet_shape (hok : tablesOK tabs = true) (hj : j < tabs.size) (k : Nat) : + (entrySet tabs[j]! k).toList.Pairwise (· < ·) := by + unfold entrySet + cases hk : tabs[j]![k]! with + | none => simp + | some x => exact (tablesOK_shape hok hj hk).2 + +theorem entrySet_size (hok : tablesOK tabs = true) (hj : j < tabs.size) {k : Nat} + (hk : (tabs[j]![k]!).isSome) : (entrySet tabs[j]! k).size = k := by + unfold entrySet + cases hk' : tabs[j]![k]! with + | none => rw [hk'] at hk; cases hk + | some x => exact (tablesOK_shape hok hj hk').1 + +theorem entrySet_inTable {tab : CTable} {k z : Nat} (h : z ∈ (entrySet tab k).toList) : + InTable tab z := by + unfold entrySet at h + cases hk : tab[k]! with + | none => rw [hk] at h; simp at h + | some x => rw [hk] at h; exact ⟨k, x, hk, h⟩ + +/-- A term of the previous tables is not in the current table. -/ +theorem notInTable_of_prev (hok : tablesOK tabs = true) (hj : j < tabs.size) {z : Nat} + (hz : InPrev tabs j z) : ¬ InTable tabs[j]! z := by + obtain ⟨i, hij, hi⟩ := hz + exact tablesOK_disjoint hok hij hj hi + +theorem candSet_sorted (hok : tablesOK tabs = true) (hj : j < tabs.size) + (h : LayerInv cap tabs j dp L recon) {a k : Nat} (ha : a ≤ cap) (hda : (L.delta[a]!).isSome) : + (candSet recon tabs[j]! a k).toList.Pairwise (· < ·) := + mergeSorted_sorted (h.sorted a ha hda) (entrySet_shape hok hj k) + (fun z hz hz' => notInTable_of_prev hok hj (h.dom a ha hda z hz) (entrySet_inTable hz')) + +theorem candFD_eq (hok : tablesOK tabs = true) (hj : j < tabs.size) + (h : LayerInv cap tabs j dp L recon) {a ka b kb : Nat} (ha : a ≤ cap) (hb : b ≤ cap) + (hda : (L.delta[a]!).isSome) (hdb : (L.delta[b]!).isSome) : + candFD L tabs[j]! a ka b kb = + firstDiff (candSet recon tabs[j]! a ka).toList (candSet recon tabs[j]! b kb).toList := by + unfold candFD + rw [h.prevFD_eq ha hb hda hdb] + symm + apply firstDiff_union (h.sorted a ha hda) (h.sorted b hb hdb) (entrySet_shape hok hj ka) + (entrySet_shape hok hj kb) (candSet_sorted hok hj h ha hda) (candSet_sorted hok hj h hb hdb) + (fun z => mem_mergeSorted) (fun z => mem_mergeSorted) + intro z hz + have hp : InPrev tabs j z := by + rcases hz with hz | hz + · exact h.dom a ha hda z hz + · exact h.dom b hb hdb z hz + exact ⟨fun hx => notInTable_of_prev hok hj hp (entrySet_inTable hx), + fun hy => notInTable_of_prev hok hj hp (entrySet_inTable hy)⟩ + +theorem candPrec_eq (hok : tablesOK tabs = true) (hj : j < tabs.size) + (h : LayerInv cap tabs j dp L recon) {a ka b kb : Nat} (ha : a ≤ cap) (hb : b ≤ cap) + (hda : (L.delta[a]!).isSome) (hdb : (L.delta[b]!).isSome) : + candPrec L tabs[j]! a ka b kb = + setPrec (candSet recon tabs[j]! a ka) (candSet recon tabs[j]! b kb) := by + have hU := candSet_sorted (k := ka) hok hj h ha hda + have hV := candSet_sorted (k := kb) hok hj h hb hdb + have hfd := candFD_eq (ka := ka) (kb := kb) hok hj h ha hb hda hdb + apply Bool.eq_iff_iff.mpr + rw [setPrec_iff hU hV] + unfold candPrec + rw [hfd] + cases hm : firstDiff (candSet recon tabs[j]! a ka).toList (candSet recon tabs[j]! b kb).toList with + | none => simp + | some m => + simp only [Option.elim_some, Option.some.injEq, exists_eq_left'] + have hmfd := (firstDiff_eq_some_iff hU hV).mp hm + -- where `m` comes from + have hcand := hfd ▸ hm + unfold candFD at hcand + by_cases hpm : prevFD L a b = some m + · simp only [hpm, beq_self_eq_true, if_true, decide_eq_true_eq] + have hab : a ≠ b := by intro e; subst e; simp [prevFD] at hpm + rw [h.prevFD_eq ha hb hda hdb] at hpm + have hrm := (firstDiff_eq_some_iff (h.sorted a ha hda) (h.sorted b hb hdb)).mp hpm + have hmp : InPrev tabs j m := by + by_cases hma : m ∈ (recon a).toList + · exact h.dom a ha hda m hma + · obtain ⟨hrm1, _⟩ := hrm + apply h.dom b hb hdb m + by_cases hmb : m ∈ (recon b).toList + · exact hmb + · exact absurd (hrm1.mpr hmb) hma + have hmY : m ∉ (entrySet tabs[j]! kb).toList := + fun hy => notInTable_of_prev hok hj hmp (entrySet_inTable hy) + rw [h.rank a b ha hb hda hdb hab, setPrec_iff (h.sorted a ha hda) (h.sorted b hb hdb), hpm] + simp only [Option.some.injEq, exists_eq_left'] + unfold candSet + rw [mem_mergeSorted] + simp [hmY] + · have hpm' : (prevFD L a b == some m) = false := by + simp only [beq_eq_false_iff_ne, ne_eq]; exact hpm + simp only [hpm', Bool.false_eq_true, if_false, Bool.not_eq_true'] + rcases minOpt_some hcand with hp | ⟨hq, _⟩ + · exact absurd hp hpm + · have hxy := (firstDiff_eq_some_iff (entrySet_shape hok hj ka) (entrySet_shape hok hj kb)).mp hq + obtain ⟨hxy1, _⟩ := hxy + have hmT : InTable tabs[j]! m := by + by_cases hmx : m ∈ (entrySet tabs[j]! ka).toList + · exact entrySet_inTable hmx + · apply entrySet_inTable (k := kb) + by_cases hmy : m ∈ (entrySet tabs[j]! kb).toList + · exact hmy + · exact absurd (hxy1.mpr hmy) hmx + have hmB : m ∉ (recon b).toList := + fun hb' => notInTable_of_prev hok hj (h.dom b hb hdb m hb') hmT + unfold candSet + rw [mem_mergeSorted] + simp only [hmB, false_or] + by_cases hx : m ∈ (entrySet tabs[j]! ka).toList + · have hc : (entrySet tabs[j]! ka).contains m = true := + Array.contains_iff_mem.mpr (Array.mem_toList_iff.mp hx) + rw [hc] + simp only [Bool.true_eq_false, false_iff] + exact hxy1.mp hx + · have hc : (entrySet tabs[j]! ka).contains m = false := by + cases hcc : (entrySet tabs[j]! ka).contains m + · rfl + · exact absurd (Array.mem_toList_iff.mpr (Array.contains_iff_mem.mp hcc)) hx + rw [hc] + simp only [true_iff] + by_cases hy : m ∈ (entrySet tabs[j]! kb).toList + · exact hy + · exact absurd (hxy1.mpr hy) hx + +/-- The value of a fast candidate: its Δ and merged set. -/ +def candVal (recon : Nat → Array Nat) (tab : CTable) (x : _root_.Int × Nat × Nat) : + _root_.Int × Array Nat := + (x.1, candSet recon tab x.2.1 x.2.2) + +theorem candBetter_eq (hok : tablesOK tabs = true) (hj : j < tabs.size) + (h : LayerInv cap tabs j dp L recon) {x y : _root_.Int × Nat × Nat} + (hx : x.2.1 ≤ cap ∧ (L.delta[x.2.1]!).isSome) (hy : y.2.1 ≤ cap ∧ (L.delta[y.2.1]!).isSome) : + candBetter L tabs[j]! x y = entryLt (candVal recon tabs[j]! x) (candVal recon tabs[j]! y) := by + unfold candBetter entryLt candVal + rw [candPrec_eq hok hj h hx.1 hy.1 hx.2 hy.2] + +theorem mem_cellCands {tab : CTable} {t : Nat} {x : _root_.Int × Nat × Nat} : + x ∈ cellCands L tab t ↔ ∃ k xk da, k ≤ t ∧ k < tab.size ∧ tab[k]! = some xk ∧ + L.delta[t - k]! = some da ∧ x = (da + xk.1, t - k, k) := by + unfold cellCands + rw [List.mem_filterMap] + constructor + · rintro ⟨k, hk, hx⟩ + rw [List.mem_range] at hk + cases htk : tab[k]! with + | none => rw [htk] at hx; cases hx + | some xk => + rw [htk] at hx + cases hd : L.delta[t - k]! with + | none => rw [hd] at hx; simp at hx + | some da => + rw [hd] at hx + simp only [Option.bind_some, Option.map_some, Option.some.injEq] at hx + have hks : k < tab.size := by + by_cases hk' : k < tab.size + · exact hk' + · rw [getElem!_neg tab k hk'] at htk; cases htk + exact ⟨k, xk, da, by omega, hks, htk, hd, hx.symm⟩ + · rintro ⟨k, xk, da, hkt, hks, htk, hd, rfl⟩ + refine ⟨k, List.mem_range.mpr (by omega), ?_⟩ + rw [htk, Option.bind_some, hd] + rfl + +theorem cellCands_ok {tab : CTable} {t : Nat} (ht : t ≤ cap) {x : _root_.Int × Nat × Nat} + (hx : x ∈ cellCands L tab t) : x.2.1 ≤ cap ∧ (L.delta[x.2.1]!).isSome := by + obtain ⟨k, xk, da, hkt, _, _, hd, rfl⟩ := mem_cellCands.mp hx + exact ⟨by simp; omega, by simp [hd]⟩ + +/-- The specification's candidates of target `t` are the values of the fast +candidates. -/ +theorem specCands_iff (h : LayerInv cap tabs j dp L recon) {tab : CTable} {t : Nat} (ht : t ≤ cap) + (v : _root_.Int × Array Nat) : + v ∈ ((List.range dp.size).flatMap fun c => + (dp[c]!).elim [] fun e => srcCands cap c e tab tab.size t) ↔ + ∃ x ∈ cellCands L tab t, candVal recon tab x = v := by + rw [List.mem_flatMap] + constructor + · rintro ⟨c, hc, hv⟩ + rw [List.mem_range, h.size] at hc + rw [h.cell c (by omega)] at hv + cases hd : L.delta[c]! with + | none => rw [hd] at hv; simp at hv + | some d => + rw [hd] at hv + simp only [Option.map_some, Option.elim_some] at hv + unfold srcCands at hv + split at hv + · rename_i hcond + cases htk : tab[t - c]! with + | none => rw [htk] at hv; simp at hv + | some xk => + rw [htk] at hv + simp only [Option.elim_some, List.mem_singleton] at hv + subst hv + refine ⟨(d + xk.1, c, t - c), mem_cellCands.mpr ⟨t - c, xk, d, by omega, hcond.2.1, + htk, by rw [show t - (t - c) = c by omega]; exact hd, by rw [show t - (t - c) = c by omega]⟩, ?_⟩ + unfold candVal candSet knapCand entrySet + rw [htk] + rfl + · simp at hv + · rintro ⟨x, hx, rfl⟩ + obtain ⟨k, xk, da, hkt, hks, htk, hd, rfl⟩ := mem_cellCands.mp hx + refine ⟨t - k, List.mem_range.mpr (by rw [h.size]; omega), ?_⟩ + rw [h.cell (t - k) (by omega), hd] + simp only [Option.map_some, Option.elim_some] + unfold srcCands + have hcond : t - k ≤ t ∧ t - (t - k) < tab.size ∧ t ≤ cap := ⟨by omega, by omega, ht⟩ + rw [if_pos hcond, show t - (t - k) = k by omega, htk] + simp only [Option.elim_some, List.mem_singleton] + unfold candVal candSet knapCand entrySet + rw [htk] + rfl + +/-- Cell `t` of the next layer: the fast best candidate's value is the +specification's cell. -/ +theorem cell_step (hok : tablesOK tabs = true) (hj : j < tabs.size) + (h : LayerInv cap tabs j dp L recon) {t : Nat} (ht : t ≤ cap) : + (knapStep cap dp tabs[j]!)[t]! = (cellBest L tabs[j]! t).map (candVal recon tabs[j]!) := by + rw [(knapStep_get cap dp tabs[j]!).2 t ht] + have hspec := foldl_least (fun _ => True) id entryLt entryLt_irrefl (fun _ _ _ => entryLt_trans) + betterStep (fun x => by simp [betterStep, betterEntry]) + (fun a x _ _ => by simp only [betterStep, betterEntry_some, id]) + ((List.range dp.size).flatMap fun c => (dp[c]!).elim [] fun e => srcCands cap c e tabs[j]! tabs[j]!.size t) + none (fun _ _ => trivial) (fun _ _ => trivial) + have hfast := foldl_least (fun x => x.2.1 ≤ cap ∧ (L.delta[x.2.1]!).isSome) + (candVal recon tabs[j]!) entryLt entryLt_irrefl (fun _ _ _ => entryLt_trans) + (candStep L tabs[j]!) (fun x => rfl) + (fun a x ha hx => by + simp only [candStep, Option.elim_some] + rw [candBetter_eq hok hj h hx ha]) + (cellCands L tabs[j]! t) none (fun x hx => cellCands_ok ht hx) (fun _ h => by cases h) + obtain ⟨hsn, hss⟩ := hspec + obtain ⟨hfn, hfs⟩ := hfast + unfold cellBest + cases hfr : (cellCands L tabs[j]! t).foldl (candStep L tabs[j]!) none with + | none => + have hnil := (hfn.mp hfr).2 + rw [Option.map_none] + apply hsn.mpr + refine ⟨rfl, ?_⟩ + apply List.eq_nil_iff_forall_not_mem.mpr + intro v hv + obtain ⟨x, hx, _⟩ := (specCands_iff h ht v).mp hv + rw [hnil] at hx + simp at hx + | some m => + obtain ⟨hmem, hle, _⟩ := hfs m hfr + have hmL : m ∈ cellCands L tabs[j]! t := by + rcases hmem with h' | h' + · exact h' + · cases h' + rw [Option.map_some] + cases hsr : ((List.range dp.size).flatMap fun c => + (dp[c]!).elim [] fun e => srcCands cap c e tabs[j]! tabs[j]!.size t).foldl betterStep none with + | none => + exfalso + have hnil := (hsn.mp hsr).2 + have := (specCands_iff h ht (candVal recon tabs[j]! m)).mpr ⟨m, hmL, rfl⟩ + rw [hnil] at this + simp at this + | some v => + obtain ⟨hvmem, hvle, _⟩ := hss v hsr + have hvL : v ∈ ((List.range dp.size).flatMap fun c => + (dp[c]!).elim [] fun e => srcCands cap c e tabs[j]! tabs[j]!.size t) := by + rcases hvmem with h' | h' + · exact h' + · cases h' + congr 1 + apply least_unique entryLt (fun x y hxy => entryLt_total hxy) hvL + ((specCands_iff h ht _).mpr ⟨m, hmL, rfl⟩) hvle + intro w hw + obtain ⟨x, hx, rfl⟩ := (specCands_iff h ht w).mp hw + exact hle x hx + +theorem cellBest_mem (hok : tablesOK tabs = true) (hj : j < tabs.size) + (h : LayerInv cap tabs j dp L recon) {t : Nat} (ht : t ≤ cap) {x : _root_.Int × Nat × Nat} + (hx : cellBest L tabs[j]! t = some x) : x ∈ cellCands L tabs[j]! t := by + have hfast := foldl_least (fun x => x.2.1 ≤ cap ∧ (L.delta[x.2.1]!).isSome) + (candVal recon tabs[j]!) entryLt entryLt_irrefl (fun _ _ _ => entryLt_trans) + (candStep L tabs[j]!) (fun x => rfl) + (fun a x ha hx => by + simp only [candStep, Option.elim_some] + rw [candBetter_eq hok hj h hx ha]) + (cellCands L tabs[j]! t) none (fun x hx => cellCands_ok ht hx) (fun _ h => by cases h) + rcases (hfast.2 x hx).1 with h' | h' + · exact h' + · cases h' + +end Step + +theorem rankOf_aux (n : Nat) : + ∀ (l : List Nat) (s : Nat) (A : Array Nat), l.Nodup → A.size = n → + ((l.zipIdx s).foldl (fun rk p => rk.set! p.1 p.2) A).size = n ∧ + ∀ x, x < n → ((l.zipIdx s).foldl (fun rk p => rk.set! p.1 p.2) A)[x]! = + if x ∈ l then l.idxOf x + s else A[x]! := by + intro l + induction l with + | nil => intro s A _ hA; simp [hA] + | cons a l ih => + intro s A hnd hA + rw [List.nodup_cons] at hnd + simp only [List.zipIdx_cons, List.foldl_cons] + obtain ⟨hsz, hval⟩ := ih (s + 1) (A.set! a s) hnd.2 (by simp [hA]) + refine ⟨hsz, fun x hx => ?_⟩ + rw [hval x hx] + by_cases hxa : x = a + · subst hxa + simp only [hnd.1, if_false, List.mem_cons_self, if_true, List.idxOf_cons_self] + rw [getElem!_set!_self' _ _ _ (by omega)] + omega + · have hax : (a == x) = false := by simp only [beq_eq_false_iff_ne, ne_eq]; exact fun h => hxa h.symm + rw [getElem!_set!_ne' _ _ _ _ (fun h => hxa h.symm)] + by_cases hxl : x ∈ l + · simp only [hxl, if_true, List.mem_cons, hxa, false_or, List.idxOf_cons, hax, cond_false] + omega + · simp only [hxl, if_false, List.mem_cons, hxa, false_or] + +theorem rankOf_get {n : Nat} {l : List Nat} (hnd : l.Nodup) {x : Nat} (hx : x < n) (hxl : x ∈ l) : + (rankOf n l)[x]! = l.idxOf x := by + unfold rankOf + rw [(rankOf_aux n l 0 (Array.replicate n 0) hnd (by simp)).2 x hx, if_pos hxl] + rfl + +/-! ## Ranks of the next layer -/ + +/-- Sorting cells by a comparator that is `setPrec` on their (distinct) sets +puts the sets in `setPrec` order. -/ +theorem mergeSort_setPrec (S : Nat → Array Nat) (cells : List Nat) (r : Nat → Nat → Bool) + (hr : ∀ u ∈ cells, ∀ v ∈ cells, r u v = !setPrec (S v) (S u)) + (hdist : ∀ u ∈ cells, ∀ v ∈ cells, u ≠ v → S u ≠ S v) (hnd : cells.Nodup) : + ∀ i k (hi : i < k) (hk : k < (cells.mergeSort r).length), + setPrec (S (cells.mergeSort r)[i]) (S (cells.mergeSort r)[k]) = true := by + intro i k hik hk + let s : Array Nat → Array Nat → Bool := fun A B => !setPrec B A + have hmap : (cells.mergeSort r).map S = (cells.map S).mergeSort s := + List.map_mergeSort (fun a ha b hb => hr a ha b hb) + have htrans : ∀ A B C, s A B = true → s B C = true → s A C = true := by + intro A B C h1 h2 + simp only [s, Bool.not_eq_true'] at * + cases h3 : setPrec C A + · rfl + · exfalso + by_cases hAB : A = B + · subst hAB; rw [h2] at h3; cases h3 + · rcases setPrec_total' hAB with h4 | h4 + · rw [setPrec_trans' h3 h4] at h2; cases h2 + · rw [h4] at h1; cases h1 + have htotal : ∀ A B, (s A B || s B A) = true := by + intro A B + simp only [s, Bool.or_eq_true, Bool.not_eq_true'] + cases h : setPrec B A + · exact Or.inl rfl + · exact Or.inr (setPrec_asymm' h) + have hpw := List.pairwise_mergeSort htrans htotal (cells.map S) + rw [← hmap, List.pairwise_map] at hpw + have hord := (List.pairwise_iff_getElem.mp hpw) i k (by omega) hk hik + simp only [s, Bool.not_eq_true'] at hord + have hndo : (cells.mergeSort r).Nodup := hnd.perm (List.mergeSort_perm cells r).symm + have hne : (cells.mergeSort r)[i] ≠ (cells.mergeSort r)[k] := by + intro he + have := (List.getElem_inj hndo).mp he + omega + have hmi : (cells.mergeSort r)[i] ∈ cells := + List.mem_mergeSort.mp (List.getElem_mem (by omega)) + have hmk : (cells.mergeSort r)[k] ∈ cells := List.mem_mergeSort.mp (List.getElem_mem hk) + rcases setPrec_total' (hdist _ hmi _ hmk hne) with h | h + · exact h + · rw [h] at hord; cases hord + +/-! ## One layer -/ + +/-- The sets of the next layer: the previous cell's set with the entry taken. -/ +def reconNext (recon : Nat → Array Nat) (tab : CTable) (took : Array Nat) (t : Nat) : Array Nat := + candSet recon tab (t - took[t]!) took[t]! + +theorem knapBest_get {cap : Nat} {L : KLayer} {tab : CTable} {t : Nat} (ht : t ≤ cap) : + (knapBest cap L tab)[t]! = cellBest L tab t := by + unfold knapBest + rw [getElem!_pos _ t (by simp; omega)] + simp + +theorem knapTook_get {best : Array (Option (_root_.Int × Nat × Nat))} {t : Nat} + (ht : t < best.size) : (knapTook best)[t]! = (best[t]!).elim 0 (·.2.2) := by + unfold knapTook + rw [getElem!_pos _ t (by simpa using ht), getElem!_pos _ t ht] + simp + +theorem knapDelta_get {best : Array (Option (_root_.Int × Nat × Nat))} {t : Nat} + (ht : t < best.size) : (best.map (·.map (·.1)))[t]! = (best[t]!).map (·.1) := by + rw [getElem!_pos _ t (by simpa using ht), getElem!_pos _ t ht] + simp + +section Layer + +variable {cap : Nat} {tabs : Array CTable} {j : Nat} {dp : Array (Option (_root_.Int × Array Nat))} + {L : KLayer} {recon : Nat → Array Nat} + +/-- What a nonempty cell of the next layer took: an entry `k ≤ t` present in the +table, from a nonempty cell `t - k` of the previous layer. -/ +theorem cellBest_shape (hok : tablesOK tabs = true) (hj : j < tabs.size) + (h : LayerInv cap tabs j dp L recon) {t : Nat} (ht : t ≤ cap) {x : _root_.Int × Nat × Nat} + (hx : cellBest L tabs[j]! t = some x) : + x.2.2 ≤ t ∧ x.2.1 = t - x.2.2 ∧ (tabs[j]![x.2.2]!).isSome ∧ (L.delta[t - x.2.2]!).isSome := by + obtain ⟨k, xk, da, hkt, _, htk, hd, rfl⟩ := mem_cellCands.mp (cellBest_mem hok hj h ht hx) + exact ⟨hkt, rfl, by simp [htk], by simp [hd]⟩ + +theorem knapLayer_inv (hok : tablesOK tabs = true) (hj : j < tabs.size) + (h : LayerInv cap tabs j dp L recon) : + LayerInv cap tabs (j + 1) (knapStep cap dp tabs[j]!) (knapLayer cap L tabs[j]!).1 + (reconNext recon tabs[j]! (knapLayer cap L tabs[j]!).2) := by + -- names for the parts of the next layer + have hbsz : (knapBest cap L tabs[j]!).size = cap + 1 := by simp [knapBest] + have hdelta : ∀ t, t ≤ cap → (knapLayer cap L tabs[j]!).1.delta[t]! = + (cellBest L tabs[j]! t).map (·.1) := by + intro t ht + show ((knapBest cap L tabs[j]!).map (·.map (·.1)))[t]! = _ + rw [knapDelta_get (by omega), knapBest_get ht] + have htook : ∀ t, t ≤ cap → (knapLayer cap L tabs[j]!).2[t]! = + (cellBest L tabs[j]! t).elim 0 (·.2.2) := by + intro t ht + show (knapTook (knapBest cap L tabs[j]!))[t]! = _ + rw [knapTook_get (by omega), knapBest_get ht] + -- a nonempty cell of the next layer + have hnon : ∀ t, t ≤ cap → ((knapLayer cap L tabs[j]!).1.delta[t]!).isSome → + ∃ x, cellBest L tabs[j]! t = some x ∧ (knapLayer cap L tabs[j]!).2[t]! = x.2.2 := by + intro t ht hs + rw [hdelta t ht] at hs + cases hb : cellBest L tabs[j]! t with + | none => rw [hb] at hs; cases hs + | some x => exact ⟨x, rfl, by rw [htook t ht, hb]; rfl⟩ + have hcandVal : ∀ t, t ≤ cap → ∀ x, cellBest L tabs[j]! t = some x → + candVal recon tabs[j]! x = (x.1, reconNext recon tabs[j]! (knapLayer cap L tabs[j]!).2 t) := by + intro t ht x hx + obtain ⟨_, h2, _, _⟩ := cellBest_shape hok hj h ht hx + have hk : (knapLayer cap L tabs[j]!).2[t]! = x.2.2 := by rw [htook t ht, hx]; rfl + unfold candVal reconNext + rw [hk, ← h2] + have hprev : ∀ t, t ≤ cap → ((knapLayer cap L tabs[j]!).1.delta[t]!).isSome → + t - (knapLayer cap L tabs[j]!).2[t]! ≤ cap ∧ + (L.delta[t - (knapLayer cap L tabs[j]!).2[t]!]!).isSome ∧ + (knapLayer cap L tabs[j]!).2[t]! ≤ t ∧ + (tabs[j]![(knapLayer cap L tabs[j]!).2[t]!]!).isSome := by + intro t ht hs + obtain ⟨x, hx, hk⟩ := hnon t ht hs + obtain ⟨h1, _, h3, h4⟩ := cellBest_shape hok hj h ht hx + rw [hk] + exact ⟨by omega, h4, h1, h3⟩ + have hsorted : ∀ t, t ≤ cap → ((knapLayer cap L tabs[j]!).1.delta[t]!).isSome → + (reconNext recon tabs[j]! (knapLayer cap L tabs[j]!).2 t).toList.Pairwise (· < ·) := by + intro t ht hs + obtain ⟨h1, h2, _, _⟩ := hprev t ht hs + exact candSet_sorted hok hj h h1 h2 + have hcard : ∀ t, t ≤ cap → ((knapLayer cap L tabs[j]!).1.delta[t]!).isSome → + (reconNext recon tabs[j]! (knapLayer cap L tabs[j]!).2 t).size = t := by + intro t ht hs + obtain ⟨h1, h2, h3, h4⟩ := hprev t ht hs + unfold reconNext candSet + rw [mergeSorted_size, h.card _ h1 h2, entrySet_size hok hj h4] + omega + -- comparisons of next-layer cells are `setPrec` on their sets + have hprec : ∀ u v, u ≤ cap → v ≤ cap → ((knapLayer cap L tabs[j]!).1.delta[u]!).isSome → + ((knapLayer cap L tabs[j]!).1.delta[v]!).isSome → + candPrec L tabs[j]! (u - (knapLayer cap L tabs[j]!).2[u]!) (knapLayer cap L tabs[j]!).2[u]! + (v - (knapLayer cap L tabs[j]!).2[v]!) (knapLayer cap L tabs[j]!).2[v]! = + setPrec (reconNext recon tabs[j]! (knapLayer cap L tabs[j]!).2 u) + (reconNext recon tabs[j]! (knapLayer cap L tabs[j]!).2 v) := by + intro u v hu hv hsu hsv + obtain ⟨hu1, hu2, _, _⟩ := hprev u hu hsu + obtain ⟨hv1, hv2, _, _⟩ := hprev v hv hsv + exact candPrec_eq hok hj h hu1 hv1 hu2 hv2 + have hdist : ∀ u v, u ≤ cap → v ≤ cap → ((knapLayer cap L tabs[j]!).1.delta[u]!).isSome → + ((knapLayer cap L tabs[j]!).1.delta[v]!).isSome → u ≠ v → + reconNext recon tabs[j]! (knapLayer cap L tabs[j]!).2 u ≠ + reconNext recon tabs[j]! (knapLayer cap L tabs[j]!).2 v := by + intro u v hu hv hsu hsv huv he + have := congrArg Array.size he + rw [hcard u hu hsu, hcard v hv hsv] at this + exact huv this + -- the sorted order of the next layer's cells + generalize hS : reconNext recon tabs[j]! (knapLayer cap L tabs[j]!).2 = S at * + generalize hbest : knapBest cap L tabs[j]! = best at hbsz + have hL1 : (knapLayer cap L tabs[j]!).1 = + { delta := best.map (·.map (·.1)), + rank := rankOf (cap + 1) (knapOrd cap L tabs[j]! best (knapTook best)), + sp := sparseBuild (knapAdj L tabs[j]! (knapTook best) (knapOrd cap L tabs[j]! best (knapTook best))) } := by + rw [← hbest]; rfl + have hL2 : (knapLayer cap L tabs[j]!).2 = knapTook best := by rw [← hbest]; rfl + generalize hcells : (List.range (cap + 1)).filter (fun c => (best[c]!).isSome) = cells + have hord : knapOrd cap L tabs[j]! best (knapTook best) = cells.mergeSort fun u v => + !candPrec L tabs[j]! (v - (knapTook best)[v]!) (knapTook best)[v]! + (u - (knapTook best)[u]!) (knapTook best)[u]! := by + rw [← hcells]; rfl + have hmemc : ∀ c, c ∈ cells ↔ c ≤ cap ∧ ((knapLayer cap L tabs[j]!).1.delta[c]!).isSome := by + intro c + rw [← hcells, List.mem_filter, List.mem_range] + constructor + · rintro ⟨h1, h2⟩ + have hc : c ≤ cap := by omega + refine ⟨hc, ?_⟩ + rw [hdelta c hc, ← knapBest_get hc, hbest] + simpa using h2 + · rintro ⟨h1, h2⟩ + refine ⟨by omega, ?_⟩ + rw [hdelta c h1, ← knapBest_get h1, hbest] at h2 + simpa using h2 + have hndc : cells.Nodup := by + rw [← hcells]; exact (List.nodup_range).filter _ + generalize hordv : knapOrd cap L tabs[j]! best (knapTook best) = ord at hL1 hord + have hsetPrec := mergeSort_setPrec S cells (fun u v => + !candPrec L tabs[j]! (v - (knapTook best)[v]!) (knapTook best)[v]! + (u - (knapTook best)[u]!) (knapTook best)[u]!) + (fun u hu v hv => by + obtain ⟨hu1, hu2⟩ := (hmemc u).mp hu + obtain ⟨hv1, hv2⟩ := (hmemc v).mp hv + rw [← hL2, hprec v u hv1 hu1 hv2 hu2]) + (fun u hu v hv huv => by + obtain ⟨hu1, hu2⟩ := (hmemc u).mp hu + obtain ⟨hv1, hv2⟩ := (hmemc v).mp hv + exact hdist u v hu1 hv1 hu2 hv2 huv) + hndc + have hsetPrec' : ∀ i k (hi : i < k) (hk : k < ord.length), setPrec (S ord[i]) (S ord[k]) = true := by + rw [hord]; exact hsetPrec + have hndo : ord.Nodup := by + rw [hord]; exact hndc.perm (List.mergeSort_perm _ _).symm + have hmemo : ∀ c, c ∈ ord ↔ c ∈ cells := by + intro c; rw [hord, List.mem_mergeSort] + have hrank : ∀ c, c ∈ ord → (knapLayer cap L tabs[j]!).1.rank[c]! = ord.idxOf c := by + intro c hc + rw [hL1] + exact rankOf_get hndo (by have := ((hmemc c).mp ((hmemo c).mp hc)).1; omega) hc + refine { + size := (knapStep_get cap dp tabs[j]!).1 + cell := fun t ht => ?_ + sorted := hsorted + card := hcard + dom := fun t ht hs z hz => ?_ + rank := fun a b ha hb hsa hsb hab => ?_ + fd := fun a b ha hb hsa hsb hlt => ?_ } + · -- the cells + rw [cell_step hok hj h ht, hdelta t ht] + cases hb : cellBest L tabs[j]! t with + | none => rfl + | some x => + simp only [Option.map_some] + rw [hcandVal t ht x hb] + · -- the domain + obtain ⟨h1, h2, _, _⟩ := hprev t ht hs + rw [← hS] at hz + unfold reconNext candSet at hz + rcases mem_mergeSorted.mp hz with hz | hz + · obtain ⟨i, hi, hiz⟩ := h.dom _ h1 h2 z hz + exact ⟨i, by omega, hiz⟩ + · exact ⟨j, by omega, entrySet_inTable hz⟩ + · -- ranks + have hao : a ∈ ord := (hmemo a).mpr ((hmemc a).mpr ⟨ha, hsa⟩) + have hbo : b ∈ ord := (hmemo b).mpr ((hmemc b).mpr ⟨hb, hsb⟩) + rw [hrank a hao, hrank b hbo] + have hia := List.idxOf_lt_length_of_mem hao + have hib := List.idxOf_lt_length_of_mem hbo + have ea : ord[ord.idxOf a] = a := List.getElem_idxOf hia + have eb : ord[ord.idxOf b] = b := List.getElem_idxOf hib + constructor + · intro hlt + have := hsetPrec' _ _ hlt hib + rwa [ea, eb] at this + · intro hp + rcases Nat.lt_trichotomy (ord.idxOf a) (ord.idxOf b) with hlt | heq | hgt + · exact hlt + · exfalso; apply hab; rw [← ea, ← eb]; simp only [heq] + · exfalso + have := hsetPrec' _ _ hgt hia + rw [ea, eb] at this + rw [setPrec_asymm' this] at hp + cases hp + · -- first differences through the sparse table + have hao : a ∈ ord := (hmemo a).mpr ((hmemc a).mpr ⟨ha, hsa⟩) + have hbo : b ∈ ord := (hmemo b).mpr ((hmemc b).mpr ⟨hb, hsb⟩) + rw [hrank a hao, hrank b hbo] at hlt ⊢ + have hia := List.idxOf_lt_length_of_mem hao + have hib := List.idxOf_lt_length_of_mem hbo + have ea : ord[ord.idxOf a] = a := List.getElem_idxOf hia + have eb : ord[ord.idxOf b] = b := List.getElem_idxOf hib + -- every cell of the order is a nonempty cell + have hcell : ∀ m (hm : m < ord.length), ord[m] ≤ cap ∧ + ((knapLayer cap L tabs[j]!).1.delta[ord[m]]!).isSome := + fun m hm => (hmemc _).mp ((hmemo _).mp (List.getElem_mem hm)) + have hordA : ∀ m (hm : m < ord.length), ord.toArray[m]! = ord[m] := by + intro m hm + rw [getElem!_pos _ m (by simpa using hm)] + simp + have hadjsz : (knapAdj L tabs[j]! (knapTook best) ord).size = ord.length - 1 := by + simp [knapAdj] + have hadj : ∀ m (hm : m + 1 < ord.length), + firstDiff (S ord[m]).toList (S ord[m + 1]).toList = + some (knapAdj L tabs[j]! (knapTook best) ord)[m]! ∧ + (knapAdj L tabs[j]! (knapTook best) ord)[m]! ∈ (S ord[m + 1]).toList := by + intro m hm + obtain ⟨hu1, hu2⟩ := hcell m (by omega) + obtain ⟨hv1, hv2⟩ := hcell (m + 1) hm + have hp := hsetPrec' m (m + 1) (by omega) hm + obtain ⟨d, hd1, hd2⟩ := (setPrec_iff (hsorted _ hu1 hu2) (hsorted _ hv1 hv2)).mp hp + have hval : (knapAdj L tabs[j]! (knapTook best) ord)[m]! = d := by + unfold knapAdj + rw [getElem!_pos _ m (by simp; omega)] + simp only [Array.getElem_map, Array.getElem_range] + rw [hordA m (by omega), hordA (m + 1) hm, ← hL2] + obtain ⟨hp1, hp2, _, _⟩ := hprev _ hu1 hu2 + obtain ⟨hq1, hq2, _, _⟩ := hprev _ hv1 hv2 + rw [candFD_eq hok hj h hp1 hq1 hp2 hq2] + have e1 : candSet recon tabs[j]! (ord[m] - (knapLayer cap L tabs[j]!).2[ord[m]]!) + (knapLayer cap L tabs[j]!).2[ord[m]]! = S ord[m] := by rw [← hS]; rfl + have e2 : candSet recon tabs[j]! (ord[m + 1] - (knapLayer cap L tabs[j]!).2[ord[m + 1]]!) + (knapLayer cap L tabs[j]!).2[ord[m + 1]]! = S ord[m + 1] := by rw [← hS]; rfl + rw [e1, e2, hd1] + rfl + rw [hval] + exact ⟨hd1, hd2⟩ + have hchain := firstDiff_chain (sets := fun m => (S ord.toArray[m]!).toList) + (d := fun m => (knapAdj L tabs[j]! (knapTook best) ord)[m]!) (n := ord.length) + (fun m hm => by + rw [hordA m hm] + obtain ⟨h1, h2⟩ := hcell m hm + exact hsorted _ h1 h2) + (fun m hm => by + rw [hordA m (by omega), hordA (m + 1) hm] + exact hadj m hm) + (ord.idxOf b - ord.idxOf a - 1) (ord.idxOf a) (by omega) + have e : ord.idxOf a + (ord.idxOf b - ord.idxOf a - 1) + 1 = ord.idxOf b := by omega + rw [e, hordA _ hia, hordA _ hib, ea, eb] at hchain + rw [hchain.1, hL1] + simp only + rw [sparseQuery_eq _ hlt (by rw [hadjsz]; omega)] + +end Layer + +/-! ## All layers -/ + +theorem knapInit_inv (cap : Nat) (tabs : Array CTable) (recon : Nat → Array Nat) + (hr : recon 0 = #[]) : + LayerInv cap tabs 0 (#[some (0, #[])] ++ Array.replicate cap none) (knapInit cap) recon := by + have hdel : ∀ c, c ≤ cap → (knapInit cap).delta[c]! = if c = 0 then some 0 else none := by + intro c hc + unfold knapInit + simp only + rw [getElem!_pos _ c (by simp; omega)] + by_cases h0 : c = 0 + · subst h0; simp + · simp only [h0, if_false] + rw [Array.getElem_append_right (by simp; omega)] + simp + have hnon : ∀ c, c ≤ cap → ((knapInit cap).delta[c]!).isSome → c = 0 := by + intro c hc hs + rw [hdel c hc] at hs + by_cases h0 : c = 0 + · exact h0 + · simp [h0] at hs + refine { + size := by simp; omega + cell := fun c hc => ?_ + sorted := fun c hc hs => by rw [hnon c hc hs, hr]; simp + card := fun c hc hs => by rw [hnon c hc hs, hr]; rfl + dom := fun c hc hs z hz => by rw [hnon c hc hs, hr] at hz; simp at hz + rank := fun a b ha hb hsa hsb hab => absurd ((hnon a ha hsa).trans (hnon b hb hsb).symm) hab + fd := fun a b ha hb hsa hsb hlt => ?_ } + · rw [hdel c hc, getElem!_pos _ c (by simp; omega)] + by_cases h0 : c = 0 + · subst h0; simp [hr] + · simp only [h0, if_false, Option.map_none] + rw [Array.getElem_append_right (by simp; omega)] + simp + · have := hnon a ha hsa + have := hnon b hb hsb + subst a; subst b + exact absurd hlt (Nat.lt_irrefl _) + +theorem knapRecon_push (tabs : Array CTable) (tooks : Array (Array Nat)) (took : Array Nat) : + ∀ j c, j ≤ tooks.size → knapRecon tabs (tooks.push took) j c = knapRecon tabs tooks j c := by + intro j + induction j with + | zero => intro c _; rfl + | succ j ih => + intro c hj + simp only [knapRecon] + have e : (tooks.push took)[j]! = tooks[j]! := by + rw [getElem!_pos _ j (by simp; omega), getElem!_pos _ j (by omega)] + simp [Array.getElem_push_lt (by omega : j < tooks.size)] + rw [e, ih _ (by omega)] + +/-- The run over the tables `l` (the tables from `j` on) keeps the invariant. -/ +theorem knapRun_inv {cap : Nat} {tabs : Array CTable} (hok : tablesOK tabs = true) : + ∀ (l : List CTable) (j : Nat) (dp : Array (Option (_root_.Int × Array Nat))) (L : KLayer) + (tooks : Array (Array Nat)), + l = tabs.toList.drop j → j ≤ tabs.size → tooks.size = j → + LayerInv cap tabs j dp L (knapRecon tabs tooks j) → + LayerInv cap tabs tabs.size (l.foldl (fun dp tab => knapStep cap dp tab) dp) + (l.foldl (fun acc tab => let r := knapLayer cap acc.1 tab; (r.1, acc.2.push r.2)) (L, tooks)).1 + (knapRecon tabs + (l.foldl (fun acc tab => let r := knapLayer cap acc.1 tab; (r.1, acc.2.push r.2)) (L, tooks)).2 + tabs.size) ∧ + (l.foldl (fun acc tab => let r := knapLayer cap acc.1 tab; (r.1, acc.2.push r.2)) (L, tooks)).2.size + = tabs.size := by + intro l + induction l with + | nil => + intro j dp L tooks hl hjs hsz hinv + have hj : j = tabs.size := by + have := congrArg List.length hl + simp at this + omega + subst hj + exact ⟨hinv, hsz⟩ + | cons tab l ih => + intro j dp L tooks hl hjs hsz hinv + have hj : j < tabs.size := by + have := congrArg List.length hl + simp at this + omega + have htab : tab = tabs[j]! := by + rw [List.drop_eq_getElem_cons (by simpa using hj)] at hl + rw [getElem!_pos tabs j hj] + simpa using (List.cons.inj hl).1 + subst htab + simp only [List.foldl_cons] + apply ih (j + 1) + · rw [List.drop_eq_getElem_cons (by simpa using hj)] at hl + exact (List.cons.inj hl).2 + · omega + · simp [hsz] + · have hstep := knapLayer_inv hok hj hinv + have hrec : reconNext (knapRecon tabs tooks j) tabs[j]! (knapLayer cap L tabs[j]!).2 = + knapRecon tabs (tooks.push (knapLayer cap L tabs[j]!).2) (j + 1) := by + funext c + simp only [knapRecon] + have e : (tooks.push (knapLayer cap L tabs[j]!).2)[j]! = (knapLayer cap L tabs[j]!).2 := by + rw [getElem!_pos _ j (by simp; omega)] + simp [← hsz] + rw [e, knapRecon_push _ _ _ _ _ (by omega)] + rfl + rw [hrec] at hstep + exact hstep + +/-! ## The choice of the bracket -/ + +theorem foldl_filterMap_elim {α β γ : Type} (f : α → Option β) (g : γ → β → γ) : + ∀ (l : List α) (init : γ), (l.filterMap f).foldl g init = l.foldl (fun x y => (f y).elim x (g x)) init := by + intro l + induction l with + | nil => intro init; rfl + | cons a l ih => + intro init + rw [List.filterMap_cons] + cases h : f a with + | none => simp only [List.foldl_cons, h, Option.elim_none]; exact ih init + | some b => simp only [List.foldl_cons, h, Option.elim_some]; exact ih (g init b) + +/-- The order of `knapChoose` on candidates `(Δ, set, lower)`: length, then +`setPrec`. -/ +def chooseKey (kCS : Nat) (x : _root_.Int × Array Nat × Bool) : _root_.Int × Array Nat := + (x.1 + (tag0Size (kCS + x.2.1.size) : _root_.Int), x.2.1) + +/-- The step of `knapChoose`. -/ +def chooseStep (kCS : Nat) (acc x : _root_.Int × Array Nat × Bool) : _root_.Int × Array Nat × Bool := + if entryLt (chooseKey kCS x) (chooseKey kCS acc) then x else acc + +theorem knapChoose_eq_fold (kCS : Nat) (dp : Array (Option (_root_.Int × Array Nat))) + (init : _root_.Int × Array Nat × Bool) + (hcard : ∀ c, c < dp.size → ∀ e, dp[c]! = some e → e.2.size = c) : + knapChoose kCS dp init = + ((List.range dp.size).filterMap fun c => (dp[c]!).map fun e => (e.1, e.2, true)).foldl + (chooseStep kCS) init := by + rw [foldl_filterMap_elim] + unfold knapChoose + have key : ∀ (l : List Nat) (acc : _root_.Int × Array Nat × Bool), (∀ c ∈ l, c < dp.size) → + l.foldl (fun (acc : _root_.Int × Array Nat × Bool) c => + match dp[c]! with + | none => acc + | some (d, s) => + let l : _root_.Int := d + (tag0Size (kCS + c) : _root_.Int) + let l0 : _root_.Int := acc.1 + (tag0Size (kCS + acc.2.1.size) : _root_.Int) + if l < l0 || (l == l0 && setPrec s acc.2.1) then (d, s, true) else acc) acc = + l.foldl (fun x y => ((dp[y]!).map fun e => (e.1, e.2, true)).elim x (chooseStep kCS x)) acc := by + intro l + induction l with + | nil => intro acc _; rfl + | cons c l ih => + intro acc hl + simp only [List.foldl_cons] + rw [← ih _ (fun c' hc' => hl c' (List.mem_cons_of_mem _ hc'))] + congr 1 + cases he : dp[c]! with + | none => rfl + | some e => + obtain ⟨d, s⟩ := e + have hs := hcard c (hl c List.mem_cons_self) (d, s) he + simp only [Option.map_some, Option.elim_some, chooseStep, chooseKey, entryLt] + simp only at hs + simp only [hs] + exact key _ init (fun c hc => List.mem_range.mp hc) + +/-- A fold that replaces its value by a strictly smaller element (no `Option`). -/ +theorem foldl_least_init {α β : Type} (abs : α → β) (lt : β → β → Bool) + (hirr : ∀ x, lt x x = false) + (htrans : ∀ x y z, lt x y = true → lt y z = true → lt x z = true) + (g : α → α → α) (hg : ∀ a x, g a x = if lt (abs x) (abs a) then x else a) : + ∀ (L : List α) (init : α), + (L.foldl g init ∈ L ∨ L.foldl g init = init) ∧ + (∀ x ∈ L, lt (abs x) (abs (L.foldl g init)) = false) ∧ + (L.foldl g init = init ∨ lt (abs (L.foldl g init)) (abs init) = true) := by + have hasymm : ∀ x y, lt x y = true → lt y x = false := by + intro x y h + cases h' : lt y x + · rfl + · have := htrans _ _ _ h h'; rw [hirr] at this; cases this + intro L + induction L with + | nil => intro init; simp + | cons t ts ih => + intro init + simp only [List.foldl_cons] + obtain ⟨hmem, hle, hlea⟩ := ih (g init t) + rw [hg] at hmem hle hlea ⊢ + by_cases hb : lt (abs t) (abs init) = true + · simp only [hb, if_true] at hmem hle hlea ⊢ + refine ⟨?_, fun x hx => ?_, ?_⟩ + · rcases hmem with h | h + · exact Or.inl (List.mem_cons_of_mem _ h) + · rw [h]; exact Or.inl List.mem_cons_self + · rcases List.mem_cons.mp hx with h | h + · subst h + rcases hlea with h | h + · rw [h]; exact hirr _ + · exact hasymm _ _ h + · exact hle x h + · rcases hlea with h | h + · rw [h]; exact Or.inr hb + · exact Or.inr (htrans _ _ _ h hb) + · simp only [hb, Bool.false_eq_true, if_false] at hmem hle hlea ⊢ + refine ⟨?_, fun x hx => ?_, hlea⟩ + · rcases hmem with h | h + · exact Or.inl (List.mem_cons_of_mem _ h) + · exact Or.inr h + · rcases List.mem_cons.mp hx with h | h + · subst h + cases h : lt (abs x) (abs (ts.foldl g init)) + · rfl + · exfalso + rcases hlea with h' | h' + · rw [h'] at h; exact hb h + · exact hb (htrans _ _ _ h h') + · exact hle x h + +theorem tag0BracketStart_le (k : Nat) : tag0BracketStart k ≤ k := by + unfold tag0BracketStart + split + · omega + · split <;> (try split) <;> (try split) <;> (try split) <;> omega + +/-! ## Rebuilding the chosen set -/ + +theorem knapRecon_sorted (tabs : Array CTable) (tooks : Array (Array Nat)) : + ∀ j c, (knapRecon tabs tooks j c).toList.Pairwise fun x y => decide (x ≤ y) = true := by + intro j + cases j with + | zero => intro c; simp [knapRecon] + | succ j => + intro c + simp only [knapRecon] + unfold mergeSorted + exact List.pairwise_mergeSort le_trans_dec le_total_dec _ + +theorem knapCollect_perm (tabs : Array CTable) (tooks : Array (Array Nat)) : + ∀ j c acc, (knapCollect tabs tooks j c acc).Perm ((knapRecon tabs tooks j c).toList ++ acc) := by + intro j + induction j with + | zero => intro c acc; simp [knapCollect, knapRecon] + | succ j ih => + intro c acc + simp only [knapCollect, knapRecon] + refine (ih _ _).trans ?_ + rw [← List.append_assoc] + exact List.Perm.append_right _ (mergeSorted_perm _ _).symm + +theorem knapReconFast_eq (tabs : Array CTable) (tooks : Array (Array Nat)) (j c : Nat) : + knapReconFast tabs tooks j c = knapRecon tabs tooks j c := by + unfold knapReconFast + apply Array.toList_inj.mp + simp only + apply List.Perm.eq_of_pairwise (le := fun x y => decide (x ≤ y) = true) + (fun a b _ _ h1 h2 => by simp only [decide_eq_true_eq] at h1 h2; omega) + (List.pairwise_mergeSort le_trans_dec le_total_dec _) (knapRecon_sorted tabs tooks j c) + refine (List.mergeSort_perm _ _).trans ?_ + simpa using knapCollect_perm tabs tooks j c [] + +/-! ## The chosen bracket -/ + +theorem filterMap_congr' {α β : Type} {f g : α → Option β} : + ∀ (l : List α), (∀ x ∈ l, f x = g x) → l.filterMap f = l.filterMap g + | [], _ => rfl + | a :: l, h => by + rw [List.filterMap_cons, List.filterMap_cons, h a List.mem_cons_self, + filterMap_congr' l (fun x hx => h x (List.mem_cons_of_mem _ hx))] + +theorem knapBestCell_eq_fold (kCS : Nat) (L : KLayer) (cap : Nat) : + knapBestCell kCS L cap = + ((List.range (cap + 1)).filterMap fun c => + (L.delta[c]!).map fun d => (d + (tag0Size (kCS + c) : _root_.Int), c, d)).foldl + (fun acc x => acc.elim (some x) fun b => + if x.1 < b.1 || (x.1 == b.1 && decide (L.rank[x.2.1]! < L.rank[b.2.1]!)) then some x + else some b) none := by + rw [foldl_filterMap_elim] + unfold knapBestCell + congr 1 + funext acc c + cases L.delta[c]! <;> rfl + +theorem knapChooseFast_eq {kCS cap : Nat} {tabs : Array CTable} {init : _root_.Int × Array Nat × Bool} + (hinit : cap < init.2.1.size) {dp : Array (Option (_root_.Int × Array Nat))} + (h : LayerInv cap tabs tabs.size dp (knapRun cap tabs.toList).1 + (knapRecon tabs (knapRun cap tabs.toList).2 tabs.size)) : + knapChooseFast kCS cap tabs init = knapChoose kCS dp init := by + generalize hL : (knapRun cap tabs.toList).1 = L at h + generalize hR : knapRecon tabs (knapRun cap tabs.toList).2 tabs.size = recon at h + have hcard : ∀ c, c < dp.size → ∀ e, dp[c]! = some e → e.2.size = c := by + intro c hc e he + rw [h.size] at hc + rw [h.cell c (by omega)] at he + cases hd : L.delta[c]! with + | none => rw [hd] at he; cases he + | some d => + rw [hd] at he + simp only [Option.map_some, Option.some.injEq] at he + subst he + exact h.card c (by omega) (by simp [hd]) + rw [knapChoose_eq_fold kCS dp init hcard] + -- the specification's candidates + have hspecv : ((List.range dp.size).filterMap fun c => (dp[c]!).map fun e => (e.1, e.2, true)) = + ((List.range (cap + 1)).filterMap fun c => (L.delta[c]!).map fun d => (d, recon c, true)) := by + rw [h.size] + apply filterMap_congr' + intro c hc + rw [h.cell c (by simp at hc; omega)] + cases L.delta[c]! <;> rfl + rw [hspecv] + generalize hV : ((List.range (cap + 1)).filterMap fun c => + (L.delta[c]!).map fun d => (d, recon c, true)) = V + have hmemV : ∀ x, x ∈ V ↔ ∃ c d, c ≤ cap ∧ L.delta[c]! = some d ∧ x = (d, recon c, true) := by + intro x + rw [← hV, List.mem_filterMap] + constructor + · rintro ⟨c, hc, hx⟩ + cases hd : L.delta[c]! with + | none => rw [hd] at hx; cases hx + | some d => + rw [hd] at hx + simp only [Option.map_some, Option.some.injEq] at hx + exact ⟨c, d, by simp at hc; omega, hd, hx.symm⟩ + · rintro ⟨c, d, hc, hd, rfl⟩ + exact ⟨c, by simp; omega, by rw [hd]; rfl⟩ + have hkeyV : ∀ c d, c ≤ cap → L.delta[c]! = some d → + chooseKey kCS (d, recon c, true) = (d + (tag0Size (kCS + c) : _root_.Int), recon c) := by + intro c d hc hd + unfold chooseKey + simp only + rw [h.card c hc (by simp [hd])] + -- the specification's choice + obtain ⟨hrmem, hrle, hrinit⟩ := foldl_least_init (chooseKey kCS) entryLt entryLt_irrefl + (fun _ _ _ => entryLt_trans) (chooseStep kCS) (fun a x => rfl) V init + generalize hr : V.foldl (chooseStep kCS) init = r at hrmem hrle hrinit + -- the fast choice + unfold knapChooseFast + simp only + rw [hL] + rw [knapBestCell_eq_fold] + generalize hC : ((List.range (cap + 1)).filterMap fun c => + (L.delta[c]!).map fun d => (d + (tag0Size (kCS + c) : _root_.Int), c, d)) = C + have hmemC : ∀ x, x ∈ C ↔ ∃ c d, c ≤ cap ∧ L.delta[c]! = some d ∧ + x = (d + (tag0Size (kCS + c) : _root_.Int), c, d) := by + intro x + rw [← hC, List.mem_filterMap] + constructor + · rintro ⟨c, hc, hx⟩ + cases hd : L.delta[c]! with + | none => rw [hd] at hx; cases hx + | some d => + rw [hd] at hx + simp only [Option.map_some, Option.some.injEq] at hx + exact ⟨c, d, by simp at hc; omega, hd, hx.symm⟩ + · rintro ⟨c, d, hc, hd, rfl⟩ + exact ⟨c, by simp; omega, by rw [hd]; rfl⟩ + have hfast := foldl_least (fun x : _root_.Int × Nat × _root_.Int => + x.2.1 ≤ cap ∧ (L.delta[x.2.1]!).isSome) + (fun x => (x.1, recon x.2.1)) entryLt entryLt_irrefl (fun _ _ _ => entryLt_trans) + (fun acc x => acc.elim (some x) fun b => + if x.1 < b.1 || (x.1 == b.1 && decide (L.rank[x.2.1]! < L.rank[b.2.1]!)) then some x + else some b) (fun x => rfl) + (fun b x hb hx => by + simp only [Option.elim_some] + congr 1 + unfold entryLt + by_cases hxb : x.2.1 = b.2.1 + · rw [hxb, setPrec_irrefl'] + simp + · have hdec : decide (L.rank[x.2.1]! < L.rank[b.2.1]!) = setPrec (recon x.2.1) (recon b.2.1) := by + rw [Bool.eq_iff_iff, decide_eq_true_iff] + exact h.rank _ _ hx.1 hb.1 hx.2 hb.2 hxb + rw [hdec]) + C none (fun x hx => by + obtain ⟨c, d, hc, hd, rfl⟩ := (hmemC x).mp hx + exact ⟨hc, by simp [hd]⟩) (fun _ h => by cases h) + obtain ⟨hfn, hfs⟩ := hfast + cases hb : C.foldl (fun acc x => acc.elim (some x) fun b => + if x.1 < b.1 || (x.1 == b.1 && decide (L.rank[x.2.1]! < L.rank[b.2.1]!)) then some x + else some b) none with + | none => + -- no cell: the specification keeps `init` + have hCnil := (hfn.mp hb).2 + have hVnil : V = [] := by + apply List.eq_nil_iff_forall_not_mem.mpr + intro x hx + obtain ⟨c, d, hc, hd, _⟩ := (hmemV x).mp hx + have := (hmemC _).mpr ⟨c, d, hc, hd, rfl⟩ + rw [hCnil] at this + simp at this + rw [hVnil] at hr + simp only [Option.elim_none] + rw [← hr] + rfl + | some b => + obtain ⟨hbmem, hble, _⟩ := hfs b hb + have hbC : b ∈ C := by + rcases hbmem with h' | h' + · exact h' + · cases h' + obtain ⟨c, d, hc, hd, rfl⟩ := (hmemC _).mp hbC + simp only [Option.elim_some] + rw [knapReconFast_eq, hR] + -- the best cell's candidate + have hvV : (d, recon c, true) ∈ V := (hmemV _).mpr ⟨c, d, hc, hd, rfl⟩ + have hvmin : ∀ x ∈ V, entryLt (chooseKey kCS x) (chooseKey kCS (d, recon c, true)) = false := by + intro x hx + obtain ⟨c', d', hc', hd', rfl⟩ := (hmemV x).mp hx + rw [hkeyV c' d' hc' hd', hkeyV c d hc hd] + exact hble _ ((hmemC _).mpr ⟨c', d', hc', hd', rfl⟩) + -- candidates of `V` are told apart by their keys, and differ from `init` + have hinj : ∀ x ∈ V, ∀ y ∈ V, chooseKey kCS x = chooseKey kCS y → x = y := by + intro x hx y hy hxy + obtain ⟨c1, d1, hc1, hd1, rfl⟩ := (hmemV x).mp hx + obtain ⟨c2, d2, hc2, hd2, rfl⟩ := (hmemV y).mp hy + rw [hkeyV c1 d1 hc1 hd1, hkeyV c2 d2 hc2 hd2] at hxy + have hs := congrArg (fun p => p.2.size) hxy + simp only at hs + rw [h.card c1 hc1 (by simp [hd1]), h.card c2 hc2 (by simp [hd2])] at hs + subst hs + rw [hd1] at hd2 + cases hd2 + rfl + have hneinit : ∀ x ∈ V, chooseKey kCS x ≠ chooseKey kCS init := by + intro x hx hxe + obtain ⟨c1, d1, hc1, hd1, rfl⟩ := (hmemV x).mp hx + have hs := congrArg (fun p => p.2.size) hxe + simp only [chooseKey] at hs + rw [h.card c1 hc1 (by simp [hd1])] at hs + omega + have hkv := hkeyV c d hc hd + by_cases hlt : entryLt (chooseKey kCS (d, recon c, true)) (chooseKey kCS init) = true + · -- the cell is chosen + have hcond : (d + (tag0Size (kCS + c) : _root_.Int) < + init.1 + (tag0Size (kCS + init.2.1.size) : _root_.Int) || + (d + (tag0Size (kCS + c) : _root_.Int) == + init.1 + (tag0Size (kCS + init.2.1.size) : _root_.Int) && + setPrec (recon c) init.2.1)) = true := by + rw [hkv] at hlt + exact hlt + rw [if_pos hcond] + -- `r` is the cell's candidate + rcases hrmem with hrV | hrinit' + · have : chooseKey kCS r = chooseKey kCS (d, recon c, true) := by + apply least_unique entryLt (fun x y hxy => entryLt_total hxy) + (L := (V.map (chooseKey kCS))) (List.mem_map_of_mem hrV) (List.mem_map_of_mem hvV) + · intro x hx + obtain ⟨y, hy, rfl⟩ := List.mem_map.mp hx + exact hrle y hy + · intro x hx + obtain ⟨y, hy, rfl⟩ := List.mem_map.mp hx + exact hvmin y hy + rw [← hinj _ hrV _ hvV this] + · exfalso + have := hrle _ hvV + rw [hrinit', hlt] at this + cases this + · -- `init` is kept + have hcond : (d + (tag0Size (kCS + c) : _root_.Int) < + init.1 + (tag0Size (kCS + init.2.1.size) : _root_.Int) || + (d + (tag0Size (kCS + c) : _root_.Int) == + init.1 + (tag0Size (kCS + init.2.1.size) : _root_.Int) && + setPrec (recon c) init.2.1)) = false := by + have h2 : entryLt (chooseKey kCS (d, recon c, true)) (chooseKey kCS init) = false := by + simpa using hlt + rw [hkv] at h2 + exact h2 + rw [if_neg (by simp [hcond])] + rcases hrinit with hri | hri + · exact hri.symm + · exfalso + rcases hrmem with hrV | hrinit' + · -- `r` is a cell below `init`, so it is the best cell + have hle1 := hrle _ hvV + have hle2 := hvmin r hrV + have hne : chooseKey kCS r ≠ chooseKey kCS (d, recon c, true) ∨ + chooseKey kCS r = chooseKey kCS (d, recon c, true) := by + by_cases he : chooseKey kCS r = chooseKey kCS (d, recon c, true) + · exact Or.inr he + · exact Or.inl he + rcases hne with hne | he + · rcases entryLt_total hne with h1 | h1 + · rw [h1] at hle2; cases hle2 + · rw [h1] at hle1; cases hle1 + · rw [he] at hri + exact hlt hri + · rw [hrinit', entryLt_irrefl] at hri + cases hri + +/-! ## The per-component optimum and the knapsack -/ + +theorem foldl_mergeSorted_perm : + ∀ (l : List CompResult) (acc : Array Nat), + (l.foldl (fun acc r => mergeSorted acc r.bestSet) acc).toList.Perm + (acc.toList ++ l.flatMap fun r => r.bestSet.toList) := by + intro l + induction l with + | nil => intro acc; simp + | cons r l ih => + intro acc + simp only [List.foldl_cons, List.flatMap_cons] + refine (ih _).trans ?_ + rw [← List.append_assoc] + exact List.Perm.append_right _ (mergeSorted_perm _ _) + +theorem foldl_mergeSorted_sorted : + ∀ (l : List CompResult) (acc : Array Nat), + acc.toList.Pairwise (fun x y => decide (x ≤ y) = true) → + (l.foldl (fun acc r => mergeSorted acc r.bestSet) acc).toList.Pairwise + fun x y => decide (x ≤ y) = true := by + intro l + induction l with + | nil => intro acc h; exact h + | cons r l ih => + intro acc _ + simp only [List.foldl_cons] + apply ih + unfold mergeSorted + exact List.pairwise_mergeSort le_trans_dec le_total_dec _ + +theorem foldl_append_toList : + ∀ (l : List CompResult) (acc : Array Nat), + (l.foldl (fun acc r => acc ++ r.bestSet) acc).toList = + acc.toList ++ l.flatMap fun r => r.bestSet.toList := by + intro l + induction l with + | nil => intro acc; simp + | cons r l ih => + intro acc + simp only [List.foldl_cons, List.flatMap_cons] + rw [ih, Array.toList_append, List.append_assoc] + +/-- The union of the per-component optima, merged once. -/ +theorem bestX_eq (results : Array CompResult) : + results.foldl (fun acc r => mergeSorted acc r.bestSet) #[] = + ((results.foldl (fun acc r => acc ++ r.bestSet) #[]).toList.mergeSort + fun x y => decide (x ≤ y)).toArray := by + apply Array.toList_inj.mp + rw [← Array.foldl_toList, ← Array.foldl_toList, List.toList_toArray] + apply List.Perm.eq_of_pairwise (le := fun x y => decide (x ≤ y) = true) + (fun a b _ _ h1 h2 => by simp only [decide_eq_true_eq] at h1 h2; omega) + (foldl_mergeSorted_sorted _ _ (by simp)) + (List.pairwise_mergeSort le_trans_dec le_total_dec _) + refine (foldl_mergeSorted_perm _ _).trans ?_ + rw [foldl_append_toList] + exact (List.mergeSort_perm _ _).symm + +theorem uniformKnapsack_eq_fast_apply (limits : Limits) (kCS : Nat) (results : Array CompResult) : + uniformKnapsack limits kCS results = uniformKnapsackFast limits kCS results := by + unfold uniformKnapsack uniformKnapsackFast + rw [bestX_eq] + generalize ((results.foldl (fun acc r => acc ++ r.bestSet) #[]).toList.mergeSort + fun x y => decide (x ≤ y)).toArray = bestX + simp only + split + · rename_i hstart + split + · rfl + · rename_i hcells + split + · rename_i hok + congr 1 + have hdp : results.foldl (fun dp r => knapStep (tag0BracketStart (kCS + bestX.size) - 1 - kCS) + dp r.bySize) (#[some (0, #[])] ++ Array.replicate + (tag0BracketStart (kCS + bestX.size) - 1 - kCS) none) = + (results.map (·.bySize)).toList.foldl + (fun dp tab => knapStep (tag0BracketStart (kCS + bestX.size) - 1 - kCS) dp tab) + (#[some (0, #[])] ++ Array.replicate + (tag0BracketStart (kCS + bestX.size) - 1 - kCS) none) := by + rw [← Array.foldl_toList, Array.toList_map, List.foldl_map] + rw [hdp] + have hinit := knapInit_inv (tag0BracketStart (kCS + bestX.size) - 1 - kCS) + (results.map (·.bySize)) (knapRecon (results.map (·.bySize)) #[] 0) rfl + have hrun := (knapRun_inv hok (results.map (·.bySize)).toList 0 _ _ #[] (by simp) (by omega) + rfl hinit).1 + symm + apply knapChooseFast_eq _ hrun + have := tag0BracketStart_le (kCS + bestX.size) + simp only + omega + · rfl + · rfl + +@[csimp] theorem uniformKnapsack_eq_fast : @uniformKnapsack = @uniformKnapsackFast := by + funext limits kCS results + exact uniformKnapsack_eq_fast_apply limits kCS results + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/Oracle.lean b/Ix/Sharing/Exact/Oracle.lean new file mode 100644 index 000000000..9fadc3e49 --- /dev/null +++ b/Ix/Sharing/Exact/Oracle.lean @@ -0,0 +1,235 @@ +/- + Exact minimum sharing: tiny exhaustive reference oracle (§6.3), a test + oracle, not the compiler path. + + Deliberately independent of the telescope recurrence and the width-state + search. It enumerates + + * every ordered table over *all* distinct subterms of the roots (every + ordered subset, including leaves, roots, and useless entries), and + * every representation of each table entry and root obtained by choosing, + independently at each occurrence, the inline constructor or a reference + to an equal available entry (entry `i` may use entries `< i`), + + serializes candidates with the production writer (`putExpr`, or a + caller-supplied complete-Constant writer) and keeps the least full key + `(byte length, table term IDs, bytes)` of §3.3. + + `oracle` uses one standard reduction: for a fixed table the entries and + roots serialize as independent fixed-position parts, so the least key for + that table is obtained by choosing each part's least `(length, bytes)` + representation. `oracleProduct` drops even that reduction and enumerates + the full Cartesian product of all parts; it is only feasible for the + smallest inputs and exists to cross-check `oracle`. + + Exponential by design; every enumeration is metered and fails closed. +-/ +module + +public import Ix.Sharing.Exact.Dictionary + +public section + +namespace Ix.Sharing.Exact + +open Ixon + +/-- Oracle work counters. `candidates` counts complete candidates compared +(one per table for `oracle`, the whole product for `oracleProduct`). -/ +structure OracleWork where + tables : Nat := 0 + variants : Nat := 0 + candidates : Nat := 0 + deriving Inhabited, Repr + +abbrev OracleM := StateT OracleWork (Except SharingError) + +def chargeVariants (limits : Limits) (k : Nat) : OracleM Unit := do + let w ← get + if w.variants + k > limits.maxOracleVariants then + throw (.resourceExhausted .oracleVariants limits.maxOracleVariants) + set { w with variants := w.variants + k } + +def chargeTable (limits : Limits) (candidates : Nat) : OracleM Unit := do + let w ← get + if w.tables + 1 > limits.maxOracleTables then + throw (.resourceExhausted .oracleTables limits.maxOracleTables) + set { w with tables := w.tables + 1, candidates := w.candidates + candidates } + +/-- Every representation of term `t`: a Share to its entry if available, +plus the inline node over every combination of child representations. -/ +def variantsOf (dag : Dag) (index : Array (Option Nat)) (limits : Limits) : + Nat → Nat → OracleM (List Ixon.Expr) + | 0, _ => throw (.internal "oracle fuel exhausted") + | fuel + 1, t => do + let node := dag.node t + let go := variantsOf dag index limits fuel + let inl : List Ixon.Expr ← match node.head with + | .prj ti f => do + let vs ← go (node.child 0) + pure (vs.map (Ixon.Expr.prj ti f)) + | .app => do + let fs ← go (node.child 0) + let as ← go (node.child 1) + pure (fs.flatMap fun f => as.map (Ixon.Expr.app f)) + | .lam c => do + let tys ← go (node.child 0) + let bs ← go (node.child 1) + pure (tys.flatMap fun ty => bs.map (Ixon.Expr.lam c ty)) + | .all c r => do + let tys ← go (node.child 0) + let bs ← go (node.child 1) + pure (tys.flatMap fun ty => bs.map (Ixon.Expr.all c r ty)) + | .letE c => do + let tys ← go (node.child 0) + let vs ← go (node.child 1) + let bs ← go (node.child 2) + pure (tys.flatMap fun ty => vs.flatMap fun v => bs.map (Ixon.Expr.letE c ty v)) + | _ => pure [node.toExpr fun _ => default] + let sh := match index[t]?.getD none with + | some i => [Ixon.Expr.share i.toUInt64] + | none => [] + let out := sh ++ inl + chargeVariants limits out.length + return out + +/-- `(length, bytes)` order of serialized candidates. -/ +def keyLess (a b : ByteArray) : Bool := + a.size < b.size || (a.size == b.size && compareBytes a b == .lt) + +/-- The representation of `t` whose serialization has least +`(length, bytes)`. -/ +def bestPart (dag : Dag) (index : Array (Option Nat)) (limits : Limits) (t : Nat) : + OracleM (Ixon.Expr × ByteArray) := do + let vs ← variantsOf dag index limits (dag.size + 1) t + let mut best : Option (Ixon.Expr × ByteArray) := none + for v in vs do + let bytes := runPut (putExpr v) + match best with + | none => best := some (v, bytes) + | some (_, bb) => if keyLess bytes bb then best := some (v, bytes) + match best with + | some b => return b + | none => throw (.internal "term without representation") + +/-- Every ordered subset (sequence without repetition) of `xs`. -/ +def orderedSubsets : Nat → List Nat → List (List Nat) + | 0, _ => [[]] + | fuel + 1, xs => [] :: xs.flatMap fun x => (orderedSubsets fuel (xs.erase x)).map (x :: ·) + +/-- Oracle result. -/ +structure OracleResult where + /-- Bytes of the winning candidate (as produced by the writer). -/ + bytes : ByteArray + /-- Table term IDs of the winner. -/ + table : Array Nat + sharing : Array Ixon.Expr + roots : Array Ixon.Expr + work : OracleWork + /-- Distinct byte strings of the per-table winners that attain the minimum + length, in enumeration order. -/ + minima : Array ByteArray + deriving Inhabited + +/-- Candidate key `(length, table, bytes)` strictly smaller. -/ +def fullKeyLess (bytes : ByteArray) (table : Array Nat) (bytes' : ByteArray) + (table' : Array Nat) : Bool := + bytes.size < bytes'.size || + (bytes.size == bytes'.size && + (compareNatArray table table' == .lt || + (compareNatArray table table' == .eq && compareBytes bytes bytes' == .lt))) + +/-- Record a candidate in the running best and minima. -/ +def OracleResult.consider (best : Option OracleResult) (bytes : ByteArray) + (table : Array Nat) (sharing roots : Array Ixon.Expr) : Option OracleResult := + match best with + | none => some { bytes, table, sharing, roots, work := {}, minima := #[bytes] } + | some b => + let minima := + if bytes.size < b.bytes.size then #[bytes] + else if bytes.size == b.bytes.size && !b.minima.contains bytes then b.minima.push bytes + else b.minima + if fullKeyLess bytes table b.bytes b.table then + some { b with bytes, table, sharing, roots, minima } + else some { b with minima } + +/-- Exhaustive oracle with per-part selection. `write sharing roots` must +produce the serialized candidate (e.g. the complete Constant). -/ +def oracle (dag : Dag) (rootIds : Array Nat) + (write : Array Ixon.Expr → Array Ixon.Expr → Except SharingError ByteArray) + (limits : Limits) : Except SharingError OracleResult := do + let n := dag.size + let run : OracleM (Option OracleResult) := do + let mut best : Option OracleResult := none + for order in orderedSubsets n (List.range n) do + chargeTable limits 1 + let table := order.toArray + let mut entries : Array Ixon.Expr := #[] + for h : i in [0:table.size] do + let (e, _) ← bestPart dag (indexOfPrefix n table i) limits table[i] + entries := entries.push e + let full := indexOfPrefix n table table.size + let mut roots : Array Ixon.Expr := #[] + for r in rootIds do + let (e, _) ← bestPart dag full limits r + roots := roots.push e + let bytes ← liftM (write entries roots) + best := OracleResult.consider best bytes table entries roots + return best + let (best, work) ← run.run {} + match best with + | some b => return { b with work } + | none => throw (.internal "oracle enumerated no table") +where + liftM {α} (x : Except SharingError α) : OracleM α := + match x with + | .ok a => pure a + | .error e => throw e + +/-- Stream the Cartesian product of `parts`, folding every complete +combination (in part order) into the accumulator. -/ +def forProduct (parts : List (List Ixon.Expr)) (acc : Array Ixon.Expr) + (f : Array Ixon.Expr → Option OracleResult → Except SharingError (Option OracleResult)) + (best : Option OracleResult) : Except SharingError (Option OracleResult) := + match parts with + | [] => f acc best + | p :: rest => p.foldlM (fun b x => forProduct rest (acc.push x) f b) best + +/-- Exhaustive oracle over the full Cartesian product of every part's +representations (no separability reduction). -/ +def oracleProduct (dag : Dag) (rootIds : Array Nat) + (write : Array Ixon.Expr → Array Ixon.Expr → Except SharingError ByteArray) + (limits : Limits) : Except SharingError OracleResult := do + let n := dag.size + let run : OracleM (Option OracleResult) := do + let mut best : Option OracleResult := none + for order in orderedSubsets n (List.range n) do + chargeTable limits 0 + let table := order.toArray + let mut parts : List (List Ixon.Expr) := [] + for h : i in [0:table.size] do + parts := parts ++ [← variantsOf dag (indexOfPrefix n table i) limits (n + 1) table[i]] + let full := indexOfPrefix n table table.size + for r in rootIds do + parts := parts ++ [← variantsOf dag full limits (n + 1) r] + let count := parts.foldl (fun acc p => acc * p.length) 1 + chargeVariants limits count + modify fun w => { w with candidates := w.candidates + count } + let step (combo : Array Ixon.Expr) (b : Option OracleResult) : + Except SharingError (Option OracleResult) := do + let entries := combo.extract 0 table.size + let roots := combo.extract table.size combo.size + let bytes ← write entries roots + return OracleResult.consider b bytes table entries roots + best ← match forProduct parts #[] step best with + | .ok b => pure b + | .error e => throw e + return best + let (best, work) ← run.run {} + match best with + | some b => return { b with work } + | none => throw (.internal "oracle enumerated no table") + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/Phase3.lean b/Ix/Sharing/Exact/Phase3.lean new file mode 100644 index 000000000..15f5f9337 --- /dev/null +++ b/Ix/Sharing/Exact/Phase3.lean @@ -0,0 +1,574 @@ +/- + Exact minimum sharing: re-evaluation after one dictionary change, marked + by a walk up the parent lists. + + `Prep.evalUp ev width t` re-evaluates `t` and every term above it after + the dictionary changed only at `t`: it marks the terms of `[t, n)` that + have `t` among their descendants (`ancestorMarks`, which tests the + children of every term of the range) and re-evaluates the marked ones in + increasing ID. `Prep.evalUpFast` marks the same terms by a walk up the + parent lists from `t` (`ancWalk`: work proportional to the ancestors of + `t` and their parent edges) and re-evaluates them in the same order + (`evalMarked`), so the evaluation, its work count included, is the same. + + `Prep.evalUpFast_eq` proves it equal to `evalUp` for every DAG whose + children precede their parents, given the parent lists + `parentEdgeLists dag` and a cleared mark array, which it returns cleared. + If the walk runs out of fuel, `evalUpFast` runs `evalUp`. +-/ +module + +public import Ix.Sharing.Exact.Dictionary +import all Ix.Sharing.Exact.Basic +import all Ix.Sharing.Exact.Dag +import all Ix.Sharing.Exact.Dictionary + +public section + +namespace Ix.Sharing.Exact + +/-! ## Evaluation of one term -/ + +/-- `evalStep` at a term whose `affected` mark is set, with the evaluation +taken apart first so that its arrays are updated in place +(`evalStep_eq_evalNode`). -/ +def evalNode (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (st : DictEval) (t : Nat) : DictEval := + match st with + | ⟨cost, sides, below, work⟩ => + let node := dag.node t + let fam := family[t]! + if fam == .none then + let inl := node.children.foldl (fun acc c => acc + cost[c]!) node.head.ownBytes + let c := match widthOf width t with + | some w => min inl w + | none => inl + ⟨cost.set! t c, sides, below, work + 1⟩ + else + let nxt := node.spineNext + let same := family[nxt]! == fam + let s := node.sideExtra + cost[node.sideChild]! + (if same then sides[nxt]! else 0) + let bl : Option Nat := + if same then (if (widthOf width nxt).isSome then some nxt else below[nxt]!) + else none + let l := spineLen[t]! + let natural := tag4Size l + s + cost[tail[t]!]! + let sides := sides.set! t s + let below := below.set! t bl + let (inl, work) := cutScan spineLen sides below width l s l bl natural work + let c := match widthOf width t with + | some w => min inl w + | none => inl + ⟨cost.set! t c, sides, below, work + 1⟩ + +/-! ## Parent lists and the ancestor walk -/ + +/-- `parents[c]`: every `u` that has `c` among its children (once per such +child position), in increasing `u`. -/ +def parentEdgeLists (dag : Dag) : Array (Array Nat) := + foldRange (fun (ps : Array (Array Nat)) u => + (dag.node u).children.foldl (fun ps c => ps.modify c (·.push u)) ps) + 0 dag.size (Array.replicate dag.size #[]) + +/-- Mark and append `u` unless it is marked. -/ +@[inline] def ancVisit (acc : Array Bool × Array Nat) (u : Nat) : Array Bool × Array Nat := + match acc with + | (mark, out) => if mark[u]! then (mark, out) else (mark.set! u true, out.push u) + +/-- Walk up the parent lists: visit the parents of `out[k]`, `out[k+1]`, … +until every listed term is visited (`true`) or the fuel runs out +(`false`). -/ +def ancWalk (parents : Array (Array Nat)) : + Nat → Nat → Array Bool → Array Nat → Bool × Array Bool × Array Nat + | 0, _, mark, out => (false, mark, out) + | fuel + 1, k, mark, out => + if h : k < out.size then + match (parents[out[k]]?.getD #[]).foldl ancVisit (mark, out) with + | (mark, out) => ancWalk parents fuel (k + 1) mark out + else (true, mark, out) + +/-- Clear the marks of `s`. -/ +def unmark (mark : Array Bool) (s : Array Nat) : Array Bool := + s.foldl (fun m u => m.set! u false) mark + +/-! ## The work of a re-evaluation, counted without evaluating + +After the dictionary gains `t`, `Prep.evalUp` re-evaluates `t` and every term +above it, and counts for each of them 1 plus, for a telescope term, one per +available term strictly below it on its spine (the internal cuts `cutScan` +visits). `ancestorWork` counts the same from a walk up the parent lists and a +table of those spine counts, which `spineAdd` keeps up to date. -/ + +/-- `sp[x]`: the telescope terms whose spine continues into `x` (same family, +`x` their spine successor), each listed once. -/ +def spineParentLists (dag : Dag) (family : Array Family) : Array (Array Nat) := + foldRange (fun (sp : Array (Array Nat)) u => + let fam := family[u]! + let nxt := (dag.node u).spineNext + if fam != .none && family[nxt]! == fam then sp.modify nxt (·.push u) else sp) + 0 dag.size (Array.replicate dag.size #[]) + +/-- Add one to the spine count of every term above `x` along spine-parent +links (a depth-first walk with a stack); `none` if the fuel runs out. -/ +def spineAddGo (sp : Array (Array Nat)) : Nat → List Nat → Array Nat → Option (Array Nat) + | _, [], sc => some sc + | 0, _ :: _, _ => none + | fuel + 1, x :: stack, sc => + spineAddGo sp fuel ((sp[x]?.getD #[]).toList ++ stack) (sc.modify x (· + 1)) + +/-- `sc` after `t` became available: every term with `t` strictly below it on +its spine counts one more. -/ +def spineAdd (sp : Array (Array Nat)) (sc : Array Nat) (t : Nat) : Option (Array Nat) := + spineAddGo sp (sc.size + 1) (sp[t]?.getD #[]).toList sc + +/-- The walk of `ancestorWork`: the parents of `queue[k]` from position `j` +on are next; each term not yet marked with `epoch` is marked, queued and adds +1 plus its spine count to `sum`. `none` when the fuel runs out. -/ +def awGo (parents : Array (Array Nat)) (sc : Array Nat) (epoch : Nat) : + Nat → Nat → Nat → Array Nat → Array Nat → Nat → Option (Nat × Array Nat × Array Nat) + | 0, _, _, _, _, _ => none + | fuel + 1, k, j, mark, queue, sum => + if hk : k < queue.size then + let ps := parents[queue[k]]?.getD #[] + if hj : j < ps.size then + let u := ps[j] + if mark[u]! == epoch then awGo parents sc epoch fuel k (j + 1) mark queue sum + else awGo parents sc epoch fuel k (j + 1) (mark.set! u epoch) (queue.push u) + (sum + 1 + sc[u]!) + else awGo parents sc epoch fuel (k + 1) 0 mark queue sum + else some (sum, mark, queue) + +/-- The work `Prep.evalUp` counts after `t` became available: 1 per term at +or above `t` plus its spine count, from a walk up the parent lists that marks +with `epoch` (every mark must be below it) and reuses the queue array. -/ +def ancestorWork (parents : Array (Array Nat)) (sc : Array Nat) (epoch t fuel : Nat) + (mark queue : Array Nat) : Option (Nat × Array Nat × Array Nat) := + awGo parents sc epoch fuel 0 0 (mark.set! t epoch) ((queue.shrink 0).push t) (1 + sc[t]!) + +/-- Evaluate the marked terms of `[t, n)` in increasing ID (`evalMarked_eq`: +`foldRange` of `evalStep` with the marks as the affected terms). -/ +def evalMarked (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (mark : Array Bool) (t n : Nat) (st : DictEval) : DictEval := + foldRange (fun st u => if mark[u]! then evalNode dag family spineLen tail width st u else st) + t (n - t) st + +/-- `Prep.evalUp` with the ancestors of `t` marked by a walk up the parent +lists instead of a scan of `[t, n)` (`evalUpFast_eq`), given the parent lists +and a cleared mark array, which is returned cleared. -/ +def Prep.evalUpFast (p : Prep) (parents : Array (Array Nat)) (ev : DictEval) + (width : Array (Option Nat)) (t : Nat) (mark : Array Bool) : DictEval × Array Bool := + match ancWalk parents (p.dag.size + 1) 0 (mark.set! t true) #[t] with + | (done, mark, out) => + if done then + (evalMarked p.dag p.family p.spineLen p.tail width mark t p.dag.size { ev with work := 0 }, + unmark mark out) + else (p.evalUp ev width t, Array.replicate p.dag.size false) + +/-! ## Proofs -/ + +theorem evalStep_eq_evalNode (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (affected : Array Bool) (st : DictEval) (t : Nat) : + evalStep dag family spineLen tail width affected st t = + if affected[t]! then evalNode dag family spineLen tail width st t else st := by + cases st + unfold evalStep evalNode + rfl + +theorem evalMarked_eq (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (mark : Array Bool) (t n : Nat) (st : DictEval) : + evalMarked dag family spineLen tail width mark t n st = + foldRange (evalStep dag family spineLen tail width mark) t (n - t) st := by + unfold evalMarked + congr 1 + +/-- Induction over `foldRange`. -/ +theorem foldRange_induction {σ : Type} (f : σ → Nat → σ) (P : Nat → σ → Prop) : + ∀ (i k : Nat) (st : σ), P k st → (∀ j s, k ≤ j → j < k + i → P j s → P (j + 1) (f s j)) → + P (k + i) (foldRange f k i st) + | 0, k, st, h0, _ => by simpa [foldRange] using h0 + | i + 1, k, st, h0, hs => by + have h1 : P (k + 1) (f st k) := hs k st (Nat.le_refl _) (by omega) h0 + have := foldRange_induction f P i (k + 1) (f st k) h1 + (fun j s hj hj' hp => hs j s (by omega) (by omega) hp) + simpa [foldRange, Nat.add_assoc, Nat.add_comm 1 i] using this + +/-- `u` is `t` or has `t` below it. -/ +inductive AncOf (dag : Dag) (t : Nat) : Nat → Prop + | refl : AncOf dag t t + | step {c u : Nat} : AncOf dag t c → c ∈ (dag.node u).children → AncOf dag t u + +theorem dag_node_of_lt {dag : Dag} {u : Nat} (hu : u < dag.size) : dag.node u = dag.nodes[u] := by + simp [Dag.node, Dag.size] at hu ⊢ + simp [hu] + +theorem child_lt_of_childrenPrecede {dag : Dag} (hcp : childrenPrecede dag.nodes = true) + {u c : Nat} (hu : u < dag.size) (hc : c ∈ (dag.node u).children) : c < u := by + unfold childrenPrecede at hcp + rw [Array.all_eq_true] at hcp + have := hcp u (by simpa [Array.size_zipIdx, Dag.size] using hu) + simp only [Array.getElem_zipIdx, Nat.zero_add] at this + rw [Array.all_eq_true'] at this + rw [dag_node_of_lt hu] at hc + simpa using this c hc + +theorem AncOf.le {dag : Dag} (hcp : childrenPrecede dag.nodes = true) {t u : Nat} + (h : AncOf dag t u) (hu : u < dag.size) : t ≤ u := by + induction h with + | refl => exact Nat.le_refl _ + | step _ hc ih => + have := child_lt_of_childrenPrecede hcp hu hc + exact Nat.le_of_lt (Nat.lt_of_le_of_lt (ih (by omega)) this) + +theorem AncOf.iff {dag : Dag} {t u : Nat} : + AncOf dag t u ↔ u = t ∨ ∃ c ∈ (dag.node u).children, AncOf dag t c := by + constructor + · intro h + cases h with + | refl => exact Or.inl rfl + | step hc hm => exact Or.inr ⟨_, hm, hc⟩ + · rintro (rfl | ⟨c, hm, hc⟩) + · exact .refl + · exact .step hc hm + +theorem ancestorMarks_spec {dag : Dag} (hcp : childrenPrecede dag.nodes = true) {t : Nat} + (ht : t < dag.size) : + (ancestorMarks dag t).size = dag.size ∧ + ∀ u, (ancestorMarks dag t)[u]! = true ↔ (u < dag.size ∧ AncOf dag t u) := by + let P : Nat → Array Bool → Prop := fun j acc => + acc.size = dag.size ∧ ∀ u, acc[u]! = true ↔ (u < j ∧ u < dag.size ∧ AncOf dag t u) + have h0 : P t (Array.replicate dag.size false) := by + refine ⟨by simp, fun u => ?_⟩ + constructor + · intro h + by_cases hu : u < dag.size + · simp [getElem!_pos, hu] at h + · simp [getElem!_neg, hu] at h + · rintro ⟨hut, hu, ha⟩ + exact absurd (ha.le hcp hu) (by omega) + have := foldRange_induction (fun (acc : Array Bool) u => + acc.set! u (u == t || (dag.node u).children.any (acc[·]!))) P (dag.size - t) t _ h0 + (by + intro j acc hj hj' ⟨hsz, hacc⟩ + have hjn : j < dag.size := by omega + refine ⟨by simp [Array.set!_eq_setIfInBounds, hsz], fun u => ?_⟩ + rw [getElem!_setBang] + by_cases huj : u = j + · subst huj + rw [if_pos ⟨rfl, by rw [hsz]; exact hjn⟩] + simp only [Bool.or_eq_true, beq_iff_eq, Array.any_eq_true', hacc] + constructor + · rintro (rfl | ⟨c, hm, _, _, hc⟩) + · exact ⟨by omega, hjn, .refl⟩ + · exact ⟨by omega, hjn, .step hc hm⟩ + · rintro ⟨_, _, ha⟩ + rcases AncOf.iff.mp ha with h | ⟨c, hm, hc⟩ + · exact Or.inl h + · have hcu := child_lt_of_childrenPrecede hcp hjn hm + exact Or.inr ⟨c, hm, hcu, by omega, hc⟩ + · simp only [huj, false_and, if_false, hacc] + constructor + · rintro ⟨h1, h2, h3⟩; exact ⟨by omega, h2, h3⟩ + · rintro ⟨h1, h2, h3⟩; exact ⟨by omega, h2, h3⟩) + have heq : t + (dag.size - t) = dag.size := by omega + rw [heq] at this + obtain ⟨hsz, hm⟩ := this + unfold ancestorMarks + refine ⟨hsz, fun u => ?_⟩ + rw [hm] + constructor + · rintro ⟨_, h⟩; exact h + · rintro ⟨h1, h2⟩; exact ⟨h1, h1, h2⟩ + +/-! ### The parent lists -/ + +/-- `parents[c]` lists exactly the terms with `c` among their children. -/ +def ParentsOK (dag : Dag) (parents : Array (Array Nat)) : Prop := + ∀ c, c < dag.size → ∀ p, p ∈ (parents[c]?.getD #[]) ↔ (p < dag.size ∧ c ∈ (dag.node p).children) + +theorem modify_push_fold (u : Nat) : + ∀ (l : List Nat) (ps : Array (Array Nat)), + (l.foldl (fun ps c => ps.modify c (·.push u)) ps).size = ps.size ∧ + ∀ c p, p ∈ ((l.foldl (fun ps c => ps.modify c (·.push u)) ps)[c]?.getD #[]) ↔ + (p ∈ (ps[c]?.getD #[]) ∨ (p = u ∧ c ∈ l ∧ c < ps.size)) + | [], ps => ⟨rfl, fun c p => by simp⟩ + | d :: l, ps => by + simp only [List.foldl_cons] + obtain ⟨h1, h2⟩ := modify_push_fold u l (ps.modify d (·.push u)) + rw [Array.size_modify] at h1 + refine ⟨h1, fun c p => ?_⟩ + rw [h2, Array.getElem?_modify, Array.size_modify, List.mem_cons] + by_cases hdc : d = c + · subst hdc + rw [if_pos rfl] + by_cases hd : d < ps.size + · rw [Array.getElem?_eq_getElem hd] + simp only [Option.map_some, Option.getD_some, Array.mem_push] + grind + · rw [Array.getElem?_eq_none (Nat.le_of_not_lt hd)] + simp only [Option.map_none] + grind + · rw [if_neg hdc] + grind + +theorem parentEdgeLists_ok (dag : Dag) : ParentsOK dag (parentEdgeLists dag) := by + let P : Nat → Array (Array Nat) → Prop := fun j ps => + ps.size = dag.size ∧ ∀ c, c < dag.size → ∀ p, + p ∈ (ps[c]?.getD #[]) ↔ (p < j ∧ c ∈ (dag.node p).children) + have h0 : P 0 (Array.replicate dag.size #[]) := by + refine ⟨by simp, fun c hc p => ?_⟩ + rw [Array.getElem?_replicate] + split <;> simp + have := foldRange_induction (fun (ps : Array (Array Nat)) u => + (dag.node u).children.foldl (fun ps c => ps.modify c (·.push u)) ps) P dag.size 0 _ h0 + (by + intro j ps _ hj ⟨hsz, hps⟩ + rw [← Array.foldl_toList] + obtain ⟨h1, h2⟩ := modify_push_fold j (dag.node j).children.toList ps + refine ⟨by rw [h1, hsz], fun c hc p => ?_⟩ + rw [h2, hps c hc, Array.mem_toList_iff, hsz] + constructor + · rintro (⟨h3, h4⟩ | ⟨rfl, h4, _⟩) + · exact ⟨by omega, h4⟩ + · exact ⟨by omega, h4⟩ + · rintro ⟨h3, h4⟩ + by_cases hpj : p = j + · subst hpj; exact Or.inr ⟨rfl, h4, hc⟩ + · exact Or.inl ⟨by omega, h4⟩) + rw [Nat.zero_add] at this + obtain ⟨_, hm⟩ := this + intro c hc p + unfold parentEdgeLists + rw [hm c hc p] + +/-! ### The ancestor walk -/ + +/-- Invariant of `ancWalk`: the marks are the listed terms, every listed term +is an ancestor of `t`, and the parents of the first `k` listed terms are +listed. -/ +structure WalkInv (dag : Dag) (parents : Array (Array Nat)) (t k : Nat) (mark : Array Bool) + (out : Array Nat) : Prop where + size : mark.size = dag.size + marked : ∀ u, mark[u]! = true ↔ u ∈ out + anc : ∀ u ∈ out, u < dag.size ∧ AncOf dag t u + start : t ∈ out + closed : ∀ j (hj : j < out.size), j < k → ∀ p ∈ (parents[out[j]]?.getD #[]), p ∈ out + le : k ≤ out.size + +theorem ancVisit_pair (mark : Array Bool) (out : Array Nat) (u : Nat) : + ancVisit (mark, out) u = if mark[u]! then (mark, out) else (mark.set! u true, out.push u) := by + unfold ancVisit; rfl + +theorem ancVisit_fold {dag : Dag} {t : Nat} : + ∀ (l : List Nat) (mark : Array Bool) (out : Array Nat), + mark.size = dag.size → (∀ u, mark[u]! = true ↔ u ∈ out) → + (∀ u ∈ out, u < dag.size ∧ AncOf dag t u) → (∀ p ∈ l, p < dag.size ∧ AncOf dag t p) → + let r := l.foldl ancVisit (mark, out) + r.1.size = dag.size ∧ (∀ u, r.1[u]! = true ↔ u ∈ r.2) ∧ + (∀ u ∈ r.2, u < dag.size ∧ AncOf dag t u) ∧ (∀ p ∈ l, p ∈ r.2) ∧ + ∃ l', r.2.toList = out.toList ++ l' + | [], mark, out, hs, hm, ha, _ => by + simp only [List.foldl_nil] + exact ⟨hs, hm, ha, by simp, [], by simp⟩ + | p :: l, mark, out, hs, hm, ha, hl => by + simp only [List.foldl_cons] + have hp := hl p (by simp) + have hl' : ∀ q ∈ l, q < dag.size ∧ AncOf dag t q := fun q hq => hl q (by simp [hq]) + rw [ancVisit_pair] + by_cases hmp : mark[p]! = true + · simp only [hmp, if_true] + obtain ⟨h1, h2, h3, h4, l', h5⟩ := ancVisit_fold l mark out hs hm ha hl' + refine ⟨h1, h2, h3, ?_, l', h5⟩ + intro q hq + simp only [List.mem_cons] at hq + rcases hq with rfl | hq + · rw [Array.mem_def, h5, List.mem_append] + exact Or.inl (Array.mem_def.mp ((hm q).mp hmp)) + · exact h4 q hq + · simp only [hmp, Bool.false_eq_true, if_false] + have hs' : (mark.set! p true).size = dag.size := by + simp [Array.set!_eq_setIfInBounds, hs] + have hm' : ∀ u, (mark.set! p true)[u]! = true ↔ u ∈ out.push p := by + intro u + rw [getElem!_setBang, Array.mem_push] + by_cases hup : u = p + · subst hup; simp [hs, hp.1] + · simp [hup, hm u] + have ha' : ∀ u ∈ out.push p, u < dag.size ∧ AncOf dag t u := by + intro u hu + rcases Array.mem_push.mp hu with hu | rfl + · exact ha u hu + · exact hp + obtain ⟨h1, h2, h3, h4, l', h5⟩ := ancVisit_fold l (mark.set! p true) (out.push p) hs' hm' ha' hl' + refine ⟨h1, h2, h3, ?_, [p] ++ l', by rw [h5, Array.toList_push, List.append_assoc]⟩ + intro q hq + simp only [List.mem_cons] at hq + rcases hq with rfl | hq + · rw [Array.mem_def, h5, List.mem_append] + exact Or.inl (by simp [Array.toList_push]) + · exact h4 q hq + +theorem ancWalk_spec {dag : Dag} {parents : Array (Array Nat)} {t : Nat} + (hpar : ParentsOK dag parents) : + ∀ (fuel k : Nat) (mark : Array Bool) (out : Array Nat) (mark' : Array Bool) (out' : Array Nat), + WalkInv dag parents t k mark out → ancWalk parents fuel k mark out = (true, mark', out') → + WalkInv dag parents t out'.size mark' out' + | 0, _, _, _, _, _, _, h => by simp [ancWalk] at h + | fuel + 1, k, mark, out, mark', out', hinv, h => by + unfold ancWalk at h + split at h + · rename_i hk + have hx := hinv.anc out[k] (Array.getElem_mem hk) + have hl : ∀ p ∈ (parents[out[k]]?.getD #[]).toList, p < dag.size ∧ AncOf dag t p := by + intro p hp + have := (hpar out[k] hx.1 p).mp (Array.mem_toList_iff.mp hp) + exact ⟨this.1, .step hx.2 this.2⟩ + have hf := ancVisit_fold (dag := dag) (t := t) (parents[out[k]]?.getD #[]).toList mark out + hinv.size hinv.marked hinv.anc hl + rw [Array.foldl_toList] at hf + split at h + rename_i m2 o2 heq + rw [heq] at hf + obtain ⟨h1, h2, h3, h4, l', h5⟩ := hf + have hpre : ∀ j (hj : j < out.size), ∃ hj' : j < o2.size, o2[j] = out[j] := by + intro j hj + have hsz : o2.size = out.size + l'.length := by + rw [← Array.length_toList, h5, List.length_append, Array.length_toList] + refine ⟨by omega, ?_⟩ + have hj2 : j < out.toList.length := by rw [Array.length_toList]; exact hj + have h6 : o2[j]? = out[j]? := by + rw [← Array.getElem?_toList, ← Array.getElem?_toList, h5, List.getElem?_append_left hj2] + rw [Array.getElem?_eq_getElem hj, Array.getElem?_eq_getElem (by omega)] at h6 + exact Option.some.inj h6 + have hsub : ∀ u ∈ out, u ∈ o2 := by + intro u hu + rw [Array.mem_def, h5, List.mem_append] + exact Or.inl (Array.mem_def.mp hu) + apply ancWalk_spec hpar fuel (k + 1) m2 o2 mark' out' _ h + refine ⟨h1, h2, h3, hsub t hinv.start, ?_, ?_⟩ + · intro j hj hjk p hp + by_cases hjk' : j < k + · have hjo : j < out.size := Nat.lt_of_lt_of_le hjk' hinv.le + obtain ⟨_, he⟩ := hpre j hjo + simp only [he] at hp + exact hsub p (hinv.closed j hjo hjk' p hp) + · have hjk : j = k := by omega + subst hjk + obtain ⟨_, he⟩ := hpre j hk + simp only [he] at hp + exact h4 p (Array.mem_toList_iff.mpr hp) + · obtain ⟨hj', _⟩ := hpre k hk + omega + · rename_i hk + simp only [Prod.mk.injEq, true_and] at h + obtain ⟨rfl, rfl⟩ := h + exact { hinv with closed := fun j hj _ => hinv.closed j hj (by omega), le := Nat.le_refl _ } + +theorem WalkInv.complete {dag : Dag} {parents : Array (Array Nat)} {t : Nat} + {mark : Array Bool} {out : Array Nat} (hcp : childrenPrecede dag.nodes = true) + (hpar : ParentsOK dag parents) (hinv : WalkInv dag parents t out.size mark out) : + ∀ u, u < dag.size → AncOf dag t u → u ∈ out := by + intro u hu ha + induction ha with + | refl => exact hinv.start + | step hc hm ih => + rename_i c v + have hcv := child_lt_of_childrenPrecede hcp hu hm + have hco := ih (by omega) + obtain ⟨j, hj, rfl⟩ := Array.mem_iff_getElem.mp hco + exact hinv.closed j hj hj _ ((hpar _ (by omega) v).mpr ⟨hu, hm⟩) + +theorem unmark_spec (mark : Array Bool) (s : Array Nat) : + (unmark mark s).size = mark.size ∧ + ∀ u, (unmark mark s)[u]! = true → mark[u]! = true ∧ u ∉ s := by + unfold unmark + rw [← Array.foldl_toList] + suffices h : ∀ (l : List Nat) (m : Array Bool), (l.foldl (fun m u => m.set! u false) m).size = m.size ∧ + ∀ u, (l.foldl (fun m u => m.set! u false) m)[u]! = true → m[u]! = true ∧ u ∉ l by + obtain ⟨h1, h2⟩ := h s.toList mark + exact ⟨h1, fun u hu => by + obtain ⟨a, b⟩ := h2 u hu + exact ⟨a, fun hm => b (Array.mem_toList_iff.mpr hm)⟩⟩ + intro l + induction l with + | nil => intro m; exact ⟨rfl, fun u hu => ⟨by simpa using hu, by simp⟩⟩ + | cons v l ih => + intro m + simp only [List.foldl_cons] + obtain ⟨h1, h2⟩ := ih (m.set! v false) + refine ⟨by rw [h1]; simp [Array.set!_eq_setIfInBounds], fun u hu => ?_⟩ + obtain ⟨a, b⟩ := h2 u hu + rw [getElem!_setBang] at a + by_cases huv : u = v + · subst huv + by_cases hs : u < m.size + · simp [hs] at a + · simp only [hs, and_false, if_false] at a + rw [getElem!_neg m u hs] at a + exact absurd a (by decide) + · simp only [huv, false_and, if_false] at a + exact ⟨a, by simp [huv, b]⟩ + +theorem getElem!_replicate_false (n u : Nat) : (Array.replicate n false)[u]! = false := by + by_cases hu : u < n + · rw [getElem!_pos _ _ (by simpa using hu), Array.getElem_replicate] + · rw [getElem!_neg _ _ (by simpa using hu)]; rfl + +/-- Two arrays of the same size whose entries agree under `[·]!`. -/ +theorem array_ext_getElem! {α : Type} [Inhabited α] {a b : Array α} (hs : a.size = b.size) + (h : ∀ u : Nat, a[u]! = b[u]!) : a = b := by + apply Array.ext hs + intro i h1 h2 + have := h i + rwa [getElem!_pos a i h1, getElem!_pos b i h2] at this + +theorem Prep.evalUpFast_eq (p : Prep) (ev : DictEval) (width : Array (Option Nat)) (t : Nat) + (ht : t < p.dag.size) (hcp : childrenPrecede p.dag.nodes = true) : + p.evalUpFast (parentEdgeLists p.dag) ev width t (Array.replicate p.dag.size false) = + (p.evalUp ev width t, Array.replicate p.dag.size false) := by + have hpar := parentEdgeLists_ok p.dag + have hm0 : WalkInv p.dag (parentEdgeLists p.dag) t 0 + ((Array.replicate p.dag.size false).set! t true) #[t] := + { size := by simp [Array.set!_eq_setIfInBounds] + marked := fun u => by + rw [getElem!_setBang, Array.mem_singleton] + by_cases hut : u = t + · subst hut; simp [ht] + · simp [hut, getElem!_replicate_false] + anc := fun u hu => by + rw [Array.mem_singleton] at hu + subst hu + exact ⟨ht, .refl⟩ + start := by simp + closed := fun _ _ hj => absurd hj (Nat.not_lt_zero _) + le := Nat.zero_le _ } + unfold Prep.evalUpFast + split + rename_i done mark out heq + cases done + · rfl + · have hinv := ancWalk_spec hpar _ _ _ _ _ _ hm0 heq + obtain ⟨hasz, hanc⟩ := ancestorMarks_spec hcp ht + have hiff : ∀ u, mark[u]! = true ↔ (u < p.dag.size ∧ AncOf p.dag t u) := by + intro u + rw [hinv.marked u] + exact ⟨hinv.anc u, fun ⟨h1, h2⟩ => hinv.complete hcp hpar u h1 h2⟩ + have hmark : mark = ancestorMarks p.dag t := by + apply array_ext_getElem! (by rw [hinv.size, hasz]) + intro u + rw [Bool.eq_iff_iff, hiff, hanc] + have hun : unmark mark out = Array.replicate p.dag.size false := by + obtain ⟨h1, h2⟩ := unmark_spec mark out + apply array_ext_getElem! (by rw [h1, hinv.size, Array.size_replicate]) + intro u + rw [getElem!_replicate_false] + cases hu : (unmark mark out)[u]! + · rfl + · obtain ⟨h3, h4⟩ := h2 u hu + exact absurd ((hinv.marked u).mp h3) h4 + simp only [if_true] + rw [evalMarked_eq, hun, hmark] + rfl + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/PinnedDeps.lean b/Ix/Sharing/Exact/PinnedDeps.lean new file mode 100644 index 000000000..2857d0940 --- /dev/null +++ b/Ix/Sharing/Exact/PinnedDeps.lean @@ -0,0 +1,305 @@ +/- + Nearest stored descendants without a hash set per term. + + `pinnedDeps` walks down from every stored term to its nearest stored + descendants, keeping the visited terms in a fresh `Std.HashSet` per term. + `pinnedDepsFast` makes the same walks (same stack, same order, same fuel) + with the visited terms of the `k`-th walk marked `k + 1` in one stamp array + shared by all walks, so a walk costs its own region only. + `pinnedDeps_eq_fast : @pinnedDeps = @pinnedDepsFast` (`@[csimp]`) holds for + every input: terms outside the DAG are never stored and have no children, so + whether a walk remembers them changes neither its stack nor its output. +-/ +module + +public import Ix.Sharing.Exact.Uniform +import all Ix.Sharing.Exact.Uniform +import all Ix.Sharing.Exact.Dag +import Std.Data.HashSet.Lemmas + +public section + +namespace Ix.Sharing.Exact + +/-- One walk of `pinnedDeps` (its inner loop), visited terms as a hash set. -/ +def pinnedWalkSpec (dag : Dag) (isStored : Array Bool) : + Nat → Std.HashSet Nat → Array Nat → Array Nat → Std.HashSet Nat × Array Nat × Array Nat + | 0, seen, stack, out => (seen, stack, out) + | fuel + 1, seen, stack, out => + (stack.back?).elim (seen, stack, out) fun u => + if seen.contains u then pinnedWalkSpec dag isStored fuel seen stack.pop out + else if isStored[u]! then + pinnedWalkSpec dag isStored fuel (seen.insert u) stack.pop (out.push u) + else pinnedWalkSpec dag isStored fuel (seen.insert u) (stack.pop ++ (dag.node u).children) out + +/-- One walk with the visited terms marked `mark` in `stamp`. -/ +def pinnedWalk (dag : Dag) (isStored : Array Bool) (mark : Nat) : + Nat → Array Nat → Array Nat → Array Nat → Array Nat × Array Nat + | 0, _, stamp, out => (stamp, out) + | fuel + 1, stack, stamp, out => + (stack.back?).elim (stamp, out) fun u => + if stamp[u]! == mark then pinnedWalk dag isStored mark fuel stack.pop stamp out + else if isStored[u]! then + pinnedWalk dag isStored mark fuel stack.pop (stamp.set! u mark) (out.push u) + else pinnedWalk dag isStored mark fuel (stack.pop ++ (dag.node u).children) + (stamp.set! u mark) out + +/-- One term of `pinnedDepsFast`: walk from `t` with mark `k + 1`. -/ +def pinnedDepsStep (dag : Dag) (isStored : Array Bool) (n : Nat) + (acc : Std.HashMap Nat (Array Nat) × Array Nat × Nat) (t : Nat) : + Std.HashMap Nat (Array Nat) × Array Nat × Nat := + match acc with + | (deps, stamp, k) => + match pinnedWalk dag isStored (k + 1) (4 * n + 4) (dag.node t).children stamp #[] with + | (stamp, out) => (deps.insert t out, stamp, k + 1) + +/-- `pinnedDeps` with one stamp array for all walks. -/ +def pinnedDepsFast (dag : Dag) (stored : Array Nat) : Std.HashMap Nat (Array Nat) := + let n := dag.size + let isStored := stored.foldl (fun acc t => acc.set! t true) (Array.replicate n false) + (stored.foldl (pinnedDepsStep dag isStored n) ({}, Array.replicate n 0, 0)).1 + +/-! ## The loop of the specification -/ + +/-- One step of the inner loop of `pinnedDeps`. -/ +def pinnedStep (dag : Dag) (isStored : Array Bool) (seen : Std.HashSet Nat) + (stack out : Array Nat) : Id (ForInStep (Std.HashSet Nat × Array Nat × Array Nat)) := + (stack.back?).elim (pure (.done (seen, stack, out))) fun u => + if seen.contains u then pure (.yield (seen, stack.pop, out)) + else if isStored[u]! then pure (.yield (seen.insert u, stack.pop, out.push u)) + else pure (.yield (seen.insert u, stack.pop ++ (dag.node u).children, out)) + +theorem forIn_pinnedStep (dag : Dag) (isStored : Array Bool) + (f : Nat → Std.HashSet Nat × Array Nat × Array Nat → + Id (ForInStep (Std.HashSet Nat × Array Nat × Array Nat))) + (hf : ∀ x seen stack out, f x (seen, stack, out) = pinnedStep dag isStored seen stack out) : + ∀ (fuel s : Nat) (seen : Std.HashSet Nat) (stack out : Array Nat), + forIn (List.range' s fuel) (seen, stack, out) f = + pinnedWalkSpec dag isStored fuel seen stack out := by + intro fuel + induction fuel with + | zero => intro s seen stack out; rfl + | succ fuel ih => + intro s seen stack out + rw [List.range'_succ, List.forIn_cons, hf] + unfold pinnedStep pinnedWalkSpec + cases stack.back? with + | none => rfl + | some u => + simp only [Option.elim_some] + by_cases hs : seen.contains u = true + · simp only [hs, if_true] + exact ih _ _ _ _ + · simp only [hs, Bool.false_eq_true, if_false] + split + · exact ih _ _ _ _ + · exact ih _ _ _ _ + +/-! ## The walks agree -/ + +/-- The visited set and the stamps agree on the DAG's terms. -/ +def WalkRel (n mark : Nat) (seen : Std.HashSet Nat) (stamp : Array Nat) : Prop := + stamp.size = n ∧ ∀ u, u < n → (seen.contains u = true ↔ stamp[u]! = mark) + +theorem pinnedWalk_eq (dag : Dag) (isStored : Array Bool) (hiS : isStored.size = dag.size) + (mark : Nat) (hmark : 0 < mark) : + ∀ (fuel : Nat) (seen : Std.HashSet Nat) (stack stamp out : Array Nat), + WalkRel dag.size mark seen stamp → + (pinnedWalkSpec dag isStored fuel seen stack out).2.2 = + (pinnedWalk dag isStored mark fuel stack stamp out).2 ∧ + (pinnedWalk dag isStored mark fuel stack stamp out).1.size = dag.size ∧ + ∀ u, u < dag.size → (pinnedWalk dag isStored mark fuel stack stamp out).1[u]! = stamp[u]! ∨ + (pinnedWalk dag isStored mark fuel stack stamp out).1[u]! = mark := by + intro fuel + induction fuel with + | zero => intro seen stack stamp out h; exact ⟨rfl, h.1, fun u _ => Or.inl rfl⟩ + | succ fuel ih => + intro seen stack stamp out h + obtain ⟨hsz, hrel⟩ := h + unfold pinnedWalkSpec pinnedWalk + cases stack.back? with + | none => exact ⟨rfl, hsz, fun u _ => Or.inl rfl⟩ + | some u => + simp only [Option.elim_some] + by_cases hu : u < dag.size + · -- a term of the DAG: the two visited sets agree on it + by_cases hs : seen.contains u = true + · have hm : (stamp[u]! == mark) = true := by simpa using (hrel u hu).mp hs + simp only [hs, if_true, hm] + exact ih _ _ _ _ ⟨hsz, hrel⟩ + · have hm : (stamp[u]! == mark) = false := by + simp only [beq_eq_false_iff_ne, ne_eq] + exact fun h' => hs ((hrel u hu).mpr h') + simp only [hs, Bool.false_eq_true, if_false, hm] + have hrel' : WalkRel dag.size mark (seen.insert u) (stamp.set! u mark) := by + refine ⟨by simp [hsz], fun v hv => ?_⟩ + rw [Std.HashSet.contains_insert] + by_cases hvu : v = u + · subst hvu + simp only [beq_self_eq_true, Bool.true_or, true_iff] + simp only [Array.set!_eq_setIfInBounds, getElem!_def] + rw [Array.getElem?_setIfInBounds] + simp [hsz, hv] + · have : (u == v) = false := by + simp only [beq_eq_false_iff_ne, ne_eq]; exact fun h' => hvu h'.symm + rw [this, Bool.false_or, hrel v hv] + simp only [Array.set!_eq_setIfInBounds, getElem!_def] + rw [Array.getElem?_setIfInBounds] + simp [Ne.symm hvu] + have hkeep : ∀ (r : Array Nat × Array Nat), (r.1.size = dag.size ∧ + ∀ v, v < dag.size → r.1[v]! = (stamp.set! u mark)[v]! ∨ r.1[v]! = mark) → + r.1.size = dag.size ∧ ∀ v, v < dag.size → r.1[v]! = stamp[v]! ∨ r.1[v]! = mark := by + intro r ⟨h1, h2⟩ + refine ⟨h1, fun v hv => ?_⟩ + rcases h2 v hv with h3 | h3 + · rw [h3] + by_cases hvu : v = u + · subst hvu + right + simp only [Array.set!_eq_setIfInBounds, getElem!_def] + rw [Array.getElem?_setIfInBounds] + simp [hsz, hv] + · left + simp only [Array.set!_eq_setIfInBounds, getElem!_def] + rw [Array.getElem?_setIfInBounds] + simp [Ne.symm hvu] + · exact Or.inr h3 + split + · obtain ⟨e1, e2, e3⟩ := ih _ _ _ _ hrel' + exact ⟨e1, hkeep _ ⟨e2, e3⟩⟩ + · obtain ⟨e1, e2, e3⟩ := ih _ _ _ _ hrel' + exact ⟨e1, hkeep _ ⟨e2, e3⟩⟩ + · -- a term outside the DAG: not stored, no children, no stamp + have hnode : (dag.node u).children = #[] := by + unfold Dag.node + rw [Array.getElem?_eq_none (by simp only [Dag.size] at hu; omega)] + rfl + have hst : isStored[u]! = false := by + rw [getElem!_neg isStored u (by omega)] + rfl + have hstamp : stamp[u]! = 0 := by + rw [getElem!_neg stamp u (by omega)] + rfl + have hm : (stamp[u]! == mark) = false := by + rw [hstamp]; simp only [beq_eq_false_iff_ne, ne_eq]; omega + have hset : stamp.set! u mark = stamp := by + simp only [Array.set!_eq_setIfInBounds] + exact Array.setIfInBounds_eq_of_size_le (by omega) + simp only [hm, hst, Bool.false_eq_true, if_false, hnode, Array.append_empty, hset] + have hrel' : WalkRel dag.size mark (seen.insert u) stamp := by + refine ⟨hsz, fun v hv => ?_⟩ + rw [Std.HashSet.contains_insert] + have : (u == v) = false := by + simp only [beq_eq_false_iff_ne, ne_eq]; omega + rw [this, Bool.false_or] + exact hrel v hv + by_cases hs : seen.contains u = true + · simp only [hs, if_true] + exact ih _ _ _ _ ⟨hsz, hrel⟩ + · simp only [hs, Bool.false_eq_true, if_false] + exact ih _ _ _ _ hrel' + +/-! ## All walks -/ + +/-- `pinnedDeps` with its inner loop body written as `pinnedStep`. -/ +def pinnedDepsAlt (dag : Dag) (stored : Array Nat) : Std.HashMap Nat (Array Nat) := Id.run do + let n := dag.size + let isStored := stored.foldl (fun acc t => acc.set! t true) (Array.replicate n false) + let mut deps : Std.HashMap Nat (Array Nat) := {} + for t in stored do + let r ← forIn [0:4 * n + 4] ((∅ : Std.HashSet Nat), (dag.node t).children, (#[] : Array Nat)) + fun _ s => pinnedStep dag isStored s.1 s.2.1 s.2.2 + deps := deps.insert t r.2.2 + return deps + +theorem pinnedDeps_eq_alt (dag : Dag) (stored : Array Nat) : + pinnedDeps dag stored = pinnedDepsAlt dag stored := by + unfold pinnedDeps pinnedDepsAlt + simp only [Id.run] + congr 1 + congr 1 + funext t deps + congr 1 + · congr 1 + funext x s + obtain ⟨seen, stack, out⟩ := s + unfold pinnedStep + simp only + cases stack.back? <;> rfl + +theorem pinnedDepsAlt_eq_foldl (dag : Dag) (stored : Array Nat) : + pinnedDepsAlt dag stored = + stored.foldl (fun deps t => deps.insert t + (pinnedWalkSpec dag (stored.foldl (fun acc t => acc.set! t true) + (Array.replicate dag.size false)) (4 * dag.size + 4) ∅ (dag.node t).children #[]).2.2) {} := by + unfold pinnedDepsAlt + have key := forIn_pinnedStep dag (stored.foldl (fun acc t => acc.set! t true) + (Array.replicate dag.size false)) + (fun _ s => pinnedStep dag (stored.foldl (fun acc t => acc.set! t true) + (Array.replicate dag.size false)) s.1 s.2.1 s.2.2) (fun _ _ _ _ => rfl) + simp only [Std.Legacy.Range.forIn_eq_forIn_range', key] + simp [Id.run] + rfl + +theorem pinnedDepsStep_eq (dag : Dag) (isStored : Array Bool) (n : Nat) + (deps : Std.HashMap Nat (Array Nat)) (stamp : Array Nat) (k t : Nat) : + pinnedDepsStep dag isStored n (deps, stamp, k) t = + (deps.insert t (pinnedWalk dag isStored (k + 1) (4 * n + 4) (dag.node t).children stamp #[]).2, + (pinnedWalk dag isStored (k + 1) (4 * n + 4) (dag.node t).children stamp #[]).1, k + 1) := by + unfold pinnedDepsStep + rfl + +theorem pinnedDeps_foldl (dag : Dag) (isStored : Array Bool) (hiS : isStored.size = dag.size) : + ∀ (l : List Nat) (deps : Std.HashMap Nat (Array Nat)) (stamp : Array Nat) (k : Nat), + stamp.size = dag.size → (∀ u, u < dag.size → stamp[u]! ≤ k) → + l.foldl (fun deps t => deps.insert t + (pinnedWalkSpec dag isStored (4 * dag.size + 4) ∅ (dag.node t).children #[]).2.2) deps = + (l.foldl (pinnedDepsStep dag isStored dag.size) (deps, stamp, k)).1 := by + intro l + induction l with + | nil => intro deps stamp k _ _; rfl + | cons t l ih => + intro deps stamp k hsz hle + simp only [List.foldl_cons] + rw [pinnedDepsStep_eq] + obtain ⟨e1, e2, e3⟩ := pinnedWalk_eq dag isStored hiS (k + 1) (by omega) (4 * dag.size + 4) + ∅ (dag.node t).children stamp #[] + ⟨hsz, fun u hu => by + simp only [Std.HashSet.contains_empty, Bool.false_eq_true, false_iff] + have := hle u hu + omega⟩ + rw [e1] + apply ih _ _ _ e2 + intro u hu + rcases e3 u hu with h | h + · rw [h]; have := hle u hu; omega + · rw [h]; exact Nat.le_refl _ + +theorem foldl_set_size (stored : List Nat) (A : Array Bool) : + (stored.foldl (fun acc t => acc.set! t true) A).size = A.size := by + induction stored generalizing A with + | nil => rfl + | cons t l ih => simp only [List.foldl_cons]; rw [ih]; simp + +theorem pinnedDeps_eq_fast_apply (dag : Dag) (stored : Array Nat) : + pinnedDeps dag stored = pinnedDepsFast dag stored := by + rw [pinnedDeps_eq_alt, pinnedDepsAlt_eq_foldl] + unfold pinnedDepsFast + simp only + have hiS : (stored.foldl (fun acc t => acc.set! t true) (Array.replicate dag.size false)).size = + dag.size := by + rw [← Array.foldl_toList, foldl_set_size]; simp + generalize stored.foldl (fun acc t => acc.set! t true) (Array.replicate dag.size false) = + isStored at hiS ⊢ + rw [← Array.foldl_toList, ← Array.foldl_toList] + exact pinnedDeps_foldl dag _ hiS stored.toList {} (Array.replicate dag.size 0) 0 (by simp) + (fun u hu => by + rw [getElem!_pos _ u (by simpa using hu)]; simp) + +@[csimp] theorem pinnedDeps_eq_fast : @pinnedDeps = @pinnedDepsFast := by + funext dag stored + exact pinnedDeps_eq_fast_apply dag stored + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/PinnedFast.lean b/Ix/Sharing/Exact/PinnedFast.lean new file mode 100644 index 000000000..e212f38fd --- /dev/null +++ b/Ix/Sharing/Exact/PinnedFast.lean @@ -0,0 +1,555 @@ +/- + Fast pinned table order (phase-1 finish and phase 2). + + `pinnedOrder` places one term at a time: among the remaining terms whose + nearest stored descendants are all placed, the one with the larger in-degree, + then the smaller ID. The specification scans every remaining term at every + step (quadratic in the stored terms). `pinnedOrderFast` keeps the ready terms + in a `Std.TreeSet` of priority keys (`pinnedKey`, in-degree descending then + ID ascending) and, after each placement, adds the users of the placed term + that became ready: O((k + edges) log k). The nearest stored descendants are + still computed by `pinnedDeps`. + + `pinnedOrder_eq_fast : @pinnedOrder = @pinnedOrderFast` (`@[csimp]`) holds + for every input: the fast placement runs when the stored terms are strictly + increasing (the case of every caller), and the specification otherwise. +-/ +module + +public import Ix.Sharing.Exact.Uniform +public import Ix.Sharing.Exact.PinnedDeps +import all Ix.Sharing.Exact.Uniform +import Std.Data.HashSet.Lemmas +import Std.Data.HashMap.Lemmas +import Std.Data.TreeSet.Lemmas + +public section + +namespace Ix.Sharing.Exact + +/-! ## The placement -/ + +/-- Priority key of a term in the pinned order (smaller first): the larger +in-degree first, then the smaller ID, for terms below `B` with in-degree at +most `D`. -/ +@[inline] def pinnedKey (deg : Array Nat) (D B t : Nat) : Nat := (D - deg[t]!) * B + t + +/-- Whether every nearest stored descendant of `t` is placed. -/ +@[inline] def pinnedReady (deps : Std.HashMap Nat (Array Nat)) (placed : Std.HashSet Nat) + (t : Nat) : Bool := + (deps.getD t #[]).all placed.contains + +/-- The users of every term: `u` (once per occurrence) for each stored `u` +with `d` among its nearest stored descendants, at `d`. -/ +def pinnedUsers (deps : Std.HashMap Nat (Array Nat)) (stored : Array Nat) : + Std.HashMap Nat (Array Nat) := + stored.foldl (fun us u => (deps.getD u #[]).foldl + (fun us d => us.alter d fun o => some ((o.getD #[]).push u)) us) {} + +/-- Add the keys of the unplaced terms of `us` that are ready. -/ +def pinnedWake (deg : Array Nat) (deps : Std.HashMap Nat (Array Nat)) (D B : Nat) + (placed : Std.HashSet Nat) (us : Array Nat) (ready : Std.TreeSet Nat) : Std.TreeSet Nat := + us.foldl (fun r u => + if !placed.contains u && pinnedReady deps placed u then r.insert (pinnedKey deg D B u) + else r) ready + +/-- `pinnedPlace` with the ready terms kept as keys in `ready`; the unplaced +terms are the stored terms not in `placed`. -/ +def pinnedPlaceFast (deg : Array Nat) (deps users : Std.HashMap Nat (Array Nat)) (D B : Nat) + (stored : Array Nat) : + Nat → Array Nat → Std.HashSet Nat → Std.TreeSet Nat → Array Nat + | 0, order, placed, _ => order ++ stored.filter (!placed.contains ·) + | fuel + 1, order, placed, ready => + match ready.min? with + | none => order ++ stored.filter (!placed.contains ·) + | some key => + let pick := key % B + let placed := placed.insert pick + pinnedPlaceFast deg deps users D B stored fuel (order.push pick) placed + (pinnedWake deg deps D B placed (users.getD pick #[]) (ready.erase key)) + +/-- Strictly increasing. -/ +def incList : List Nat → Bool + | [] => true + | [_] => true + | a :: b :: l => decide (a < b) && incList (b :: l) + +/-- `pinnedOrder` with a priority set of ready terms (module doc). -/ +def pinnedOrderFast (dag : Dag) (deg : Array Nat) (stored : Array Nat) : Array Nat := + if incList stored.toList then + let deps := pinnedDeps dag stored + let D := stored.foldl (fun m t => max m deg[t]!) 0 + let B := stored.foldl (fun m t => max m (t + 1)) 0 + let ready := pinnedWake deg deps D B {} stored {} + pinnedPlaceFast deg deps (pinnedUsers deps stored) D B stored stored.size #[] {} ready + else pinnedOrder dag deg stored + +/-! ## Keys -/ + +theorem lex_lt {x y t a B : Nat} (ht : t < B) (ha : a < B) : + x * B + t < y * B + a ↔ x < y ∨ (x = y ∧ t < a) := by + constructor + · intro h + rcases Nat.lt_trichotomy x y with hxy | hxy | hxy + · exact Or.inl hxy + · subst hxy; exact Or.inr ⟨rfl, by omega⟩ + · exfalso + have h1 : (y + 1) * B ≤ x * B := Nat.mul_le_mul_right B hxy + rw [Nat.succ_mul] at h1 + omega + · rintro (h | ⟨rfl, h⟩) + · have h1 : (x + 1) * B ≤ y * B := Nat.mul_le_mul_right B h + rw [Nat.succ_mul] at h1 + omega + · omega + +/-- The terms the keys are taken over: below `B`, in-degree at most `D`. -/ +def KeyOK (deg : Array Nat) (D B t : Nat) : Prop := t < B ∧ deg[t]! ≤ D + +theorem pinnedKey_mod {deg : Array Nat} {D B t : Nat} (h : KeyOK deg D B t) : + pinnedKey deg D B t % B = t := by + unfold pinnedKey + rw [Nat.mul_comm, Nat.mul_add_mod] + exact Nat.mod_eq_of_lt h.1 + +theorem pinnedKey_inj {deg : Array Nat} {D B t a : Nat} (ht : KeyOK deg D B t) + (ha : KeyOK deg D B a) (h : pinnedKey deg D B t = pinnedKey deg D B a) : t = a := by + have := congrArg (· % B) h + simp only [pinnedKey_mod ht, pinnedKey_mod ha] at this + exact this + +/-- The tie order of `pinnedPick` is the key order. -/ +theorem better_iff_key {deg : Array Nat} {D B t a : Nat} (ht : KeyOK deg D B t) + (ha : KeyOK deg D B a) : + (deg[t]! > deg[a]! || (deg[t]! == deg[a]! && t < a)) = true ↔ + pinnedKey deg D B t < pinnedKey deg D B a := by + unfold pinnedKey + rw [lex_lt ht.1 ha.1] + have h1 := ht.2 + have h2 := ha.2 + simp only [Bool.or_eq_true, decide_eq_true_eq, Bool.and_eq_true, beq_iff_eq] + omega + +/-! ## The pick -/ + +/-- The fold of `pinnedPick` (any step function `f` with its two equations): +the least key of the list, or `none`. -/ +theorem pinnedPick_fold {deg : Array Nat} {D B : Nat} (f : Option Nat → Nat → Option Nat) + (hf1 : ∀ t, f none t = some t) + (hf2 : ∀ a t, f (some a) t = + if (deg[t]! > deg[a]! || (deg[t]! == deg[a]! && t < a)) = true then some t else some a) : + ∀ (L : List Nat) (acc : Option Nat), + (∀ t ∈ L, KeyOK deg D B t) → (∀ a, acc = some a → KeyOK deg D B a) → + (L.foldl f acc = none ↔ acc = none ∧ L = []) ∧ + ∀ m, L.foldl f acc = some m → (m ∈ L ∨ acc = some m) ∧ KeyOK deg D B m ∧ + (∀ x ∈ L, pinnedKey deg D B m ≤ pinnedKey deg D B x) ∧ + (∀ a, acc = some a → pinnedKey deg D B m ≤ pinnedKey deg D B a) := by + intro L + induction L with + | nil => + intro acc _ hacc + simp only [List.foldl_nil] + refine ⟨by simp, fun m hm => ⟨Or.inr hm, hacc m hm, fun x hx => by simp at hx, fun a ha => ?_⟩⟩ + rw [hm] at ha; cases ha; exact Nat.le_refl _ + | cons t ts ih => + intro acc hL hacc + simp only [List.foldl_cons] + have ht := hL t (List.mem_cons_self) + have hts : ∀ x ∈ ts, KeyOK deg D B x := fun x hx => hL x (List.mem_cons_of_mem _ hx) + cases acc with + | none => + rw [hf1] + obtain ⟨hnone, hsome⟩ := ih (some t) hts (fun a ha => by cases ha; exact ht) + refine ⟨⟨fun h => absurd (hnone.mp h).1 (by simp), fun h => by simp at h⟩, fun m hm => ?_⟩ + obtain ⟨hmem, hok, hle, hlea⟩ := hsome m hm + refine ⟨?_, hok, fun x hx => ?_, fun a ha => by cases ha⟩ + · rcases hmem with h | h + · exact Or.inl (List.mem_cons_of_mem _ h) + · cases h; exact Or.inl List.mem_cons_self + · rcases List.mem_cons.mp hx with h | h + · subst h; exact hlea x rfl + · exact hle x h + | some a => + rw [hf2] + have ha := hacc a rfl + by_cases hb : (deg[t]! > deg[a]! || (deg[t]! == deg[a]! && t < a)) = true + · simp only [hb, if_true] + have hlt := (better_iff_key ht ha).mp hb + obtain ⟨hnone, hsome⟩ := ih (some t) hts (fun a ha => by cases ha; exact ht) + refine ⟨⟨fun h => absurd (hnone.mp h).1 (by simp), fun h => by simp at h⟩, fun m hm => ?_⟩ + obtain ⟨hmem, hok, hle, hlea⟩ := hsome m hm + have hmt := hlea t rfl + refine ⟨?_, hok, fun x hx => ?_, fun a' ha' => ?_⟩ + · rcases hmem with h | h + · exact Or.inl (List.mem_cons_of_mem _ h) + · cases h; exact Or.inl List.mem_cons_self + · rcases List.mem_cons.mp hx with h | h + · subst h; exact hmt + · exact hle x h + · cases ha'; omega + · simp only [hb, Bool.false_eq_true, if_false] + have hge : pinnedKey deg D B a ≤ pinnedKey deg D B t := by + have := mt (better_iff_key ht ha).mpr hb + omega + obtain ⟨hnone, hsome⟩ := ih (some a) hts (fun a' ha' => by cases ha'; exact ha) + refine ⟨⟨fun h => absurd (hnone.mp h).1 (by simp), fun h => by simp at h⟩, fun m hm => ?_⟩ + obtain ⟨hmem, hok, hle, hlea⟩ := hsome m hm + have hma := hlea a rfl + refine ⟨?_, hok, fun x hx => ?_, hlea⟩ + · rcases hmem with h | h + · exact Or.inl (List.mem_cons_of_mem _ h) + · exact Or.inr h + · rcases List.mem_cons.mp hx with h | h + · subst h; omega + · exact hle x h + +/-- `pinnedPick_spec` for a generic step function. -/ +theorem pinnedPick_spec_aux {deg : Array Nat} {D B : Nat} {deps : Std.HashMap Nat (Array Nat)} + {placed : Std.HashSet Nat} {remaining : Array Nat} + (hok : ∀ t ∈ remaining.toList, KeyOK deg D B t) (f : Option Nat → Nat → Option Nat) + (hf1 : ∀ t, f none t = some t) + (hf2 : ∀ a t, f (some a) t = + if (deg[t]! > deg[a]! || (deg[t]! == deg[a]! && t < a)) = true then some t else some a) : + ((remaining.toList.filter fun t => (deps.getD t #[]).all placed.contains).foldl f none = none ↔ + ∀ t ∈ remaining.toList, pinnedReady deps placed t = false) ∧ + ∀ m, (remaining.toList.filter fun t => (deps.getD t #[]).all placed.contains).foldl f none + = some m → + m ∈ remaining.toList ∧ pinnedReady deps placed m = true ∧ + ∀ x ∈ remaining.toList, pinnedReady deps placed x = true → + pinnedKey deg D B m ≤ pinnedKey deg D B x := by + have hL : ∀ t ∈ remaining.toList.filter (fun t => (deps.getD t #[]).all placed.contains), + KeyOK deg D B t := fun t ht => hok t (List.mem_filter.mp ht).1 + obtain ⟨hnone, hsome⟩ := pinnedPick_fold (deg := deg) (D := D) (B := B) f hf1 hf2 _ none hL + (fun a ha => by cases ha) + refine ⟨?_, fun m hm => ?_⟩ + · rw [hnone] + simp only [true_and, List.filter_eq_nil_iff, pinnedReady] + constructor + · intro h t ht; simpa using h t ht + · intro h t ht; simpa using h t ht + · obtain ⟨hmem, _, hle, _⟩ := hsome m hm + rcases hmem with hmem | hmem + · obtain ⟨h1, h2⟩ := List.mem_filter.mp hmem + exact ⟨h1, h2, fun x hx hr => hle x (List.mem_filter.mpr ⟨hx, hr⟩)⟩ + · cases hmem + +/-- The pick of the specification is the term of least key among the ready +remaining terms. -/ +theorem pinnedPick_spec {deg : Array Nat} {D B : Nat} {deps : Std.HashMap Nat (Array Nat)} + {placed : Std.HashSet Nat} {remaining : Array Nat} + (hok : ∀ t ∈ remaining.toList, KeyOK deg D B t) : + (pinnedPick deg deps placed remaining = none ↔ + ∀ t ∈ remaining.toList, pinnedReady deps placed t = false) ∧ + ∀ m, pinnedPick deg deps placed remaining = some m → + m ∈ remaining.toList ∧ pinnedReady deps placed m = true ∧ + ∀ x ∈ remaining.toList, pinnedReady deps placed x = true → + pinnedKey deg D B m ≤ pinnedKey deg D B x := by + unfold pinnedPick + rw [← Array.foldl_toList, Array.toList_filter] + refine pinnedPick_spec_aux hok _ ?_ ?_ + · intro t; rfl + · intro a t; rfl + +/-! ## Users, wake-ups, bounds -/ + +theorem users_inner (u : Nat) : + ∀ (ds : List Nat) (us : Std.HashMap Nat (Array Nat)) (x d : Nat), + x ∈ ((ds.foldl (fun us d => us.alter d fun o => some ((o.getD #[]).push u)) us).getD + d #[]).toList ↔ + x ∈ (us.getD d #[]).toList ∨ (x = u ∧ d ∈ ds) := by + intro ds + induction ds with + | nil => intro us x d; simp + | cons d0 ds ih => + intro us x d + simp only [List.foldl_cons] + rw [ih] + rw [Std.HashMap.getD_alter] + by_cases hd : d0 = d + · subst hd + have hp : ∀ a : Array Nat, x ∈ (a.push u).toList ↔ x ∈ a.toList ∨ x = u := by + intro a; simp only [Array.toList_push, List.mem_append, List.mem_singleton] + simp only [beq_self_eq_true, if_true, Option.getD_some, hp, + ← Std.HashMap.getD_eq_getD_getElem?, List.mem_cons_self, and_true] + constructor + · rintro ((h | h) | ⟨h, _⟩) + · exact Or.inl h + · exact Or.inr h + · exact Or.inr h + · rintro (h | h) + · exact Or.inl (Or.inl h) + · exact Or.inl (Or.inr h) + · have h1 : (d0 == d) = false := by simpa using hd + simp only [h1, Bool.false_eq_true, if_false, List.mem_cons] + constructor + · rintro (h | ⟨h1, h2⟩) + · exact Or.inl h + · exact Or.inr ⟨h1, Or.inr h2⟩ + · rintro (h | ⟨h1, h2 | h2⟩) + · exact Or.inl h + · exact absurd h2.symm hd + · exact Or.inr ⟨h1, h2⟩ + +theorem users_outer (deps : Std.HashMap Nat (Array Nat)) : + ∀ (l : List Nat) (us : Std.HashMap Nat (Array Nat)) (x d : Nat), + x ∈ ((l.foldl (fun us u => (deps.getD u #[]).foldl + (fun us d => us.alter d fun o => some ((o.getD #[]).push u)) us) us).getD d #[]).toList ↔ + x ∈ (us.getD d #[]).toList ∨ (x ∈ l ∧ d ∈ (deps.getD x #[]).toList) := by + intro l + induction l with + | nil => intro us x d; simp + | cons u l ih => + intro us x d + simp only [List.foldl_cons] + rw [ih, ← Array.foldl_toList, users_inner] + constructor + · rintro ((h | ⟨rfl, h⟩) | ⟨h1, h2⟩) + · exact Or.inl h + · exact Or.inr ⟨List.mem_cons_self, h⟩ + · exact Or.inr ⟨List.mem_cons_of_mem _ h1, h2⟩ + · rintro (h | ⟨h1, h2⟩) + · exact Or.inl (Or.inl h) + · rcases List.mem_cons.mp h1 with rfl | h1 + · exact Or.inl (Or.inr ⟨rfl, h2⟩) + · exact Or.inr ⟨h1, h2⟩ + +theorem pinnedUsers_mem (deps : Std.HashMap Nat (Array Nat)) (stored : Array Nat) (x d : Nat) : + x ∈ ((pinnedUsers deps stored).getD d #[]).toList ↔ + x ∈ stored.toList ∧ d ∈ (deps.getD x #[]).toList := by + unfold pinnedUsers + rw [← Array.foldl_toList, users_outer] + simp + +theorem wake_mem (deg : Array Nat) (deps : Std.HashMap Nat (Array Nat)) (D B : Nat) + (placed : Std.HashSet Nat) : + ∀ (us : List Nat) (ready : Std.TreeSet Nat) (key : Nat), + key ∈ us.foldl (fun r u => + if (!placed.contains u && pinnedReady deps placed u) = true then + r.insert (pinnedKey deg D B u) + else r) ready ↔ + key ∈ ready ∨ ∃ u ∈ us, placed.contains u = false ∧ pinnedReady deps placed u = true ∧ + key = pinnedKey deg D B u := by + intro us + induction us with + | nil => intro ready key; simp + | cons u us ih => + intro ready key + simp only [List.foldl_cons] + rw [ih] + split + · rename_i hc + simp only [Bool.and_eq_true, Bool.not_eq_true'] at hc + rw [Std.TreeSet.mem_insert, Nat.compare_eq_eq] + constructor + · rintro ((h | h) | ⟨v, hv, h⟩) + · exact Or.inr ⟨u, List.mem_cons_self, hc.1, hc.2, h.symm⟩ + · exact Or.inl h + · exact Or.inr ⟨v, List.mem_cons_of_mem _ hv, h⟩ + · rintro (h | ⟨v, hv, h⟩) + · exact Or.inl (Or.inr h) + · rcases List.mem_cons.mp hv with rfl | hv + · exact Or.inl (Or.inl h.2.2.symm) + · exact Or.inr ⟨v, hv, h⟩ + · rename_i hc + constructor + · rintro (h | ⟨v, hv, h⟩) + · exact Or.inl h + · exact Or.inr ⟨v, List.mem_cons_of_mem _ hv, h⟩ + · rintro (h | ⟨v, hv, h⟩) + · exact Or.inl h + · rcases List.mem_cons.mp hv with rfl | hv + · exact absurd (by simp [h.1, h.2.1]) hc + · exact Or.inr ⟨v, hv, h⟩ + +theorem pinnedWake_mem (deg : Array Nat) (deps : Std.HashMap Nat (Array Nat)) (D B : Nat) + (placed : Std.HashSet Nat) (us : Array Nat) (ready : Std.TreeSet Nat) (key : Nat) : + key ∈ pinnedWake deg deps D B placed us ready ↔ + key ∈ ready ∨ ∃ u ∈ us.toList, placed.contains u = false ∧ + pinnedReady deps placed u = true ∧ key = pinnedKey deg D B u := by + unfold pinnedWake + rw [← Array.foldl_toList] + exact wake_mem deg deps D B placed us.toList ready key + +theorem foldl_max_ge (f : Nat → Nat) : + ∀ (l : List Nat) (init : Nat), + init ≤ l.foldl (fun m t => max m (f t)) init ∧ + ∀ t ∈ l, f t ≤ l.foldl (fun m t => max m (f t)) init + | [], init => ⟨Nat.le_refl _, fun t ht => by simp at ht⟩ + | a :: l, init => by + obtain ⟨h1, h2⟩ := foldl_max_ge f l (max init (f a)) + simp only [List.foldl_cons] + refine ⟨Nat.le_trans (Nat.le_max_left _ _) h1, fun t ht => ?_⟩ + rcases List.mem_cons.mp ht with rfl | ht + · exact Nat.le_trans (Nat.le_max_right _ _) h1 + · exact h2 t ht + +theorem incList_lt : ∀ (a : Nat) (l : List Nat), incList (a :: l) = true → ∀ x ∈ l, a < x + | a, [], _, x, hx => by simp at hx + | a, b :: l, h, x, hx => by + simp only [incList, Bool.and_eq_true, decide_eq_true_eq] at h + rcases List.mem_cons.mp hx with rfl | hx + · exact h.1 + · exact Nat.lt_trans h.1 (incList_lt b l h.2 x hx) + +theorem incList_nodup : ∀ (l : List Nat), incList l = true → l.Nodup + | [], _ => List.nodup_nil + | [_], _ => by simp + | a :: b :: l, h => by + have hlt := incList_lt a (b :: l) h + have h2 : incList (b :: l) = true := by + simp only [incList, Bool.and_eq_true] at h + exact h.2 + exact List.nodup_cons.mpr ⟨fun hm => Nat.lt_irrefl a (hlt a hm), incList_nodup (b :: l) h2⟩ + +theorem toList_erase' (xs : Array Nat) (a : Nat) : (xs.erase a).toList = xs.toList.erase a := by + rcases xs with ⟨xs⟩ + simp + +/-! ## The simulation -/ + +/-- The fast state represents the specification's: the remaining terms are the +unplaced stored terms (in order), and the ready set holds the keys of the +ready remaining terms. -/ +def SimInv (deg : Array Nat) (deps : Std.HashMap Nat (Array Nat)) (D B : Nat) + (stored remaining : Array Nat) (placed : Std.HashSet Nat) (ready : Std.TreeSet Nat) : Prop := + remaining.toList = stored.toList.filter (fun t => !placed.contains t) ∧ + ∀ key, key ∈ ready ↔ ∃ t ∈ remaining.toList, pinnedReady deps placed t = true ∧ + key = pinnedKey deg D B t + +theorem pinnedReady_insert {deps : Std.HashMap Nat (Array Nat)} {placed : Std.HashSet Nat} + {t m : Nat} (h : pinnedReady deps placed t = true) : + pinnedReady deps (placed.insert m) t = true := by + unfold pinnedReady at * + rw [Array.all_eq_true] at * + intro i hi + rw [Std.HashSet.contains_insert, h i hi, Bool.or_true] + +theorem pinnedPlace_eq_fast (deg : Array Nat) (deps : Std.HashMap Nat (Array Nat)) (D B : Nat) + (stored : Array Nat) (hnd : stored.toList.Nodup) + (hok : ∀ t ∈ stored.toList, KeyOK deg D B t) : + ∀ (fuel : Nat) (order remaining : Array Nat) (placed : Std.HashSet Nat) + (ready : Std.TreeSet Nat), + SimInv deg deps D B stored remaining placed ready → + pinnedPlace deg deps fuel order remaining placed = + pinnedPlaceFast deg deps (pinnedUsers deps stored) D B stored fuel order placed ready := by + intro fuel + induction fuel with + | zero => + intro order remaining placed ready ⟨hrem, _⟩ + simp only [pinnedPlace, pinnedPlaceFast] + congr 1 + apply Array.toList_inj.mp + rw [hrem, Array.toList_filter] + | succ fuel ih => + intro order remaining placed ready ⟨hrem, hready⟩ + have hokr : ∀ t ∈ remaining.toList, KeyOK deg D B t := by + intro t ht + rw [hrem] at ht + exact hok t (List.mem_filter.mp ht).1 + obtain ⟨hpnone, hpsome⟩ := pinnedPick_spec (deps := deps) (placed := placed) hokr + simp only [pinnedPlace, pinnedPlaceFast] + cases hpick : pinnedPick deg deps placed remaining with + | none => + have hmin : ready.min? = none := by + rw [Std.TreeSet.min?_eq_none_iff, Std.TreeSet.isEmpty_iff_forall_not_mem] + intro key hkey + obtain ⟨t, ht, hr, _⟩ := (hready key).mp hkey + rw [(hpnone.mp hpick) t ht] at hr + cases hr + rw [hmin] + simp only + congr 1 + apply Array.toList_inj.mp + rw [hrem, Array.toList_filter] + | some m => + obtain ⟨hmrem, hmready, hmle⟩ := hpsome m hpick + have hmok := hokr m hmrem + have hmin : ready.min? = some (pinnedKey deg D B m) := by + rw [Std.TreeSet.min?_eq_some_iff_mem_and_forall] + refine ⟨(hready _).mpr ⟨m, hmrem, hmready, rfl⟩, fun k hk => ?_⟩ + obtain ⟨t, ht, hr, rfl⟩ := (hready k).mp hk + rw [Nat.isLE_compare] + exact hmle t ht hr + rw [hmin] + simp only [pinnedKey_mod hmok] + apply ih + -- the invariant after placing `m` + have hndr : remaining.toList.Nodup := by + rw [hrem]; exact hnd.sublist List.filter_sublist + refine ⟨?_, fun key => ?_⟩ + · rw [toList_erase', hndr.erase_eq_filter, hrem, List.filter_filter] + apply List.filter_congr + intro t _ + rw [Std.HashSet.contains_insert] + by_cases htm : t = m + · subst htm; simp + · have h1 : (m == t) = false := by + simp only [beq_eq_false_iff_ne, ne_eq]; exact fun h => htm h.symm + have h2 : (t != m) = true := by simpa using htm + simp [h1, h2] + · rw [pinnedWake_mem, Std.TreeSet.mem_erase, ne_eq, Nat.compare_eq_eq, hready, toList_erase'] + simp only [hndr.mem_erase_iff] + constructor + · rintro (⟨hne, t, ht, hr, rfl⟩ | ⟨u, hu, hpl, hur, rfl⟩) + · have htm : t ≠ m := fun h => hne (by rw [h]) + exact ⟨t, ⟨htm, ht⟩, pinnedReady_insert hr, rfl⟩ + · obtain ⟨hus, _⟩ := (pinnedUsers_mem deps stored u m).mp hu + rw [Std.HashSet.contains_insert] at hpl + simp only [Bool.or_eq_false_iff, beq_eq_false_iff_ne, ne_eq] at hpl + refine ⟨u, ⟨fun h => hpl.1 h.symm, ?_⟩, hur, rfl⟩ + rw [hrem] + exact List.mem_filter.mpr ⟨hus, by simp [hpl.2]⟩ + · rintro ⟨t, ⟨htm, ht⟩, hr, rfl⟩ + by_cases hr0 : pinnedReady deps placed t = true + · refine Or.inl ⟨fun h => htm (pinnedKey_inj (hokr t ht) hmok h.symm), t, ht, hr0, rfl⟩ + · refine Or.inr ⟨t, ?_, ?_, hr, rfl⟩ + · -- `t` waited for `m` + rw [pinnedUsers_mem] + have htst : t ∈ stored.toList := by + rw [hrem] at ht; exact (List.mem_filter.mp ht).1 + refine ⟨htst, ?_⟩ + unfold pinnedReady at hr hr0 + rw [Array.all_eq_true] at hr + have hr0f : (deps.getD t #[]).all placed.contains = false := by simpa using hr0 + rw [Array.all_eq_false] at hr0f + obtain ⟨i, hi, hni⟩ := hr0f + have := hr i hi + rw [Std.HashSet.contains_insert] at this + simp only [Bool.or_eq_true, beq_iff_eq] at this + rcases this with h | h + · rw [h]; exact Array.getElem_mem_toList hi + · exact absurd h hni + · rw [Std.HashSet.contains_insert] + have hnp : placed.contains t = false := by + rw [hrem] at ht + simpa using (List.mem_filter.mp ht).2 + have h1 : (m == t) = false := by + simp only [beq_eq_false_iff_ne, ne_eq]; exact fun h => htm h.symm + rw [h1, hnp, Bool.or_false] + +theorem pinnedOrder_eq_fast_apply (dag : Dag) (deg : Array Nat) (stored : Array Nat) : + pinnedOrder dag deg stored = pinnedOrderFast dag deg stored := by + unfold pinnedOrderFast + split + · rename_i hinc + unfold pinnedOrder + have hnd := incList_nodup _ hinc + have hok : ∀ t ∈ stored.toList, + KeyOK deg (stored.foldl (fun m t => max m deg[t]!) 0) + (stored.foldl (fun m t => max m (t + 1)) 0) t := by + intro t ht + rw [← Array.foldl_toList, ← Array.foldl_toList] + exact ⟨(foldl_max_ge (· + 1) _ 0).2 t ht, (foldl_max_ge (fun t => deg[t]!) _ 0).2 t ht⟩ + apply pinnedPlace_eq_fast deg _ _ _ stored hnd hok + refine ⟨(List.filter_eq_self.mpr fun _ _ => by simp).symm, fun key => ?_⟩ + rw [pinnedWake_mem] + simp only [Std.TreeSet.not_mem_emptyc, false_or, Std.HashSet.contains_empty, true_and] + · rfl + +@[csimp] theorem pinnedOrder_eq_fast : @pinnedOrder = @pinnedOrderFast := by + funext dag deg stored + exact pinnedOrder_eq_fast_apply dag deg stored + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/Reexpand.lean b/Ix/Sharing/Exact/Reexpand.lean new file mode 100644 index 000000000..a7722a434 --- /dev/null +++ b/Ix/Sharing/Exact/Reexpand.lean @@ -0,0 +1,817 @@ +/- + Exact minimum sharing: re-expansion against a fixed DAG without hashing + whole nodes. + + `reexpand` checks an encoding by expanding it again against a canonical + DAG: it runs the expansion of `expand` (`ingestTable`, in the + `StateT`/`Except` monad) with the interner seeded with every node of the + DAG (`Interner.ofNodes`, a hash map keyed by whole nodes, built per + call). `reexpandFast` makes the same walk, with the same pointer cache, + visit count, limits and errors in the same order, but finds the ID of a + node without hashing it: among the parents of its child with the fewest + parents, or in a map of the leaf heads (`ReIndex.lookup`), and it passes + its state explicitly. A node that is not in the DAG, which the interner + would add, makes `reexpandFast` run `reexpand` instead. + + `reexpand_eq_fast` proves the two equal for every input: `lookup_sound` + (the lookup returns the ID the interner's map holds: the last position of + the node in the DAG) and `reIngestExpr_sim` (each step agrees with + `ingestExpr` until the fast walk stops). +-/ +module + +public import Ix.Sharing.Exact.Phase3 +import all Ix.Sharing.Exact.Basic +import all Ix.Sharing.Exact.Dag +import all Ix.Sharing.Exact.Phase3 + +public section + +namespace Ix.Sharing.Exact + +/-! ## Structural equality of nodes -/ + +theorem isEqv_decide_iff {α : Type} [DecidableEq α] (a b : Array α) : + (a.isEqv b fun x y => decide (x = y)) = true ↔ a = b := by + rw [Array.isEqv_iff_rel, Array.ext_iff] + simp only [decide_eq_true_eq] + constructor + · rintro ⟨h, h'⟩; exact ⟨h, fun i h1 _ => h' i h1⟩ + · rintro ⟨h, h'⟩; exact ⟨h, fun i h1 => h' i h1 (h ▸ h1)⟩ + +theorem binderContract_beq_iff (a b : Ixon.BinderContract) : + Ixon.instBEqBinderContract.beq a b = true ↔ a = b := + (beq_iff_eq : (a == b) = true ↔ a = b) + +theorem valueContract_beq_iff (a b : Ixon.ValueContract) : + Ixon.instBEqValueContract.beq a b = true ↔ a = b := + (beq_iff_eq : (a == b) = true ↔ a = b) + +theorem letContract_beq_iff (a b : Ixon.LetContract) : + Ixon.instBEqLetContract.beq a b = true ↔ a = b := by + cases a; cases b + simp only [Ixon.instBEqLetContract.beq, Bool.and_eq_true, Ixon.LetContract.mk.injEq, beq_iff_eq] + +theorem Head.beq_iff (a b : Head) : (a == b) = true ↔ a = b := by + cases a <;> cases b <;> + simp [BEq.beq, instBEqHead.beq, Head.ctorIdx, isEqv_decide_iff, binderContract_beq_iff, + valueContract_beq_iff, letContract_beq_iff] + +theorem Node.beq_iff (a b : Node) : (a == b) = true ↔ a = b := by + cases a; cases b + have hh : ∀ h h' : Head, instBEqHead.beq h h' = true ↔ h = h' := Head.beq_iff + simp only [BEq.beq, instBEqNode.beq, Bool.and_eq_true, hh, isEqv_decide_iff, Node.mk.injEq] + +instance : LawfulBEq Head where + rfl := (Head.beq_iff _ _).mpr rfl + eq_of_beq h := (Head.beq_iff _ _).mp h + +instance : LawfulBEq Node where + rfl := (Node.beq_iff _ _).mpr rfl + eq_of_beq h := (Node.beq_iff _ _).mp h + +/-! ## The interner's map: the last position of each node -/ + +theorem ofNodes_get? (nodes : Array Node) (k : Node) (u : Nat) : + (Interner.ofNodes nodes).index.get? k = some u ↔ + (u < nodes.size ∧ nodes[u]! = k ∧ ∀ v, u < v → v < nodes.size → nodes[v]! ≠ k) := by + unfold Interner.ofNodes + simp only [Std.HashMap.get?_eq_getElem?] + have := Array.foldl_induction (as := nodes.zipIdx) + (motive := fun j (m : Std.HashMap Node Nat) => ∀ u, m[k]? = some u ↔ + (u < j ∧ nodes[u]! = k ∧ ∀ v, u < v → v < j → nodes[v]! ≠ k)) + (init := {}) (f := fun m (n, i) => m.insert n i) + (by intro u; simp) + (by + intro i m ih u + have hi' : i.1 < nodes.size := by simpa using i.2 + have hz : nodes.zipIdx[i] = (nodes[i.1], i.1) := by simp [Array.getElem_zipIdx] + rw [hz] + dsimp only + rw [Std.HashMap.getElem?_insert] + have hni : nodes[i.1]! = nodes[i.1] := getElem!_pos nodes i.1 hi' + by_cases hk : nodes[i.1] = k + · rw [if_pos ((Node.beq_iff _ _).mpr hk), Option.some.injEq] + constructor + · rintro rfl + exact ⟨by omega, by rw [hni, hk], fun v h1 h2 => by omega⟩ + · rintro ⟨h1, h2, h3⟩ + by_cases hui : u = i.1 + · exact hui.symm + · exact absurd (by rw [hni, hk]) (h3 i.1 (by omega) (by omega)) + · rw [if_neg (fun h => hk ((Node.beq_iff _ _).mp h)), ih u] + constructor + · rintro ⟨h1, h2, h3⟩ + refine ⟨by omega, h2, fun v h4 h5 => ?_⟩ + by_cases hvi : v = i.1 + · subst hvi; rw [hni]; exact hk + · exact h3 v h4 (by omega) + · rintro ⟨h1, h2, h3⟩ + have hui : u ≠ i.1 := fun h => hk (by subst h; rw [← hni]; exact h2) + exact ⟨by omega, h2, fun v h4 h5 => h3 v h4 (by omega)⟩) + simpa [Array.size_zipIdx] using this u + +/-! ## Finding a node without hashing it -/ + +/-- Each leaf head of the DAG (the head of a node without children) to its +last position. -/ +def leafIndex (dag : Dag) : Std.HashMap Head Nat := + dag.nodes.zipIdx.foldl (fun m (n, i) => if n.children.isEmpty then m.insert n.head i else m) {} + +theorem leafIndex_get? (dag : Dag) (h : Head) (u : Nat) : + (leafIndex dag)[h]? = some u ↔ + (u < dag.nodes.size ∧ dag.nodes[u]! = ⟨h, #[]⟩ ∧ + ∀ v, u < v → v < dag.nodes.size → dag.nodes[v]! ≠ ⟨h, #[]⟩) := by + unfold leafIndex + have := Array.foldl_induction (as := dag.nodes.zipIdx) + (motive := fun j (m : Std.HashMap Head Nat) => ∀ u, m[h]? = some u ↔ + (u < j ∧ dag.nodes[u]! = ⟨h, #[]⟩ ∧ ∀ v, u < v → v < j → dag.nodes[v]! ≠ ⟨h, #[]⟩)) + (init := {}) (f := fun m (n, i) => if n.children.isEmpty then m.insert n.head i else m) + (by intro u; simp) + (by + intro i m ih u + have hi' : i.1 < dag.nodes.size := by simpa using i.2 + have hz : dag.nodes.zipIdx[i] = (dag.nodes[i.1], i.1) := by simp [Array.getElem_zipIdx] + rw [hz] + dsimp only + have hni : dag.nodes[i.1]! = dag.nodes[i.1] := getElem!_pos dag.nodes i.1 hi' + by_cases hk : dag.nodes[i.1] = ⟨h, #[]⟩ + · have he : dag.nodes[i.1].children.isEmpty = true := by rw [hk]; rfl + have hh : (dag.nodes[i.1].head == h) = true := by rw [hk]; exact (Head.beq_iff _ _).mpr rfl + rw [if_pos he, Std.HashMap.getElem?_insert, if_pos hh, Option.some.injEq] + constructor + · rintro rfl + exact ⟨by omega, by rw [hni, hk], fun v h1 h2 => by omega⟩ + · rintro ⟨h1, h2, h3⟩ + by_cases hui : u = i.1 + · exact hui.symm + · exact absurd (by rw [hni, hk]) (h3 i.1 (by omega) (by omega)) + · have hstep : (if dag.nodes[i.1].children.isEmpty = true then + m.insert dag.nodes[i.1].head i.1 else m)[h]? = m[h]? := by + split + · rename_i he + rw [Std.HashMap.getElem?_insert, if_neg] + intro hh + apply hk + have h1 := (Head.beq_iff _ _).mp hh + have h2 : dag.nodes[i.1].children = #[] := by + simpa [Array.isEmpty_iff] using he + cases hn : dag.nodes[i.1] + rw [hn] at h1 h2 + simp only at h1 h2 + rw [h1, h2] + · rfl + rw [hstep, ih u] + constructor + · rintro ⟨h1, h2, h3⟩ + refine ⟨by omega, h2, fun v h4 h5 => ?_⟩ + by_cases hvi : v = i.1 + · subst hvi; rw [hni]; exact hk + · exact h3 v h4 (by omega) + · rintro ⟨h1, h2, h3⟩ + have hui : u ≠ i.1 := fun h' => hk (by subst h'; rw [← hni]; exact h2) + exact ⟨by omega, h2, fun v h4 h5 => h3 v h4 (by omega)⟩) + simpa [Array.size_zipIdx] using this u + +/-- The largest `u` of `ps` below `dag.size` whose node is `n`. -/ +def lastMatch (dag : Dag) (n : Node) (ps : Array Nat) : Option Nat := + ps.foldl (fun acc u => + if u < dag.size && dag.node u == n then + some (match acc with + | some v => max v u + | none => u) + else acc) none + +theorem lastMatch_spec (dag : Dag) (n : Node) (ps : Array Nat) (u : Nat) + (h : lastMatch dag n ps = some u) : + u ∈ ps ∧ u < dag.size ∧ dag.node u = n ∧ + ∀ v ∈ ps, v < dag.size → dag.node v = n → v ≤ u := by + unfold lastMatch at h + rw [← Array.foldl_toList] at h + suffices hs : ∀ (l : List Nat) (acc : Option Nat) (u : Nat), + l.foldl (fun acc u => + if u < dag.size && dag.node u == n then + some (match acc with + | some v => max v u + | none => u) + else acc) acc = some u → + ((acc = some u) ∨ (u ∈ l ∧ u < dag.size ∧ dag.node u = n)) ∧ + (∀ a, acc = some a → a ≤ u) ∧ (∀ v ∈ l, v < dag.size → dag.node v = n → v ≤ u) by + obtain ⟨h1, _, h3⟩ := hs ps.toList none u h + rcases h1 with h1 | ⟨h1, h2, h4⟩ + · cases h1 + · exact ⟨Array.mem_toList_iff.mp h1, h2, h4, fun v hv => h3 v (Array.mem_toList_iff.mpr hv)⟩ + intro l + induction l with + | nil => + intro acc u h + simp only [List.foldl_nil] at h + exact ⟨Or.inl h, fun a ha => by rw [h] at ha; cases ha; exact Nat.le_refl _, by simp⟩ + | cons w l ih => + intro acc u h + simp only [List.foldl_cons] at h + obtain ⟨h1, h2, h3⟩ := ih _ u h + by_cases hw : (w < dag.size && dag.node w == n) = true + · rw [if_pos hw] at h1 h2 + simp only [Bool.and_eq_true, decide_eq_true_eq, beq_iff_eq] at hw + have hacc : ∀ a, acc = some a → a ≤ u := by + intro a ha + subst ha + have := h2 _ rfl + simp only at this + omega + have hwu : w ≤ u := by + have := h2 _ rfl + cases acc <;> simp only at this <;> omega + refine ⟨?_, hacc, ?_⟩ + · rcases h1 with h1 | h1 + · cases acc with + | none => + simp only [Option.some.injEq] at h1 + exact Or.inr ⟨by simp [h1], h1 ▸ hw.1, h1 ▸ hw.2⟩ + | some a => + simp only [Option.some.injEq] at h1 + by_cases hav : a ≤ w + · rw [Nat.max_eq_right hav] at h1 + exact Or.inr ⟨by simp [h1], h1 ▸ hw.1, h1 ▸ hw.2⟩ + · rw [Nat.max_eq_left (by omega)] at h1 + exact Or.inl (by rw [h1]) + · exact Or.inr ⟨List.mem_cons_of_mem _ h1.1, h1.2⟩ + · intro v hv hv1 hv2 + simp only [List.mem_cons] at hv + rcases hv with rfl | hv + · exact hwu + · exact h3 v hv hv1 hv2 + · rw [if_neg hw] at h1 h2 + refine ⟨?_, h2, ?_⟩ + · rcases h1 with h1 | h1 + · exact Or.inl h1 + · exact Or.inr ⟨List.mem_cons_of_mem _ h1.1, h1.2⟩ + · intro v hv hv1 hv2 + simp only [List.mem_cons] at hv + rcases hv with rfl | hv + · exact absurd (by simp [hv1, hv2]) hw + · exact h3 v hv hv1 hv2 + +/-- The child in `cs` with the fewest parents (the first of `cs` on a tie). -/ +def fewestParents (parents : Array (Array Nat)) (cs : Array Nat) : Nat := + cs.foldl (fun best c => + if (parents[c]?.getD #[]).size < (parents[best]?.getD #[]).size then c else best) cs[0]! + +theorem fewestParents_mem (parents : Array (Array Nat)) (cs : Array Nat) (h : 0 < cs.size) : + fewestParents parents cs ∈ cs := by + unfold fewestParents + rw [← Array.foldl_toList] + have h0 : cs[0]! ∈ cs.toList := by + rw [getElem!_pos cs 0 h] + exact Array.mem_toList_iff.mpr (Array.getElem_mem h) + suffices hs : ∀ (l : List Nat) (b : Nat), b ∈ cs.toList → (∀ c ∈ l, c ∈ cs.toList) → + l.foldl (fun best c => + if (parents[c]?.getD #[]).size < (parents[best]?.getD #[]).size then c else best) b ∈ + cs.toList by + exact Array.mem_toList_iff.mp (hs cs.toList _ h0 (fun c hc => hc)) + intro l + induction l with + | nil => intro b hb _; exact hb + | cons c l ih => + intro b hb hl + simp only [List.foldl_cons] + apply ih _ _ (fun c' hc' => hl c' (List.mem_cons_of_mem _ hc')) + split + · exact hl c (List.mem_cons_self ..) + · exact hb + +/-- The tables `ReIndex.lookup` finds nodes with. -/ +structure ReIndex where + parents : Array (Array Nat) + leaves : Std.HashMap Head Nat + +/-- The parent lists and leaf heads of a DAG. -/ +def ReIndex.ofDag (dag : Dag) : ReIndex := + { parents := parentEdgeLists dag, leaves := leafIndex dag } + +/-- The ID of `n` in the DAG, if it occurs there (its last position): a leaf +by its head, any other node among the parents of its child with the fewest +parents. -/ +def ReIndex.lookup (ix : ReIndex) (dag : Dag) (n : Node) : Option Nat := + if n.children.isEmpty then ix.leaves[n.head]? + else + let c := fewestParents ix.parents n.children + if c < dag.size then lastMatch dag n (ix.parents[c]?.getD #[]) else none + +theorem dag_node_eq_getElem! (dag : Dag) (u : Nat) (hu : u < dag.size) : + dag.node u = dag.nodes[u]! := by + unfold Dag.node + rw [getElem!_pos dag.nodes u hu, Array.getElem?_eq_getElem hu] + rfl + +/-- **Lookup soundness.** A node `lookup` finds has the ID the interner's map +holds for it. -/ +theorem lookup_sound (dag : Dag) (n : Node) (u : Nat) + (h : (ReIndex.ofDag dag).lookup dag n = some u) : + (Interner.ofNodes dag.nodes).index.get? n = some u := by + rw [ofNodes_get?] + unfold ReIndex.lookup ReIndex.ofDag at h + split at h + · rename_i he + have hn : n = ⟨n.head, #[]⟩ := by + cases n + simp only at he ⊢ + rw [Node.mk.injEq] + exact ⟨rfl, by simpa [Array.isEmpty_iff] using he⟩ + rw [hn] + exact (leafIndex_get? dag n.head u).mp h + · rename_i he + simp only at h + split at h + · rename_i hc + obtain ⟨hu, hus, hun, hmax⟩ := lastMatch_spec dag n _ u h + have hcs : 0 < n.children.size := by + cases hcs : n.children.size + · exfalso; apply he; simpa [Array.isEmpty_iff, Array.size_eq_zero_iff] using hcs + · omega + have hcm := fewestParents_mem (parentEdgeLists dag) n.children hcs + refine ⟨hus, by rw [← dag_node_eq_getElem! dag u hus, hun], fun v h1 h2 h3 => ?_⟩ + have hv : dag.node v = n := by rw [dag_node_eq_getElem! dag v h2, h3] + have hok := parentEdgeLists_ok dag + unfold ParentsOK at hok + have hp := (hok _ hc v).mpr ⟨h2, by rw [hv]; exact hcm⟩ + have := hmax v hp h2 hv + omega + · cases h + +/-! ## The re-expansion walk with explicit state -/ + +/-- A step of the fast re-expansion: a value with the pointer cache and the +visit count, an error, or `stop` (a node is not in the DAG). -/ +inductive ReStep (α : Type) where + | ok (a : α) (cache : Std.HashMap USize Nat) (visits : Nat) + | error (e : SharingError) + | stop + +/-- `internNode` against the DAG's own interner. -/ +@[inline] def reIntern (limits : Limits) (dag : Dag) (ix : ReIndex) (n : Node) + (cache : Std.HashMap USize Nat) (visits : Nat) : ReStep Nat := + match ix.lookup dag n with + | some id => + if dag.nodes.size > limits.maxNodes then .error (.resourceExhausted .nodes limits.maxNodes) + else .ok id cache visits + | none => .stop + +/-- Continue an ok step with `k`. -/ +@[inline] def ReStep.bind {α β : Type} (r : ReStep α) + (k : α → Std.HashMap USize Nat → Nat → ReStep β) : ReStep β := + match r with + | .ok a cache visits => k a cache visits + | .error err => .error err + | .stop => .stop + +/-- Record the ID of the expression at `ptr` in the pointer cache. -/ +@[inline] def reFinish (ptr : USize) (r : ReStep Nat) : ReStep Nat := + r.bind fun id cache visits => .ok id (cache.insert ptr id) visits + +/-- `ingestExpr` against the DAG's own interner. -/ +def reIngestExpr (limits : Limits) (dag : Dag) (ix : ReIndex) (ctx : ShareCtx) (depth : Nat) + (e : Ixon.Expr) (cache : Std.HashMap USize Nat) (visits : Nat) : ReStep Nat := + match cache.get? (exprPtr e) with + | some id => .ok id cache visits + | none => + if depth > limits.maxDepth then .error (.resourceExhausted .depth limits.maxDepth) else + match bump visits 1 limits.maxExprVisits .exprVisits with + | .error err => .error err + | .ok visits => reFinish (exprPtr e) <| match e with + | .sort i => reIntern limits dag ix ⟨.sort i, #[]⟩ cache visits + | .var i => reIntern limits dag ix ⟨.var i, #[]⟩ cache visits + | .ref r us => reIntern limits dag ix ⟨.ref r us, #[]⟩ cache visits + | .recur r us => reIntern limits dag ix ⟨.recur r us, #[]⟩ cache visits + | .prj t f v => + (reIngestExpr limits dag ix ctx (depth + 1) v cache visits).bind fun vi cache visits => + reIntern limits dag ix ⟨.prj t f, #[vi]⟩ cache visits + | .str i => reIntern limits dag ix ⟨.str i, #[]⟩ cache visits + | .nat i => reIntern limits dag ix ⟨.nat i, #[]⟩ cache visits + | .app f a => + (reIngestExpr limits dag ix ctx (depth + 1) f cache visits).bind fun fi cache visits => + (reIngestExpr limits dag ix ctx (depth + 1) a cache visits).bind fun ai cache visits => + reIntern limits dag ix ⟨.app, #[fi, ai]⟩ cache visits + | .lam c ty body => + (reIngestExpr limits dag ix ctx (depth + 1) ty cache visits).bind fun ti cache visits => + (reIngestExpr limits dag ix ctx (depth + 1) body cache visits).bind fun bi cache visits => + reIntern limits dag ix ⟨.lam c, #[ti, bi]⟩ cache visits + | .all c r ty body => + (reIngestExpr limits dag ix ctx (depth + 1) ty cache visits).bind fun ti cache visits => + (reIngestExpr limits dag ix ctx (depth + 1) body cache visits).bind fun bi cache visits => + reIntern limits dag ix ⟨.all c r, #[ti, bi]⟩ cache visits + | .letE c ty v body => + (reIngestExpr limits dag ix ctx (depth + 1) ty cache visits).bind fun ti cache visits => + (reIngestExpr limits dag ix ctx (depth + 1) v cache visits).bind fun vi cache visits => + (reIngestExpr limits dag ix ctx (depth + 1) body cache visits).bind fun bi cache visits => + reIntern limits dag ix ⟨.letE c, #[ti, vi, bi]⟩ cache visits + | .share j => + match resolveShare ctx j with + | .ok id => .ok id cache visits + | .error err => .error err + +/-! ## Agreement with `ingestExpr` -/ + +/-- A fast step agrees with a run of the expansion monad from the DAG's +interner, unless it stopped. -/ +def ReSim {α : Type} (I0 : Interner) : ReStep α → Except SharingError (α × IngestState) → Prop + | .ok a cache visits, r => r = .ok (a, { interner := I0, ptrCache := cache, visits }) + | .error e, r => r = .error e + | .stop, _ => True + +theorem reIntern_sim (limits : Limits) (dag : Dag) (n : Node) (cache : Std.HashMap USize Nat) + (visits : Nat) : + ReSim (Interner.ofNodes dag.nodes) (reIntern limits dag (ReIndex.ofDag dag) n cache visits) + ((internNode limits n).run + { interner := Interner.ofNodes dag.nodes, ptrCache := cache, visits }) := by + unfold reIntern + split + · rename_i id hl + have hg := lookup_sound dag n id hl + have hint : (Interner.ofNodes dag.nodes).intern n = (Interner.ofNodes dag.nodes, id) := by + unfold Interner.intern + rw [hg] + unfold internNode + have hn : (Interner.ofNodes dag.nodes).nodes = dag.nodes := rfl + by_cases hm : limits.maxNodes < dag.nodes.size + · simp [hint, hn, hm, ReSim] + rfl + · simp [hint, hn, hm, ReSim] + rfl + · trivial + +theorem ReSim.bind {α β : Type} {I0 : Interner} {r : ReStep α} + {m : Except SharingError (α × IngestState)} + {k : α → Std.HashMap USize Nat → Nat → ReStep β} + {m' : α → IngestState → Except SharingError (β × IngestState)} + (h : ReSim I0 r m) + (hk : ∀ a c v, ReSim I0 (k a c v) (m' a { interner := I0, ptrCache := c, visits := v })) : + ReSim I0 (r.bind k) (m >>= fun p => m' p.1 p.2) := by + cases r with + | ok a c v => + simp only [ReSim] at h + subst h + exact hk a c v + | error e => + simp only [ReSim] at h + subst h + simp only [ReStep.bind, ReSim] + rfl + | stop => trivial + +theorem reFinish_sim {I0 : Interner} (ptr : USize) {r : ReStep Nat} + {m : Except SharingError (Nat × IngestState)} (h : ReSim I0 r m) : + ReSim I0 (reFinish ptr r) + ((fun a => (a.1, + { interner := a.2.interner, ptrCache := a.2.ptrCache.insert ptr a.1, + visits := a.2.visits })) <$> m) := by + cases r with + | ok a c v => + simp only [ReSim] at h + subst h + simp only [reFinish, ReStep.bind, ReSim] + rfl + | error e => + simp only [ReSim] at h + subst h + simp only [reFinish, ReStep.bind, ReSim] + rfl + | stop => trivial + +/-- The part of `ingestExpr` and `reIngestExpr` around the node itself: the +pointer cache, the depth limit, the visit count, and recording the ID. -/ +theorem sim_prefix (limits : Limits) (dag : Dag) (depth : Nat) (e : Ixon.Expr) + (cache : Std.HashMap USize Nat) (visits : Nat) (fb : Nat → ReStep Nat) (mb : IngestM Nat) + (hb : ∀ v, ReSim (Interner.ofNodes dag.nodes) (fb v) + (mb.run { interner := Interner.ofNodes dag.nodes, ptrCache := cache, visits := v })) : + ReSim (Interner.ofNodes dag.nodes) + (match cache.get? (exprPtr e) with + | some id => .ok id cache visits + | none => + if depth > limits.maxDepth then .error (.resourceExhausted .depth limits.maxDepth) else + match bump visits 1 limits.maxExprVisits .exprVisits with + | .error err => .error err + | .ok visits => reFinish (exprPtr e) (fb visits)) + ((do + let ptr := exprPtr e + match (← get).ptrCache.get? ptr with + | some id => return id + | none => + if depth > limits.maxDepth then + throw (.resourceExhausted .depth limits.maxDepth) + let s ← get + let visits ← liftExcept (bump s.visits 1 limits.maxExprVisits .exprVisits) + set { s with visits } + let id ← mb + modify fun s => { s with ptrCache := s.ptrCache.insert ptr id } + return id : IngestM Nat).run + { interner := Interner.ofNodes dag.nodes, ptrCache := cache, visits }) := by + simp only [StateT.run_bind, StateT.run_get, pure_bind] + cases hc : cache.get? (exprPtr e) with + | some id => simp only [ReSim]; rfl + | none => + by_cases hd : depth > limits.maxDepth + · simp only [hd, if_true, ReSim]; rfl + · simp only [hd, if_false] + cases hbv : bump visits 1 limits.maxExprVisits .exprVisits with + | error err => simp [hbv, liftExcept, ReSim]; rfl + | ok v => + simp [hbv, liftExcept] + exact reFinish_sim _ (hb v) + +theorem share_sim (I0 : Interner) (ctx : ShareCtx) (j : UInt64) (cache : Std.HashMap USize Nat) + (visits : Nat) : + ReSim I0 (match resolveShare ctx j with + | .ok id => .ok id cache visits + | .error err => .error err) + ((liftExcept (resolveShare ctx j)).run { interner := I0, ptrCache := cache, visits }) := by + cases resolveShare ctx j with + | ok id => simp only [liftExcept, ReSim]; rfl + | error err => simp only [liftExcept, ReSim]; rfl + +theorem ReSim.bind' {α β : Type} {I0 : Interner} {r : ReStep α} + {m : Except SharingError (α × IngestState)} + {k : α → Std.HashMap USize Nat → Nat → ReStep β} + {m' : α × IngestState → Except SharingError (β × IngestState)} + (h : ReSim I0 r m) + (hk : ∀ a c v, ReSim I0 (k a c v) (m' (a, { interner := I0, ptrCache := c, visits := v }))) : + ReSim I0 (r.bind k) (m >>= m') := by + cases r with + | ok a c v => + simp only [ReSim] at h + subst h + exact hk a c v + | error e => + simp only [ReSim] at h + subst h + simp only [ReStep.bind, ReSim] + rfl + | stop => trivial + +theorem reFinish_bind {α : Type} {I0 : Interner} (ptr : USize) {r : ReStep α} + {m : Except SharingError (α × IngestState)} + {k : α → Std.HashMap USize Nat → Nat → ReStep Nat} + {m' : α × IngestState → Except SharingError (Nat × IngestState)} + (h : ReSim I0 r m) + (hk : ∀ a c v, ReSim I0 (reFinish ptr (k a c v)) + (m' (a, { interner := I0, ptrCache := c, visits := v }))) : + ReSim I0 (reFinish ptr (r.bind k)) (m >>= m') := by + have : reFinish ptr (r.bind k) = r.bind (fun a c v => reFinish ptr (k a c v)) := by + cases r <;> rfl + rw [this] + exact ReSim.bind' h hk + +theorem reIngestExpr_sim (limits : Limits) (dag : Dag) (ctx : ShareCtx) : + ∀ (e : Ixon.Expr) (depth : Nat) (cache : Std.HashMap USize Nat) (visits : Nat), + ReSim (Interner.ofNodes dag.nodes) + (reIngestExpr limits dag (ReIndex.ofDag dag) ctx depth e cache visits) + ((ingestExpr limits ctx depth e).run + { interner := Interner.ofNodes dag.nodes, ptrCache := cache, visits }) := by + intro e + induction e with + | sort i | var i | ref i us | recur i us | str i | nat i => + intro depth cache visits + unfold reIngestExpr ingestExpr + refine sim_prefix limits dag depth _ cache visits _ _ ?_ + intro v + exact reIntern_sim limits dag _ cache v + | prj t f v ih => + intro depth cache visits + rw [reIngestExpr, ingestExpr] + dsimp only + simp only [StateT.run_bind, StateT.run_get, pure_bind] + cases hc : cache.get? (exprPtr (Ixon.Expr.prj t f v)) with + | some id => simp only [ReSim]; rfl + | none => + by_cases hd : depth > limits.maxDepth + · simp only [hd, if_true, ReSim]; rfl + · simp only [hd, if_false] + cases hbv : bump visits 1 limits.maxExprVisits .exprVisits with + | error err => simp [hbv, liftExcept, ReSim]; rfl + | ok w => + simp [hbv, liftExcept] + exact reFinish_bind _ (ih (depth + 1) cache w) + (fun a c v' => reFinish_sim _ (reIntern_sim limits dag _ c v')) + | app f a ihf iha => + intro depth cache visits + rw [reIngestExpr, ingestExpr] + dsimp only + simp only [StateT.run_bind, StateT.run_get, pure_bind] + cases hc : cache.get? (exprPtr (Ixon.Expr.app f a)) with + | some id => simp only [ReSim]; rfl + | none => + by_cases hd : depth > limits.maxDepth + · simp only [hd, if_true, ReSim]; rfl + · simp only [hd, if_false] + cases hbv : bump visits 1 limits.maxExprVisits .exprVisits with + | error err => simp [hbv, liftExcept, ReSim]; rfl + | ok w => + simp [hbv, liftExcept] + exact reFinish_bind _ (ihf (depth + 1) cache w) (fun fi c v' => + reFinish_bind _ (iha (depth + 1) c v') + (fun ai c' v'' => reFinish_sim _ (reIntern_sim limits dag _ c' v''))) + | lam bc ty body iht ihb => + intro depth cache visits + rw [reIngestExpr, ingestExpr] + dsimp only + simp only [StateT.run_bind, StateT.run_get, pure_bind] + cases hc : cache.get? (exprPtr (Ixon.Expr.lam bc ty body)) with + | some id => simp only [ReSim]; rfl + | none => + by_cases hd : depth > limits.maxDepth + · simp only [hd, if_true, ReSim]; rfl + · simp only [hd, if_false] + cases hbv : bump visits 1 limits.maxExprVisits .exprVisits with + | error err => simp [hbv, liftExcept, ReSim]; rfl + | ok w => + simp [hbv, liftExcept] + exact reFinish_bind _ (iht (depth + 1) cache w) (fun ti c v' => + reFinish_bind _ (ihb (depth + 1) c v') + (fun bi c' v'' => reFinish_sim _ (reIntern_sim limits dag _ c' v''))) + | all bc r ty body iht ihb => + intro depth cache visits + rw [reIngestExpr, ingestExpr] + dsimp only + simp only [StateT.run_bind, StateT.run_get, pure_bind] + cases hc : cache.get? (exprPtr (Ixon.Expr.all bc r ty body)) with + | some id => simp only [ReSim]; rfl + | none => + by_cases hd : depth > limits.maxDepth + · simp only [hd, if_true, ReSim]; rfl + · simp only [hd, if_false] + cases hbv : bump visits 1 limits.maxExprVisits .exprVisits with + | error err => simp [hbv, liftExcept, ReSim]; rfl + | ok w => + simp [hbv, liftExcept] + exact reFinish_bind _ (iht (depth + 1) cache w) (fun ti c v' => + reFinish_bind _ (ihb (depth + 1) c v') + (fun bi c' v'' => reFinish_sim _ (reIntern_sim limits dag _ c' v''))) + | letE lc ty v body iht ihv ihb => + intro depth cache visits + rw [reIngestExpr, ingestExpr] + dsimp only + simp only [StateT.run_bind, StateT.run_get, pure_bind] + cases hc : cache.get? (exprPtr (Ixon.Expr.letE lc ty v body)) with + | some id => simp only [ReSim]; rfl + | none => + by_cases hd : depth > limits.maxDepth + · simp only [hd, if_true, ReSim]; rfl + · simp only [hd, if_false] + cases hbv : bump visits 1 limits.maxExprVisits .exprVisits with + | error err => simp [hbv, liftExcept, ReSim]; rfl + | ok w => + simp [hbv, liftExcept] + exact reFinish_bind _ (iht (depth + 1) cache w) (fun ti c v' => + reFinish_bind _ (ihv (depth + 1) c v') (fun vi c' v'' => + reFinish_bind _ (ihb (depth + 1) c' v'') + (fun bi c'' v''' => reFinish_sim _ (reIntern_sim limits dag _ c'' v''')))) + | share j => + intro depth cache visits + unfold reIngestExpr ingestExpr + refine sim_prefix limits dag depth _ cache visits _ _ ?_ + intro v + exact share_sim _ ctx j cache v + +/-! ## The table and the roots -/ + +/-- The entries `i, …, i + k - 1` of `ingestTable` (`allowShare`). -/ +def reIngestEntries (limits : Limits) (dag : Dag) (ix : ReIndex) (sharing : Array Ixon.Expr) : + Nat → Nat → Array Nat → Std.HashMap USize Nat → Nat → ReStep (Array Nat) + | 0, _, resolved, cache, visits => .ok resolved cache visits + | k + 1, i, resolved, cache, visits => + let ctx : ShareCtx := + { resolved, tableSize := sharing.size, entry := some i, root := 0, allowShare := true } + (reIngestExpr limits dag ix ctx 0 sharing[i]! cache visits).bind fun id cache visits => + reIngestEntries limits dag ix sharing k (i + 1) (resolved.push id) cache visits + +/-- The roots `r, …, r + k - 1` of `ingestTable` (`allowShare`). -/ +def reIngestRoots (limits : Limits) (dag : Dag) (ix : ReIndex) (tableSize : Nat) + (resolved : Array Nat) (roots : Array Ixon.Expr) : + Nat → Nat → Array Nat → Std.HashMap USize Nat → Nat → ReStep (Array Nat) + | 0, _, out, cache, visits => .ok out cache visits + | k + 1, r, out, cache, visits => + let ctx : ShareCtx := { resolved, tableSize, entry := none, root := r, allowShare := true } + (reIngestExpr limits dag ix ctx 0 roots[r]! cache visits).bind fun id cache visits => + reIngestRoots limits dag ix tableSize resolved roots k (r + 1) (out.push id) cache visits + +/-- A loop of `ingestTable` over the positions `i, …, i + k - 1` of `xs`, +each expanded in the context `ctxOf a acc` and pushed onto the accumulator. -/ +theorem loop_sim (limits : Limits) (dag : Dag) (xs : Array Ixon.Expr) + (ctxOf : Nat → Array Nat → ShareCtx) + (fast : Nat → Nat → Array Nat → Std.HashMap USize Nat → Nat → ReStep (Array Nat)) + (hfast0 : ∀ i acc cache visits, fast 0 i acc cache visits = .ok acc cache visits) + (hfast : ∀ k i acc cache visits, fast (k + 1) i acc cache visits = + (reIngestExpr limits dag (ReIndex.ofDag dag) (ctxOf i acc) 0 xs[i]! cache visits).bind + fun id cache visits => fast k (i + 1) (acc.push id) cache visits) : + ∀ (k i : Nat) (acc : Array Nat) (cache : Std.HashMap USize Nat) (visits : Nat) + (l : List Nat) (_ : l = List.range' i k) + (f : (a : Nat) → a ∈ l → Array Nat → IngestM (ForInStep (Array Nat))), + (∀ a h acc, f a h acc = (ingestExpr limits (ctxOf a acc) 0 xs[a]! >>= fun id => + pure (ForInStep.yield (acc.push id)))) → + ReSim (Interner.ofNodes dag.nodes) (fast k i acc cache visits) + ((forIn' l acc f).run + { interner := Interner.ofNodes dag.nodes, ptrCache := cache, visits }) + | 0, i, acc, cache, visits, l, hl, f, _ => by + rw [hfast0] + simp only [List.range'_zero] at hl + subst hl + simp only [List.forIn'_nil, ReSim] + rfl + | k + 1, i, acc, cache, visits, l, hl, f, hf => by + rw [List.range'_succ] at hl + subst hl + rw [hfast, List.forIn'_cons, hf, bind_assoc, StateT.run_bind] + simp only [pure_bind] + refine ReSim.bind' (reIngestExpr_sim limits dag (ctxOf i acc) xs[i]! 0 cache visits) ?_ + intro id c v + exact loop_sim limits dag xs ctxOf fast hfast0 hfast k (i + 1) (acc.push id) c v _ rfl _ + (fun a h acc => hf a _ acc) + +/-- `ingestTable` (`allowShare`) against the DAG's own interner. -/ +def reIngestTable (limits : Limits) (dag : Dag) (ix : ReIndex) (sharing roots : Array Ixon.Expr) : + ReStep (Array Nat × Array Nat) := + (reIngestEntries limits dag ix sharing sharing.size 0 #[] {} 0).bind fun resolved cache visits => + (reIngestRoots limits dag ix sharing.size resolved roots roots.size 0 #[] cache visits).bind + fun out cache visits => .ok (resolved, out) cache visits + +theorem ingestTable_sim (limits : Limits) (dag : Dag) (sharing roots : Array Ixon.Expr) + (hw : ¬sharing.size ≥ wordBound) : + ReSim (Interner.ofNodes dag.nodes) (reIngestTable limits dag (ReIndex.ofDag dag) sharing roots) + ((ingestTable limits sharing roots true).run + { interner := Interner.ofNodes dag.nodes, ptrCache := {}, visits := 0 }) := by + unfold ingestTable reIngestTable + simp only [hw, if_false, Std.Legacy.Range.forIn'_eq_forIn'_range', StateT.run_bind] + refine ReSim.bind' (loop_sim limits dag sharing + (fun i acc => { resolved := acc, tableSize := sharing.size, entry := some i, root := 0, + allowShare := true }) + (reIngestEntries limits dag (ReIndex.ofDag dag) sharing) (fun _ _ _ _ => rfl) + (fun _ _ _ _ _ => rfl) sharing.size 0 #[] {} 0 _ ?_ _ ?_) ?_ + · simp [Std.Legacy.Range.size] + · intro a h acc + have ha : a < sharing.size := by + have := List.mem_range'.mp h + simp [Std.Legacy.Range.size] at this + omega + rw [getElem!_pos sharing a ha] + · intro resolved c v + refine ReSim.bind' (loop_sim limits dag roots + (fun r acc => { resolved, tableSize := sharing.size, entry := none, root := r, + allowShare := true }) + (reIngestRoots limits dag (ReIndex.ofDag dag) sharing.size resolved roots) + (fun _ _ _ _ => rfl) (fun _ _ _ _ _ => rfl) roots.size 0 #[] c v _ ?_ _ ?_) ?_ + · simp [Std.Legacy.Range.size] + · intro a h acc + have ha : a < roots.size := by + have := List.mem_range'.mp h + simp [Std.Legacy.Range.size] at this + omega + rw [getElem!_pos roots a ha] + · intro out c' v' + simp only [ReSim] + rfl + +/-! ## The fast re-expansion -/ + +/-- `reexpand` with the DAG's nodes found by `ReIndex.lookup` and the state +passed explicitly (`reexpand_eq_fast`); when a node is not in the DAG it +runs `reexpand`. The construction re-expands only its own output, whose +nodes are all in the DAG, so there that fallback is defensive; a direct +caller with an encoding of other terms takes it. -/ +def reexpandFast (limits : Limits) (dag : Dag) (sharing roots : Array Ixon.Expr) : + Except SharingError (Array Nat × Array Nat × Nat) := + if sharing.size ≥ wordBound then .error (.formatBound "sharing table size" sharing.size) else + match reIngestTable limits dag (ReIndex.ofDag dag) sharing roots with + | .ok (resolved, out) _ visits => .ok (resolved, out, visits) + | .error e => .error e + | .stop => reexpand limits dag sharing roots + +@[csimp] theorem reexpand_eq_fast : @reexpand = @reexpandFast := by + funext limits dag sharing roots + unfold reexpandFast + by_cases hw : sharing.size ≥ wordBound + · simp only [hw, if_true] + unfold reexpand ingestTable + simp only [hw, if_true] + rfl + · simp only [hw, if_false] + have hs := ingestTable_sim limits dag sharing roots hw + cases hr : reIngestTable limits dag (ReIndex.ofDag dag) sharing roots with + | ok p cache visits => + rw [hr] at hs + simp only [ReSim] at hs + obtain ⟨resolved, out⟩ := p + unfold reexpand + simp only [hs] + rfl + | error e => + rw [hr] at hs + simp only [ReSim] at hs + unfold reexpand + simp only [hs] + rfl + | stop => rfl + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/Search.lean b/Ix/Sharing/Exact/Search.lean new file mode 100644 index 000000000..3c39ba80c --- /dev/null +++ b/Ix/Sharing/Exact/Search.lean @@ -0,0 +1,536 @@ +/- + Exact minimum sharing: table selection and ordering (§4.1, §6). + + The width-state search below computes the global minimum of + `docs/sharing-minimum.md` §3. It is exponential in the candidates and is a + test oracle for small inputs, not the compiler path. The table + materialization (`materializeTable`) and `ExactSharingResult` are shared + with the canonical construction (`Exact.Uniform`, `Exact.Tiered`). + + Candidates. By R1 a term with a single logical occurrence is never stored, + and by R2 neither is a term whose inline encoding is one byte. The search + therefore appends only terms with `occ ≥ 2` and unshared length `≥ 2`. + + Width states (§6.1, §6.4). A state is the sorted vector of + `(term ID, Share width)` pairs of the stored terms; `k` stored terms fix the + next index `k` and its width. `F(M)` is the least accumulated table-body + length of any history reaching `M`; among equal `F`, the least term-ID + prefix is retained (§6.2). Layers are processed in increasing `k`, states + within a layer in increasing key order, so work counters are + deterministic. Appending `t` to `M` costs `C_M(t)` (the entry may use only + the earlier entries). Stopping at `M` costs + `F(M) + tag0Size k + Σ C_M(root)` variable bytes; the fixed Constant bytes + are the same for every candidate and do not affect the argmin. + + Pruning (§4.1 LB). With `M⁺` granting every absent candidate a width-1 + reference, `F(M) + tag0Size k + Σ C_{M⁺}(root)` bounds every completion of + `M` from below. A state or transition is pruned only when its bound is + strictly greater than a length already achieved by a feasible encoding, so + equal-length states are always kept. For `k ≤ 8` every stored term has + width 1, so `M⁺` is the same for all such states and its root costs are + computed once. + + The selected table is materialized with the byte-least tie-break, and the + output is re-expanded and re-measured; any disagreement is an internal + error rather than a result. +-/ +module + +public import Ix.Sharing.Exact.Dictionary +public import Ix.Sharing.Exact.Phase3 +public import Ix.Sharing.Exact.Reexpand + +public section + +namespace Ix.Sharing.Exact + +open Ixon + +/-! ## Candidates and affected terms -/ + +/-- Candidate terms after R1 (`occ ≥ 2`) and R2 (unshared length `≥ 2`), in +increasing ID order. -/ +def candidateTerms (p : Prep) (occ : Array Nat) : Array Nat := + (Array.range p.dag.size).filter fun t => occ[t]! ≥ 2 && p.base[t]! ≥ 2 + +/-- Terms whose cost can depend on the dictionary: candidates and every term +with a candidate below it. Other terms always cost `C_∅`. -/ +def affectedTerms (dag : Dag) (isCand : Array Bool) : Array Bool := Id.run do + let mut aff : Array Bool := Array.replicate dag.size false + for t in [0:dag.size] do + let below := (dag.node t).children.any (aff[·]!) + aff := aff.set! t (isCand[t]! || below) + return aff + +/-- Sum of root costs, with multiplicity. -/ +def rootsCost (cost : Array Nat) (roots : Array Nat) : Nat := + roots.foldl (fun acc r => acc + cost[r]!) 0 + +/-! ## Width states -/ + +/-- Stored terms with their Share widths, sorted by term ID. -/ +abbrev StateKey := Array (Nat × Nat) + +/-- Insert `(t, w)` keeping the key sorted by term ID. -/ +def StateKey.insertSorted (key : StateKey) (t w : Nat) : StateKey := + let (lo, hi) := key.toList.span fun (u, _) => u < t + (lo ++ (t, w) :: hi).toArray + +/-- Total order on state keys (term, then width, lexicographically). -/ +def StateKey.compare (a b : StateKey) : Ordering := + lexCompare (a.toList.flatMap fun (t, w) => [t, w]) (b.toList.flatMap fun (t, w) => [t, w]) + +/-- Dictionary widths of a state. -/ +def StateKey.widths (n : Nat) (key : StateKey) : Array (Option Nat) := + key.foldl (fun acc (t, w) => acc.set! t (some w)) (Array.replicate n none) + +/-- `M⁺`: every candidate gets width 1, stored terms keep their widths. -/ +def optimisticWidths (n : Nat) (cands : Array Nat) (key : StateKey) : Array (Option Nat) := + let w := cands.foldl (fun acc t => acc.set! t (some 1)) (Array.replicate n none) + key.foldl (fun acc (t, wt) => acc.set! t (some wt)) w + +/-- `(cost, prefix)` strictly better, comparing cost then prefix. -/ +def lexLess (c : Nat) (pre : Array Nat) (c' : Nat) (pre' : Array Nat) : Bool := + c < c' || (c == c' && compareNatArray pre pre' == .lt) + +/-! ## Search -/ + +/-- Inputs of one exact search. -/ +structure SearchInput where + prep : Prep + roots : Array Nat + candidates : Array Nat + affected : Array Bool + deriving Inhabited + +abbrev SearchM := StateT Stats (Except SharingError) + +@[inline] def liftE {α} (x : Except SharingError α) : SearchM α := + match x with + | .ok a => pure a + | .error e => throw e + +def chargeCost (limits : Limits) (w : Nat) : SearchM Unit := do + let s ← get + let v ← liftE (bump s.costEvals w limits.maxCostEvals .costEvals) + set { s with costEvals := v } + +def chargeTransition (limits : Limits) : SearchM Unit := do + let s ← get + let v ← liftE (bump s.transitions 1 limits.maxTransitions .transitions) + set { s with transitions := v } + +def chargeState (limits : Limits) : SearchM Unit := do + let s ← get + let v ← liftE (bump s.statesReached 1 limits.maxStates .states) + set { s with statesReached := v } + +/-- The winning stopping state: variable length and table term IDs. -/ +structure Best where + total : Nat + table : Array Nat + deriving Repr, Inhabited + +/-- Exact width-state search. `upper` must be the variable length of some +feasible encoding (it is only used for pruning). Returns the least +`(variable length, table term-ID vector)` over all stopping states. -/ +def search (inp : SearchInput) (limits : Limits) (upper : Nat) + (widthAt : Nat → Nat := shareWidth) : SearchM Best := do + let n := inp.prep.dag.size + let cands := inp.candidates + let (optCost, w0) := inp.prep.costs (optimisticWidths n cands #[]) inp.affected + chargeCost limits w0 + let rootLB0 := rootsCost optCost inp.roots + let mut incumbent := upper + let mut best : Option Best := none + let mut layer : Array (StateKey × Nat × Array Nat) := #[(#[], 0, #[])] + chargeState limits + for k in [0:cands.size + 1] do + if layer.isEmpty then break + modify fun s => { s with layers := s.layers + 1 } + let mut next : Std.HashMap StateKey (Nat × Array Nat) := {} + for (key, f, pre) in layer do + let rootLB ← if k ≤ 8 then pure rootLB0 else do + let (c, w) := inp.prep.costs (optimisticWidths n cands key) inp.affected + chargeCost limits w + pure (rootsCost c inp.roots) + if limits.prune && f + tag0Size k + rootLB > incumbent then + modify fun s => { s with statesPruned := s.statesPruned + 1 } + continue + modify fun s => { s with statesExpanded := s.statesExpanded + 1 } + let width := key.widths n + let (cost, w) := inp.prep.costs width inp.affected + chargeCost limits w + let total := f + tag0Size k + rootsCost cost inp.roots + let improves := match best with + | none => true + | some b => lexLess total pre b.total b.table + if improves then best := some ⟨total, pre⟩ + if total < incumbent then incumbent := total + let nw := widthAt k + let quickRest := tag0Size (k + 1) + rootLB + for t in cands do + if (width[t]!).isSome then continue + chargeTransition limits + let f' := f + cost[t]! + if limits.prune && f' + quickRest > incumbent then + modify fun s => { s with transitionsPruned := s.transitionsPruned + 1 } + continue + let key' := key.insertSorted t nw + let pre' := pre.push t + match next.get? key' with + | none => + chargeState limits + next := next.insert key' (f', pre') + | some (f0, pre0) => + if lexLess f' pre' f0 pre0 then next := next.insert key' (f', pre') + layer := (next.toArray.map fun (key, f, pre) => (key, f, pre)).qsort + fun a b => StateKey.compare a.1 b.1 == .lt + match best with + | some b => return b + | none => throw (.internal "search evaluated no stopping state") + +/-! ## Materialization and verification -/ + +/-- State of the table materialization: the entries so far, the dictionary +of those entries (table indices and Share widths), its evaluation, the +predicted length and the work. -/ +structure TableState where + entries : Array Ixon.Expr + index : Array (Option Nat) + width : Array (Option Nat) + ev : DictEval + predicted : Nat + work : Nat + deriving Inhabited + +/-- Materialize table entry `i` against the dictionary of the entries before +it, then add it to the dictionary, re-evaluating only the entry and the +terms above it. The work (the evaluation that priced the entry plus its +size) is checked against `maxMaterializeWork` after every entry. -/ +def materializeStep (p : Prep) (table : Array Nat) (limits : Limits) (widthAt : Nat → Nat) + (st : TableState) (i : Nat) : Except SharingError TableState := do + let t := table[i]! + let c := st.ev.cost[t]! + if c > limits.maxMaterialize then + throw (.resourceExhausted .materialize limits.maxMaterialize) + let e ← p.build st.ev st.index st.width false (p.dag.size + 1) t + let work := st.work + st.ev.work + c + if work > limits.maxMaterializeWork then + throw (.resourceExhausted .materializeWork limits.maxMaterializeWork) + let index := st.index.set! t (some i) + let width := st.width.set! t (some (widthAt i)) + return { entries := st.entries.push e, index, width, ev := p.evalUp st.ev width t, + predicted := st.predicted + c, work } + +/-- Materialize a table sequence and the roots with the byte-least +minimum-length encodings: entry `i` against the dictionary of the entries +before it, the roots against the whole table. Returns entries, roots, and +the variable length predicted by `C_M`. The Share at index `i` is priced +`widthAt i` (the real width by default, or a model width). The dictionary +is evaluated once and then updated incrementally (`Prep.evalUp`). -/ +def materializeTable (p : Prep) (table roots : Array Nat) (limits : Limits) + (widthAt : Nat → Nat := shareWidth) : + Except SharingError (Array Ixon.Expr × Array Ixon.Expr × Nat × Nat) := do + if table.size ≥ wordBound then throw (.formatBound "share index" table.size) else + if !table.all (· < p.dag.size) then throw (.internal "table term out of range") else do + let st ← (List.range table.size).foldlM (materializeStep p table limits widthAt) + { entries := #[], index := Array.replicate p.dag.size none, + width := Array.replicate p.dag.size none, + ev := p.evalAll (Array.replicate p.dag.size none), + predicted := tag0Size table.size, work := 0 } + if roots.foldl (fun acc r => acc + st.ev.cost[r]!) 0 > limits.maxMaterialize then + throw (.resourceExhausted .materialize limits.maxMaterialize) else do + let rs ← roots.mapM fun r => p.build st.ev st.index st.width false (p.dag.size + 1) r + let work := st.work + st.ev.work + roots.foldl (fun acc r => acc + st.ev.cost[r]!) 0 + if work > limits.maxMaterializeWork then + throw (.resourceExhausted .materializeWork limits.maxMaterializeWork) else + return (st.entries, rs, st.predicted + rootsCost st.ev.cost roots, work) + +/-! ### The same materialization with the ancestors marked by a walk + +`materializeStep` re-evaluates through `Prep.evalUp`, which tests every term +from the entry on for the entry below it, and updates the dictionary arrays +while the state that holds them is still live, so each entry copies them. +`materializeStepFast` takes the state apart first and marks the terms to +re-evaluate by a walk up the parent lists (`Prep.evalUpFast`); +`materializeTable_eq_fast` proves the result equal for every input (on a +DAG whose children do not precede their parents the specification runs). -/ + +/-- `materializeStep` with the state taken apart and `Prep.evalUpFast` +(parent lists `parents`, cleared marks `mark`, returned cleared). -/ +def materializeStepFast (p : Prep) (parents : Array (Array Nat)) (table : Array Nat) + (limits : Limits) (widthAt : Nat → Nat) (st : TableState) (mark : Array Bool) (i : Nat) : + Except SharingError (TableState × Array Bool) := + match st with + | ⟨entries, index, width, ev, predicted, work⟩ => + let t := table[i]! + let c := ev.cost[t]! + if c > limits.maxMaterialize then .error (.resourceExhausted .materialize limits.maxMaterialize) + else match p.build ev index width false (p.dag.size + 1) t with + | .error e => .error e + | .ok e => + let work := work + ev.work + c + if work > limits.maxMaterializeWork then + .error (.resourceExhausted .materializeWork limits.maxMaterializeWork) + else + let index := index.set! t (some i) + let width := width.set! t (some (widthAt i)) + match p.evalUpFast parents ev width t mark with + | (ev, mark) => .ok (⟨entries.push e, index, width, ev, predicted + c, work⟩, mark) + +/-- Entries `i, …, i + k - 1` by `materializeStepFast`. -/ +def materializeLoopFast (p : Prep) (parents : Array (Array Nat)) (table : Array Nat) + (limits : Limits) (widthAt : Nat → Nat) : + Nat → Nat → TableState → Array Bool → Except SharingError TableState + | 0, _, st, _ => .ok st + | k + 1, i, st, mark => + match materializeStepFast p parents table limits widthAt st mark i with + | .error e => .error e + | .ok (st, mark) => materializeLoopFast p parents table limits widthAt k (i + 1) st mark + +/-- `materializeTable` by `materializeLoopFast` (`materializeTable_eq_fast`). -/ +def materializeTableFast (p : Prep) (table roots : Array Nat) (limits : Limits) + (widthAt : Nat → Nat := shareWidth) : + Except SharingError (Array Ixon.Expr × Array Ixon.Expr × Nat × Nat) := do + if table.size ≥ wordBound then throw (.formatBound "share index" table.size) else + if !table.all (· < p.dag.size) then throw (.internal "table term out of range") else + if !childrenPrecede p.dag.nodes then materializeTable p table roots limits widthAt else do + let st ← materializeLoopFast p (parentEdgeLists p.dag) table limits widthAt table.size 0 + { entries := #[], index := Array.replicate p.dag.size none, + width := Array.replicate p.dag.size none, + ev := p.evalAll (Array.replicate p.dag.size none), + predicted := tag0Size table.size, work := 0 } (Array.replicate p.dag.size false) + if roots.foldl (fun acc r => acc + st.ev.cost[r]!) 0 > limits.maxMaterialize then + throw (.resourceExhausted .materialize limits.maxMaterialize) else do + let rs ← roots.mapM fun r => p.build st.ev st.index st.width false (p.dag.size + 1) r + let work := st.work + st.ev.work + roots.foldl (fun acc r => acc + st.ev.cost[r]!) 0 + if work > limits.maxMaterializeWork then + throw (.resourceExhausted .materializeWork limits.maxMaterializeWork) else + return (st.entries, rs, st.predicted + rootsCost st.ev.cost roots, work) + +theorem materializeStepFast_eq (p : Prep) (table : Array Nat) (limits : Limits) + (widthAt : Nat → Nat) (st : TableState) (i : Nat) (hcp : childrenPrecede p.dag.nodes = true) + (ht : table[i]! < p.dag.size) : + materializeStepFast p (parentEdgeLists p.dag) table limits widthAt st + (Array.replicate p.dag.size false) i = + (materializeStep p table limits widthAt st i).map + fun st' => (st', Array.replicate p.dag.size false) := by + obtain ⟨entries, index, width, ev, predicted, work⟩ := st + unfold materializeStepFast materializeStep + simp only [Prep.evalUpFast_eq _ _ _ _ ht hcp] + by_cases h1 : ev.cost[table[i]!]! > limits.maxMaterialize + · simp [h1, bind, Except.bind, throw, throwThe, MonadExceptOf.throw, Except.map] + · cases hb : p.build ev index width false (p.dag.size + 1) table[i]! with + | error e => simp [h1, bind, Except.bind, Except.map] + | ok e => + by_cases h2 : work + ev.work + ev.cost[table[i]!]! > limits.maxMaterializeWork + · simp [h1, h2, bind, Except.bind, throw, throwThe, MonadExceptOf.throw, Except.map] + · simp [h1, h2, bind, Except.bind, pure, Except.pure, Except.map] + +theorem materializeLoopFast_eq (p : Prep) (table : Array Nat) (limits : Limits) + (widthAt : Nat → Nat) (hcp : childrenPrecede p.dag.nodes = true) + (htab : ∀ i, i < table.size → table[i]! < p.dag.size) : + ∀ (k i : Nat) (st : TableState), i + k ≤ table.size → + materializeLoopFast p (parentEdgeLists p.dag) table limits widthAt k i st + (Array.replicate p.dag.size false) = + (List.range' i k).foldlM (materializeStep p table limits widthAt) st + | 0, _, st, _ => rfl + | k + 1, i, st, hk => by + unfold materializeLoopFast + rw [materializeStepFast_eq p table limits widthAt st i hcp (htab i (by omega)), + List.range'_succ, List.foldlM_cons] + cases materializeStep p table limits widthAt st i with + | error e => rfl + | ok st' => + exact materializeLoopFast_eq p table limits widthAt hcp htab k (i + 1) st' (by omega) + +@[csimp] theorem materializeTable_eq_fast : @materializeTable = @materializeTableFast := by + funext p table roots limits widthAt + unfold materializeTableFast + by_cases h1 : table.size ≥ wordBound + · unfold materializeTable + simp [h1] + · by_cases h2 : table.all (· < p.dag.size) = true + · by_cases h3 : childrenPrecede p.dag.nodes = true + · have htab : ∀ i, i < table.size → table[i]! < p.dag.size := by + intro i hi + rw [Array.all_eq_true] at h2 + rw [getElem!_pos table i hi] + simpa using h2 i hi + have hl := materializeLoopFast_eq p table limits widthAt h3 htab table.size 0 + { entries := #[], index := Array.replicate p.dag.size none, + width := Array.replicate p.dag.size none, + ev := p.evalAll (Array.replicate p.dag.size none), + predicted := tag0Size table.size, work := 0 } (by omega) + rw [← List.range_eq_range'] at hl + unfold materializeTable + simp only [h1, h2, h3, hl, if_false, Bool.not_true, Bool.false_eq_true] + · simp [h1, h2, h3] + · unfold materializeTable + simp [h1, h2] + +/-! ### One evaluation for an order closed under stored descendants + +When every stored descendant of each entry comes before it in the table (and +the DAG is well formed), the entry for `t` written under the entries before +it is the entry written under the whole table with the Share of `t` itself +hidden: below `t` the two dictionaries agree. `materializeTableOnePass` then +evaluates the whole dictionary once, prices each entry with its own Share +hidden (`evalHidden`) and builds it with the top Share excluded +(`Prep.buildTop`), and the roots under the whole table. The work it reports +and checks is the work `materializeTable` counts entry by entry, computed +from a walk up the parent lists (`ancestorWork`) and the spine counts +(`spineAdd`) instead of re-evaluating. Any other order or DAG, or a walk out +of fuel, runs `materializeTable`. -/ + +/-- The DAG is well formed (children before parents, the arity of each +head), the roots are terms of it, and the table lists distinct terms (its +whole-table index `index` maps each to its own position), each after every +stored term below it. -/ +def onePassOrder (dag : Dag) (table roots : Array Nat) (index : Array (Option Nat)) : Bool := + childrenPrecede dag.nodes && dag.nodes.all (fun node => node.children.size == node.head.arity) && + roots.all (· < dag.size) && + let pos := fun c => match index[c]?.getD none with + | some i => i + 1 + | none => 0 + let maxBelow := foldRange (fun (mb : Array Nat) u => + mb.set! u ((dag.node u).children.foldl (fun m c => max m (max (pos c) mb[c]!)) 0)) + 0 dag.size (Array.replicate dag.size 0) + (List.range table.size).all fun i => + index[table[i]!]?.getD none == some i && decide (maxBelow[table[i]!]! ≤ i) + +/-- Entries `i, …, i + k - 1` of `materializeTableOnePass`: the entries so +far, the work so far, the work of the evaluation that prices the next entry, +the predicted length, the spine counts, the walk's marks (all below `i + 1`) +and its queue; `none` if a walk runs out of fuel. -/ +def onePassLoop (p : Prep) (table : Array Nat) (limits : Limits) (ev : DictEval) + (index width : Array (Option Nat)) (allTrue : Array Bool) (parents sp : Array (Array Nat)) : + Nat → Nat → Array Ixon.Expr → Nat → Nat → Nat → Array Nat → Array Nat → Array Nat → + Option (Except SharingError (Array Ixon.Expr × Nat × Nat × Nat)) + | 0, _, entries, work, evWork, predicted, _, _, _ => some (.ok (entries, work, evWork, predicted)) + | k + 1, i, entries, work, evWork, predicted, sc, mark, queue => + let t := table[i]! + let c := evalHidden p.dag p.family p.spineLen p.tail width allTrue ev t + if c > limits.maxMaterialize then + some (.error (.resourceExhausted .materialize limits.maxMaterialize)) + else match p.buildTop ev index width c (p.dag.size + 1) t with + | .error e => some (.error e) + | .ok e => + let work := work + evWork + c + if work > limits.maxMaterializeWork then + some (.error (.resourceExhausted .materializeWork limits.maxMaterializeWork)) + else match spineAdd sp sc t with + | none => none + | some sc => + match ancestorWork parents sc (i + 1) t (4 * p.dag.size + 2) mark queue with + | none => none + | some (w, mark, queue) => + onePassLoop p table limits ev index width allTrue parents sp k (i + 1) (entries.push e) + work w (predicted + c) sc mark queue + +/-- `materializeTable` with one evaluation of the whole dictionary when the +order is closed under stored descendants (`onePassOrder`). -/ +def materializeTableOnePass (p : Prep) (table roots : Array Nat) (limits : Limits) + (widthAt : Nat → Nat := shareWidth) : + Except SharingError (Array Ixon.Expr × Array Ixon.Expr × Nat × Nat) := + if table.size ≥ wordBound then throw (.formatBound "share index" table.size) else + if !table.all (· < p.dag.size) then throw (.internal "table term out of range") else + let n := p.dag.size + let index := indexOfPrefix n table table.size + if !onePassOrder p.dag table roots index then materializeTable p table roots limits widthAt else + let width := index.map (·.map widthAt) + let ev := p.evalAll width + -- the first entry is priced by the empty dictionary's evaluation, which counts one per + -- term (`evalAll_none_work`) + match onePassLoop p table limits ev index width (Array.replicate n true) (parentEdgeLists p.dag) + (spineParentLists p.dag p.family) table.size 0 #[] 0 n (tag0Size table.size) + (Array.replicate n 0) (Array.replicate n 0) #[] with + | none => materializeTable p table roots limits widthAt + | some (.error e) => .error e + | some (.ok (entries, work, evWork, predicted)) => + if roots.foldl (fun acc r => acc + ev.cost[r]!) 0 > limits.maxMaterialize then + throw (.resourceExhausted .materialize limits.maxMaterialize) else do + let rs ← roots.mapM fun r => p.build ev index width false (p.dag.size + 1) r + let work := work + evWork + roots.foldl (fun acc r => acc + ev.cost[r]!) 0 + if work > limits.maxMaterializeWork then + throw (.resourceExhausted .materializeWork limits.maxMaterializeWork) else + return (entries, rs, predicted + rootsCost ev.cost roots, work) + +/-- Result of an exact optimization. -/ +structure ExactSharingResult where + /-- Rewritten roots, in input order. -/ + roots : Array Ixon.Expr + /-- The sharing table. -/ + sharing : Array Ixon.Expr + /-- Structural term IDs of the table entries (the key component `Q`). -/ + tableTerms : Array Nat + /-- Exact variable bytes: roots, table count, and table bodies. -/ + variableBytes : Nat + /-- The optimized objective: `variableBytes` with the real Share widths, + or the variable length in a uniform-width cost model. -/ + modelBytes : Nat + /-- Variable bytes of the unshared encoding. -/ + unsharedBytes : Nat + stats : Stats + deriving Repr, Inhabited + +/-- Optimize an expanded input. The result minimizes +`(variable length, table term IDs, bytes)`; since the fixed Constant bytes +are the same for every candidate, this is the §3.3 key of the complete +Constant. + +With `minInDegree2` only terms of compact in-degree at least 2 are +candidates. With `uniform := some w` every Share is priced `w` bytes regardless of its +index (a cost model, used as the reference for the uniform-width +optimizer): the search minimizes the model length, and `modelBytes` reports +the model length while `variableBytes` reports the real serialized length of the +same output. -/ +def optimizeExpanded (limits : Limits) (ex : Expanded) (uniform : Option Nat := none) + (minInDegree2 : Bool := false) : Except SharingError ExactSharingResult := do + if uniform == some 0 then throw (.formatBound "uniform Share width" 0) + let widthAt : Nat → Nat := match uniform with + | some w => fun _ => w + | none => shareWidth + let p := Prep.ofDag ex.dag + let n := ex.dag.size + let occ := occurrences ex.dag ex.roots + let cands := candidateTerms p occ + -- Optionally restrict to terms of compact in-degree ≥ 2 (the uniform + -- optimizer's candidate space), for differential tests. + let cands := if !minInDegree2 then cands else Id.run do + let mut deg : Array Nat := Array.replicate n 0 + for r in ex.roots do deg := deg.modify r (· + 1) + for node in ex.dag.nodes do + for c in node.children do deg := deg.modify c (· + 1) + return cands.filter (deg[·]! ≥ 2) + let isCand := cands.foldl (fun acc t => acc.set! t true) (Array.replicate n false) + let affected := affectedTerms ex.dag isCand + let unshared := tag0Size 0 + rootsCost p.base ex.roots + -- The unshared encoding is the initial upper bound. + let upper := unshared + let stats0 : Stats := + { exprVisits := ex.visits, internedNodes := ex.internedNodes, + distinctSubterms := n, candidates := cands.size } + let inp : SearchInput := { prep := p, roots := ex.roots, candidates := cands, affected } + let (best, stats) ← (search inp limits upper widthAt).run stats0 + if best.total > limits.maxOutputBytes then + throw (.resourceExhausted .outputBytes limits.maxOutputBytes) + let (entries, roots, predicted, work) ← materializeTable p best.table ex.roots limits widthAt + unless predicted == best.total do + throw (.internal s!"materialized cost {predicted} differs from search cost {best.total}") + let measured := tag0Size entries.size + exprsSize entries + exprsSize roots + unless uniform.isSome || measured == best.total do + throw (.internal s!"measured length {measured} differs from search cost {best.total}") + let (entryIds, rootIds, _) ← reexpand limits ex.dag entries roots + unless entryIds == best.table do + throw (.internal "materialized entries do not expand to the selected terms") + unless rootIds == ex.roots do + throw (.internal "materialized roots do not expand to the input roots") + return { roots, sharing := entries, tableTerms := best.table, + variableBytes := measured, modelBytes := best.total, unsharedBytes := unshared, + stats := { stats with materializedNodes := work, outputBytes := measured } } + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/SortedSets.lean b/Ix/Sharing/Exact/SortedSets.lean new file mode 100644 index 000000000..3f6a0f14f --- /dev/null +++ b/Ix/Sharing/Exact/SortedSets.lean @@ -0,0 +1,518 @@ +/- + Ascending lists of terms as sets: the least element of a symmetric + difference (`firstDiff`), the `setPrec` tie order in terms of it, unions of + sets over disjoint domains, and chains of sets in `setPrec` order (the + first difference of two sets of a chain is the least first difference of + the neighbours between them). Used by the rank-based table-count knapsack + (`Exact.KnapsackFast`). +-/ +module + +public import Ix.Sharing.Exact.UniformSearch +import all Ix.Sharing.Exact.UniformSearch +import all Ix.Common + +public section + +namespace Ix.Sharing.Exact + +/-! ## First differences -/ + +/-- The least element of the symmetric difference of two ascending lists +(`none` when they are equal): at the first position where they differ, the +smaller element is in one list only. -/ +def firstDiff : List Nat → List Nat → Option Nat + | [], [] => none + | x :: _, [] => some x + | [], y :: _ => some y + | x :: xs, y :: ys => if x = y then firstDiff xs ys else some (min x y) + +/-- `m` is the least element of the symmetric difference of `A` and `B`. -/ +def IsFD (A B : List Nat) (m : Nat) : Prop := + (m ∈ A ↔ m ∉ B) ∧ ∀ y, y < m → (y ∈ A ↔ y ∈ B) + +theorem IsFD.symm {A B : List Nat} {m : Nat} (h : IsFD A B m) : IsFD B A m := + ⟨by have := h.1; by_cases hA : m ∈ A <;> by_cases hB : m ∈ B <;> simp_all, + fun y hy => (h.2 y hy).symm⟩ + +theorem IsFD.unique {A B : List Nat} {m m' : Nat} (h : IsFD A B m) (h' : IsFD A B m') : + m = m' := by + rcases Nat.lt_trichotomy m m' with hlt | heq | hgt + · have := h'.2 m hlt + have := h.1 + exfalso + by_cases hm : m ∈ A <;> simp_all + · exact heq + · have := h.2 m' hgt + have := h'.1 + exfalso + by_cases hm : m' ∈ A <;> simp_all + +theorem firstDiff_spec : ∀ (A B : List Nat), A.Pairwise (· < ·) → B.Pairwise (· < ·) → + (firstDiff A B = none ↔ A = B) ∧ ∀ m, firstDiff A B = some m → IsFD A B m + | [], [], _, _ => ⟨by simp [firstDiff], fun m h => by simp [firstDiff] at h⟩ + | x :: xs, [], hA, _ => by + refine ⟨by simp [firstDiff], fun m h => ?_⟩ + simp only [firstDiff, Option.some.injEq] at h + subst h + refine ⟨by simp, fun y hy => ?_⟩ + simp only [List.mem_cons, List.not_mem_nil, iff_false, not_or] + refine ⟨Nat.ne_of_lt hy, fun hy' => ?_⟩ + have := List.rel_of_pairwise_cons hA hy' + omega + | [], y :: ys, _, hB => by + refine ⟨by simp [firstDiff], fun m h => ?_⟩ + simp only [firstDiff, Option.some.injEq] at h + subst h + refine ⟨by simp, fun z hz => ?_⟩ + simp only [List.not_mem_nil, List.mem_cons, false_iff, not_or] + refine ⟨Nat.ne_of_lt hz, fun hz' => ?_⟩ + have := List.rel_of_pairwise_cons hB hz' + omega + | x :: xs, y :: ys, hA, hB => by + have hxs := hA.of_cons + have hys := hB.of_cons + by_cases hxy : x = y + · subst hxy + obtain ⟨ih1, ih2⟩ := firstDiff_spec xs ys hxs hys + simp only [firstDiff, if_true] + refine ⟨by rw [ih1]; simp, fun m h => ?_⟩ + obtain ⟨h1, h2⟩ := ih2 m h + -- `m` is in `xs` or `ys`, so it is above `x` + have hmx : x < m := by + by_cases hm : m ∈ xs + · exact List.rel_of_pairwise_cons hA hm + · have : m ∈ ys := by + by_cases hc : m ∈ ys + · exact hc + · exact absurd (h1.mpr hc) hm + exact List.rel_of_pairwise_cons hB this + refine ⟨?_, fun z hz => ?_⟩ + · simp only [List.mem_cons] + constructor + · rintro (h | h) + · omega + · intro h' + rcases h' with h' | h' + · omega + · exact h1.mp h h' + · intro h' + simp only [not_or] at h' + exact Or.inr (h1.mpr h'.2) + · simp only [List.mem_cons] + by_cases hzx : z = x + · simp [hzx] + · simp only [hzx, false_or] + exact h2 z hz + · simp only [firstDiff, hxy, if_false] + refine ⟨by simp [hxy], fun m h => ?_⟩ + simp only [Option.some.injEq] at h + subst h + rcases Nat.lt_or_gt_of_ne hxy with hlt | hgt + · rw [Nat.min_eq_left (Nat.le_of_lt hlt)] + refine ⟨?_, fun z hz => ?_⟩ + · simp only [List.mem_cons, true_or, true_iff, not_or] + refine ⟨hxy, fun h' => ?_⟩ + have := List.rel_of_pairwise_cons hB h' + omega + · simp only [List.mem_cons] + have h1 : z ∉ xs := fun h' => by have := List.rel_of_pairwise_cons hA h'; omega + have h2 : z ∉ ys := fun h' => by have := List.rel_of_pairwise_cons hB h'; omega + simp only [h1, h2, or_false] + omega + · rw [Nat.min_eq_right (Nat.le_of_lt hgt)] + refine ⟨?_, fun z hz => ?_⟩ + · simp only [List.mem_cons, true_or, not_true, iff_false, not_or] + refine ⟨fun h' => hxy h'.symm, fun h' => ?_⟩ + have := List.rel_of_pairwise_cons hA h' + omega + · simp only [List.mem_cons] + have h1 : z ∉ xs := fun h' => by have := List.rel_of_pairwise_cons hA h'; omega + have h2 : z ∉ ys := fun h' => by have := List.rel_of_pairwise_cons hB h'; omega + simp only [h1, h2, or_false] + omega + +/-- The first difference is the unique least element of the symmetric +difference. -/ +theorem firstDiff_eq_some_iff {A B : List Nat} (hA : A.Pairwise (· < ·)) + (hB : B.Pairwise (· < ·)) {m : Nat} : firstDiff A B = some m ↔ IsFD A B m := by + obtain ⟨hnone, hsome⟩ := firstDiff_spec A B hA hB + constructor + · exact hsome m + · intro h + cases hfd : firstDiff A B with + | none => + have hAB := hnone.mp hfd + subst hAB + have := h.1 + by_cases hm : m ∈ A <;> simp_all + | some m' => rw [IsFD.unique (hsome m' hfd) h] + +/-- Sorted lists with the same members are equal. -/ +theorem eq_of_mem_iff {A B : List Nat} (hA : A.Pairwise (· < ·)) (hB : B.Pairwise (· < ·)) + (h : ∀ y, y ∈ A ↔ y ∈ B) : A = B := by + apply List.Perm.eq_of_pairwise (le := (· < ·)) (fun a b _ _ h1 h2 => absurd h2 (by omega)) + hA hB + exact (List.perm_ext_iff_of_nodup (hA.imp Nat.ne_of_lt) (hB.imp Nat.ne_of_lt)).mpr h + +/-! ## The tie order -/ + +theorem compareDesc_eq (x y : Nat) : compareDesc x y = compare y x := by + unfold compareDesc; rfl + +/-- On ascending lists, `setPrec a b` holds exactly when the first difference +is in `b`. -/ +theorem setPrec_iff_list : ∀ (A B : List Nat), A.Pairwise (· < ·) → B.Pairwise (· < ·) → + (List.compareLex compareDesc A B = .lt ↔ ∃ m, firstDiff A B = some m ∧ m ∈ B) + | [], [], _, _ => by simp [firstDiff, List.compareLex_nil_nil] + | x :: xs, [], _, _ => by simp [firstDiff, List.compareLex_cons_nil] + | [], y :: ys, _, _ => by simp [firstDiff, List.compareLex_nil_cons] + | x :: xs, y :: ys, hA, hB => by + rw [List.compareLex_cons_cons, compareDesc_eq] + by_cases hxy : x = y + · subst hxy + simp only [Nat.compare_eq_eq.mpr rfl, Ordering.eq_then, firstDiff, if_true] + rw [setPrec_iff_list xs ys hA.of_cons hB.of_cons] + constructor + · rintro ⟨m, h1, h2⟩; exact ⟨m, h1, List.mem_cons_of_mem _ h2⟩ + · rintro ⟨m, h1, h2⟩ + refine ⟨m, h1, ?_⟩ + rcases List.mem_cons.mp h2 with h | h + · -- `m = x` is impossible: `m` is in `xs` or `ys` + exfalso + obtain ⟨hfd, _⟩ := (firstDiff_spec xs ys hA.of_cons hB.of_cons).2 m h1 + subst h + by_cases hm : m ∈ xs + · have := List.rel_of_pairwise_cons hA hm; omega + · have : m ∈ ys := by + by_cases hc : m ∈ ys + · exact hc + · exact absurd (hfd.mpr hc) hm + have := List.rel_of_pairwise_cons hB this; omega + · exact h + · simp only [firstDiff, hxy, if_false, Option.some.injEq, exists_eq_left'] + rcases Nat.lt_or_gt_of_ne hxy with hlt | hgt + · rw [Nat.compare_eq_gt.mpr hlt, Nat.min_eq_left (Nat.le_of_lt hlt)] + simp only [Ordering.gt_then, reduceCtorEq, false_iff, List.mem_cons, not_or] + refine ⟨hxy, fun h' => ?_⟩ + have := List.rel_of_pairwise_cons hB h' + omega + · rw [Nat.compare_eq_lt.mpr hgt, Nat.min_eq_right (Nat.le_of_lt hgt)] + simp + +theorem setPrec_iff {a b : Array Nat} (ha : a.toList.Pairwise (· < ·)) + (hb : b.toList.Pairwise (· < ·)) : + setPrec a b = true ↔ ∃ m, firstDiff a.toList b.toList = some m ∧ m ∈ b.toList := by + unfold setPrec + rw [Array.compareLex_eq_compareLex_toList, ← setPrec_iff_list _ _ ha hb] + + cases List.compareLex compareDesc a.toList b.toList <;> decide + +/-! ## Unions over disjoint domains -/ + +/-- The least of two optional elements, `none` standing for no element. -/ +def minOpt : Option Nat → Option Nat → Option Nat + | none, b => b + | a, none => a + | some a, some b => some (min a b) + +theorem firstDiff_none {A B : List Nat} (hA : A.Pairwise (· < ·)) (hB : B.Pairwise (· < ·)) : + firstDiff A B = none ↔ A = B := + (firstDiff_spec A B hA hB).1 + +/-- The first difference of two unions `S ∪ X`, `S' ∪ Y` whose parts come from +disjoint domains is the smaller of the parts' first differences. -/ +theorem firstDiff_union {S S' X Y U V : List Nat} + (hS : S.Pairwise (· < ·)) (hS' : S'.Pairwise (· < ·)) (hX : X.Pairwise (· < ·)) + (hY : Y.Pairwise (· < ·)) (hUs : U.Pairwise (· < ·)) (hVs : V.Pairwise (· < ·)) + (hU : ∀ z, z ∈ U ↔ z ∈ S ∨ z ∈ X) (hV : ∀ z, z ∈ V ↔ z ∈ S' ∨ z ∈ Y) + (hdisj : ∀ z, (z ∈ S ∨ z ∈ S') → z ∉ X ∧ z ∉ Y) : + firstDiff U V = minOpt (firstDiff S S') (firstDiff X Y) := by + cases h1 : firstDiff S S' with + | none => + have hSS := (firstDiff_none hS hS').mp h1 + subst hSS + cases h2 : firstDiff X Y with + | none => + have hXY := (firstDiff_none hX hY).mp h2 + subst hXY + exact (firstDiff_none hUs hVs).mpr (eq_of_mem_iff hUs hVs fun z => by rw [hU, hV]) + | some b => + have hb := (firstDiff_eq_some_iff hX hY).mp h2 + simp only [minOpt] + apply (firstDiff_eq_some_iff hUs hVs).mpr + have hbS : b ∉ S := by + intro h + have := hdisj b (Or.inl h) + by_cases hbX : b ∈ X + · exact this.1 hbX + · exact this.2 (by have := hb.1; by_cases hbY : b ∈ Y <;> simp_all) + refine ⟨?_, fun z hz => ?_⟩ + · rw [hU, hV]; simp only [hbS, false_or]; exact hb.1 + · rw [hU, hV, hb.2 z hz] + | some a => + have ha := (firstDiff_eq_some_iff hS hS').mp h1 + have haS : a ∈ S ∨ a ∈ S' := by + have := ha.1; by_cases has : a ∈ S <;> simp_all + obtain ⟨haX, haY⟩ := hdisj a haS + cases h2 : firstDiff X Y with + | none => + have hXY := (firstDiff_none hX hY).mp h2 + subst hXY + simp only [minOpt] + apply (firstDiff_eq_some_iff hUs hVs).mpr + refine ⟨?_, fun z hz => ?_⟩ + · rw [hU, hV]; simp only [haX, or_false]; exact ha.1 + · rw [hU, hV, ha.2 z hz] + | some b => + have hb := (firstDiff_eq_some_iff hX hY).mp h2 + have hbXY : b ∈ X ∨ b ∈ Y := by + have := hb.1; by_cases hbx : b ∈ X <;> simp_all + have hab : a ≠ b := by + intro h; subst h + rcases hbXY with h | h + · exact haX h + · exact haY h + have hbS : b ∉ S ∧ b ∉ S' := by + constructor + · intro h + have := hdisj b (Or.inl h) + rcases hbXY with h' | h' + · exact this.1 h' + · exact this.2 h' + · intro h + have := hdisj b (Or.inr h) + rcases hbXY with h' | h' + · exact this.1 h' + · exact this.2 h' + simp only [minOpt] + apply (firstDiff_eq_some_iff hUs hVs).mpr + rcases Nat.lt_or_gt_of_ne hab with hlt | hgt + · rw [Nat.min_eq_left (Nat.le_of_lt hlt)] + refine ⟨?_, fun z hz => ?_⟩ + · rw [hU, hV]; simp only [haX, haY, or_false]; exact ha.1 + · rw [hU, hV, ha.2 z hz, hb.2 z (by omega)] + · rw [Nat.min_eq_right (Nat.le_of_lt hgt)] + refine ⟨?_, fun z hz => ?_⟩ + · rw [hU, hV]; simp only [hbS.1, hbS.2, false_or]; exact hb.1 + · rw [hU, hV, ha.2 z (by omega), hb.2 z hz] + +/-! ## Chains in the tie order -/ + +/-- Three sets in `setPrec` order: the first difference of the outer two is the +smaller of the two neighbouring first differences, and it is in the last. -/ +theorem firstDiff_chain3 {A B C : List Nat} (hA : A.Pairwise (· < ·)) (hB : B.Pairwise (· < ·)) + (hC : C.Pairwise (· < ·)) {x y : Nat} (hAB : firstDiff A B = some x) (hxB : x ∈ B) + (hBC : firstDiff B C = some y) (hyC : y ∈ C) : + firstDiff A C = some (min x y) ∧ min x y ∈ C := by + have hx := (firstDiff_eq_some_iff hA hB).mp hAB + have hy := (firstDiff_eq_some_iff hB hC).mp hBC + have hxA : x ∉ A := fun h => (hx.1.mp h) hxB + have hyB : y ∉ B := fun h => (hy.1.mp h) hyC + have hxy : x ≠ y := fun h => by subst h; exact hyB hxB + rcases Nat.lt_or_gt_of_ne hxy with hlt | hgt + · rw [Nat.min_eq_left (Nat.le_of_lt hlt)] + have hxC : x ∈ C := (hy.2 x hlt).mp hxB + refine ⟨(firstDiff_eq_some_iff hA hC).mpr ⟨?_, fun z hz => ?_⟩, hxC⟩ + · simp [hxA, hxC] + · rw [hx.2 z hz, hy.2 z (by omega)] + · rw [Nat.min_eq_right (Nat.le_of_lt hgt)] + have hyA : y ∉ A := fun h => hyB ((hx.2 y hgt).mp h) + refine ⟨(firstDiff_eq_some_iff hA hC).mpr ⟨?_, fun z hz => ?_⟩, hyC⟩ + · simp [hyA, hyC] + · rw [hx.2 z (by omega), hy.2 z hz] + +/-- The least of `d i, …, d (i + k)`. -/ +def rmin (d : Nat → Nat) (i : Nat) : Nat → Nat + | 0 => d i + | k + 1 => min (rmin d i k) (d (i + k + 1)) + +/-- In a chain of ascending lists in `setPrec` order (each neighbouring first +difference `d r` is in the later set), the first difference of the sets at +`i` and `i + k + 1` is the least neighbouring first difference between them, +and it is in the later set. -/ +theorem firstDiff_chain {sets : Nat → List Nat} {d : Nat → Nat} {n : Nat} + (hsorted : ∀ r, r < n → (sets r).Pairwise (· < ·)) + (hadj : ∀ r, r + 1 < n → firstDiff (sets r) (sets (r + 1)) = some (d r) ∧ + d r ∈ sets (r + 1)) : + ∀ k i, i + k + 1 < n → + firstDiff (sets i) (sets (i + k + 1)) = some (rmin d i k) ∧ rmin d i k ∈ sets (i + k + 1) := by + intro k + induction k with + | zero => intro i hi; simpa [rmin] using hadj i (by omega) + | succ k ih => + intro i hi + obtain ⟨h1, h2⟩ := ih i (by omega) + obtain ⟨h3, h4⟩ := hadj (i + k + 1) (by omega) + have := firstDiff_chain3 (hsorted i (by omega)) (hsorted (i + k + 1) (by omega)) + (hsorted (i + k + 1 + 1) (by omega)) h1 h2 h3 h4 + simp only [rmin] + have e : i + (k + 1) + 1 = i + k + 1 + 1 := by omega + rw [e] + exact this + +/-! ## Range minima -/ + +theorem rmin_le (d : Nat → Nat) (i : Nat) : + ∀ k r, i ≤ r → r ≤ i + k → rmin d i k ≤ d r := by + intro k + induction k with + | zero => intro r h1 h2; have : r = i := by omega + subst this; simp [rmin] + | succ k ih => + intro r h1 h2 + simp only [rmin] + by_cases hr : r ≤ i + k + · exact Nat.le_trans (Nat.min_le_left _ _) (ih r h1 hr) + · have : r = i + k + 1 := by omega + subst this; exact Nat.min_le_right _ _ + +theorem rmin_attained (d : Nat → Nat) (i : Nat) : + ∀ k, ∃ r, i ≤ r ∧ r ≤ i + k ∧ rmin d i k = d r := by + intro k + induction k with + | zero => exact ⟨i, Nat.le_refl _, by omega, rfl⟩ + | succ k ih => + obtain ⟨r, h1, h2, h3⟩ := ih + simp only [rmin] + by_cases hle : rmin d i k ≤ d (i + k + 1) + · exact ⟨r, h1, by omega, by rw [Nat.min_eq_left hle, h3]⟩ + · exact ⟨i + k + 1, by omega, by omega, Nat.min_eq_right (by omega)⟩ + +/-- Two overlapping windows cover their union. -/ +theorem rmin_overlap (d : Nat → Nat) {i a j b : Nat} (hij : i ≤ j) (hj : j ≤ i + a + 1) + (hend : i + a ≤ j + b) : + min (rmin d i a) (rmin d j b) = rmin d i (j + b - i) := by + obtain ⟨r1, h11, h12, h13⟩ := rmin_attained d i a + obtain ⟨r2, h21, h22, h23⟩ := rmin_attained d j b + obtain ⟨r, h1, h2, h3⟩ := rmin_attained d i (j + b - i) + have e1 := rmin_le d i (j + b - i) r1 h11 (by omega) + have e2 := rmin_le d i (j + b - i) r2 (by omega) (by omega) + have e3 : min (rmin d i a) (rmin d j b) ≤ d r := by + by_cases hr : r ≤ i + a + · exact Nat.le_trans (Nat.min_le_left _ _) (rmin_le d i a r h1 hr) + · exact Nat.le_trans (Nat.min_le_right _ _) (rmin_le d j b r (by omega) (by omega)) + rw [h13, h23] at * + rw [h3] at e1 e2 ⊢ + omega + +/-- One doubling step of a sparse table: the minima of windows of width `2w` +from those of width `w`. -/ +def sparseNext (row : Array Nat) (w : Nat) : Array Nat := + (Array.range (row.size - w)).map fun r => min row[r]! row[r + w]! + +/-- Sparse-table levels from `row` (windows of width `w`). -/ +def sparseLevels : Nat → Array Nat → Nat → Array (Array Nat) → Array (Array Nat) + | 0, _, _, acc => acc + | fuel + 1, row, w, acc => + if row.size ≤ w then acc + else + let next := sparseNext row w + sparseLevels fuel next (2 * w) (acc.push next) + +/-- The sparse table of `adj`: level `l` holds the minimum of every window of +`2^l` consecutive entries. -/ +def sparseBuild (adj : Array Nat) : Array (Array Nat) := sparseLevels adj.size adj 1 #[adj] + +/-- The minimum of `adj[lo], …, adj[hi - 1]` (`lo < hi`), from the sparse table. -/ +def sparseQuery (sp : Array (Array Nat)) (lo hi : Nat) : Nat := + let l := Nat.log2 (hi - lo) + min sp[l]![lo]! sp[l]![hi - (1 <<< l)]! + +/-- A row of window minima of width `2^l` over `adj`. -/ +def RowOK (adj : Array Nat) (l : Nat) (row : Array Nat) : Prop := + row.size + 2 ^ l = adj.size + 1 ∧ + ∀ r, r + 2 ^ l ≤ adj.size → row[r]! = rmin (fun i => adj[i]!) r (2 ^ l - 1) + +theorem sparseNext_ok {adj : Array Nat} {l : Nat} {row : Array Nat} (h : RowOK adj l row) + (hs : 2 ^ l < row.size) : RowOK adj (l + 1) (sparseNext row (2 ^ l)) := by + obtain ⟨hsz, hrow⟩ := h + have hp : 0 < 2 ^ l := Nat.two_pow_pos l + refine ⟨?_, fun r hr => ?_⟩ + · simp only [sparseNext, Array.size_map, Array.size_range, Nat.pow_succ] + omega + · have hr' : r < row.size - 2 ^ l := by rw [Nat.pow_succ] at hr; omega + simp only [sparseNext] + rw [getElem!_pos _ r (by simpa using hr')] + simp only [Array.getElem_map, Array.getElem_range] + rw [hrow r (by rw [Nat.pow_succ] at hr; omega), hrow (r + 2 ^ l) (by rw [Nat.pow_succ] at hr; omega), + rmin_overlap _ (by omega) (by omega) (by omega)] + congr 1 + rw [Nat.pow_succ] + omega + +theorem sparseLevels_ok (adj : Array Nat) : + ∀ (fuel : Nat) (row : Array Nat) (l : Nat) (acc : Array (Array Nat)), + RowOK adj l row → acc.size = l + 1 → (∀ i, i ≤ l → RowOK adj i acc[i]!) → + adj.size < 2 ^ l + fuel → + let sp := sparseLevels fuel row (2 ^ l) acc + (∀ i, i < sp.size → RowOK adj i sp[i]!) ∧ (adj.size ≠ 0 → Nat.log2 adj.size < sp.size) := by + intro fuel + induction fuel with + | zero => + intro row l acc hrow hacc hall hfuel + simp only [sparseLevels] + refine ⟨fun i hi => hall i (by omega), fun hn => ?_⟩ + rw [hacc, Nat.lt_succ_iff] + exact (Nat.log2_lt hn).mpr (by omega) |> Nat.le_of_lt_succ + | succ fuel ih => + intro row l acc hrow hacc hall hfuel + simp only [sparseLevels] + split + · rename_i hle + refine ⟨fun i hi => hall i (by omega), fun hn => ?_⟩ + rw [hacc, Nat.lt_succ_iff] + have : adj.size < 2 ^ (l + 1) := by + have := hrow.1; rw [Nat.pow_succ]; omega + exact Nat.le_of_lt_succ ((Nat.log2_lt hn).mpr this) + · rename_i hgt + have hnext := sparseNext_ok hrow (by omega) + have e : 2 * 2 ^ l = 2 ^ (l + 1) := by rw [Nat.pow_succ]; omega + rw [e] + apply ih _ (l + 1) _ hnext (by simp [hacc]) + · intro i hi + rw [getElem!_def, Array.getElem?_push] + by_cases hil : i ≤ l + · have hne : i ≠ acc.size := by omega + simp only [hne, if_false] + rw [← getElem!_def] + exact hall i hil + · have : i = acc.size := by omega + simp only [this, if_true] + rw [show acc.size = l + 1 by omega] + exact hnext + · have hp := Nat.two_pow_pos l + rw [Nat.pow_succ]; omega + +theorem sparseBuild_ok (adj : Array Nat) : + (∀ i, i < (sparseBuild adj).size → RowOK adj i (sparseBuild adj)[i]!) ∧ + (adj.size ≠ 0 → Nat.log2 adj.size < (sparseBuild adj).size) := by + have h0 : RowOK adj 0 adj := ⟨by simp, fun r hr => by simp [rmin]⟩ + have := sparseLevels_ok adj adj.size adj 0 #[adj] h0 (by simp) + (fun i hi => by have : i = 0 := by omega + subst this; simpa using h0) + (by have := Nat.lt_two_pow_self (n := adj.size); omega) + simpa [sparseBuild] using this + +/-- The sparse-table query is the range minimum. -/ +theorem sparseQuery_eq (adj : Array Nat) {lo hi : Nat} (hlo : lo < hi) (hhi : hi ≤ adj.size) : + sparseQuery (sparseBuild adj) lo hi = rmin (fun i => adj[i]!) lo (hi - lo - 1) := by + obtain ⟨hrows, hlog⟩ := sparseBuild_ok adj + have hlen : hi - lo ≠ 0 := by omega + have hl1 := Nat.log2_self_le hlen + have hl2 := Nat.lt_log2_self (n := hi - lo) + have hlvl : Nat.log2 (hi - lo) < (sparseBuild adj).size := by + have hmono : Nat.log2 (hi - lo) ≤ Nat.log2 adj.size := + (Nat.le_log2 (by omega)).mpr (Nat.le_trans hl1 (by omega)) + exact Nat.lt_of_le_of_lt hmono (hlog (by omega)) + have hrow := hrows _ hlvl + unfold sparseQuery + simp only [Nat.one_shiftLeft] + rw [hrow.2 lo (by omega), hrow.2 (hi - 2 ^ Nat.log2 (hi - lo)) (by omega), + rmin_overlap _ (by omega) (by rw [Nat.pow_succ] at hl2; omega) (by omega)] + congr 1 + omega + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/TierFast.lean b/Ix/Sharing/Exact/TierFast.lean new file mode 100644 index 000000000..0d76d59ec --- /dev/null +++ b/Ix/Sharing/Exact/TierFast.lean @@ -0,0 +1,335 @@ +/- + Fast first-tier search of the tiered construction (phase 2). + + `firstTierFast` computes exactly `firstTier` (`firstTier_eq_fast`, attached + with `@[csimp]`, so compiled callers run it): the same depth-first branch + and bound over the same items in the same order, with the same states + counted and the same errors. Two representation changes: + + * The undecided items are carried as the list `rest` (the suffix of the + items from the current position), so the bound reads it directly instead + of building `items.toList.drop pos` at every state. + * The excluded set is not stored. On every search path each item before the + current position is either chosen (in `inF`) or excluded, and no excluded + term is ever chosen, so a term is excluded exactly when it is an item + before the current position that is not chosen (`tierExcluded`, with the + first position of every item precomputed). This needs every closure to + contain its own term, which `tierClosures` guarantees and which is checked + once (`closuresContainSelf`); otherwise the specification runs. +-/ +module + +public import Ix.Sharing.Exact.Tiered +import all Ix.Sharing.Exact.Tiered +import Std.Data.HashSet.Lemmas +import Std.Data.HashMap.Lemmas + +public section + +namespace Ix.Sharing.Exact + +/-! ## First positions -/ + +/-- First position (offset by `i`) of every term of a list, added to `m` +where `m` has no entry: the first occurrence wins. -/ +def firstPosMap : List Nat → Nat → Std.HashMap Nat Nat → Std.HashMap Nat Nat + | [], _, m => m + | t :: ts, i, m => firstPosMap ts (i + 1) (m.insertIfNew t i) + +/-- Whether the first position of `u` is before `pos`. -/ +@[inline] def posBefore (posMap : Std.HashMap Nat Nat) (pos u : Nat) : Bool := + posMap[u]?.any (· < pos) + +/-- Whether `u` is excluded on a search path at position `pos` with chosen set +`inF`: an item before `pos` that is not chosen. -/ +@[inline] def tierExcluded (posMap : Std.HashMap Nat Nat) (pos : Nat) (inF : List Nat) + (u : Nat) : Bool := + posBefore posMap pos u && !inF.contains u + +/-! ## The search -/ + +/-- `tierDfs` with the undecided items as the list `rest` (starting at +position `pos`) and the excluded set derived from the position +(`tierExcluded`). -/ +def tierDfsFast (posMap : Std.HashMap Nat Nat) (weight : Nat → Nat) + (closure : Nat → Option (List Nat)) (cap : Nat) (limits : Limits) : + Nat → Nat → List Nat → Nat → List Nat → TierState → Except SharingError TierState + | 0, _, _, _, _, _ => throw (.internal "first-tier search fuel exhausted") + | fuel + 1, pos, rest, cur, inF, st => + if st.states + 1 > limits.maxStates then + throw (.resourceExhausted .states limits.maxStates) + else + let st := { st with states := st.states + 1 } + if tierPruned st.best (tierBound weight inF rest (cap - inF.length) cur) then + pure st + else + match rest with + | [] => pure { st with best := tierUpd st.best cur inF } + | t :: ts => + if inF.contains t then + tierDfsFast posMap weight closure cap limits fuel (pos + 1) ts cur inF st + else do + let st ← match closure t with + | some c => + let new := c.filter (!inF.contains ·) + if !c.any (tierExcluded posMap pos inF) && inF.length + new.length ≤ cap then + tierDfsFast posMap weight closure cap limits fuel (pos + 1) ts + (new.foldl (fun acc u => acc + weight u) cur) (inF ++ new) st + else pure st + | none => pure st + tierDfsFast posMap weight closure cap limits fuel (pos + 1) ts cur inF st + +/-- Every computed closure of an item contains the item. -/ +def closuresContainSelf (items : Array Nat) (closure : Nat → Option (List Nat)) : Bool := + items.all fun t => (closure t).all (·.contains t) + +/-- `firstTier` with `tierDfsFast` (see the module doc). -/ +def firstTierFast (topo : Array Nat) (weight : Nat → Nat) (deps : Nat → List Nat) (cap : Nat) + (limits : Limits) : Except SharingError (Array Nat × Nat) := do + let items := (topo.toList.mergeSort (tierOrder weight)).toArray + let cl ← tierClosures topo deps cap + let st ← if closuresContainSelf items (fun t => cl.getD t none) then + tierDfsFast (firstPosMap items.toList 0 {}) weight (fun t => cl.getD t none) cap limits + (items.size + 2) 0 items.toList 0 [] {} + else + tierDfs items weight (fun t => cl.getD t none) cap limits (items.size + 2) 0 0 [] {} {} + match st.best with + | some (_, s) => return ((s.mergeSort (· ≤ ·)).toArray, st.states) + | none => return (#[], st.states) + +/-! ## Equality with the specification -/ + +theorem firstPosMap_getElem? (l : List Nat) (i : Nat) (m : Std.HashMap Nat Nat) (u : Nat) : + (firstPosMap l i m)[u]? = (m[u]?).or ((l.idxOf? u).map (· + i)) := by + induction l generalizing i m with + | nil => simp [firstPosMap] + | cons t ts ih => + simp only [firstPosMap, ih, Std.HashMap.getElem?_insertIfNew, List.idxOf?_cons] + by_cases htu : t = u + · subst htu + by_cases hm : t ∈ m + · obtain ⟨q, hq⟩ := Option.isSome_iff_exists.mp (Std.HashMap.mem_iff_isSome_getElem?.mp hm) + simp [hm] + · have hn : m[t]? = none := Std.HashMap.getElem?_eq_none hm + simp [hm] + · have h1 : (t == u) = false := by simpa using htu + simp only [h1, Bool.false_eq_true, false_and, if_false, Option.map_map] + congr 2 + funext q + simp only [Function.comp] + omega + +/-- The first position of `u` in `l` is before `pos`. -/ +def idxBefore (l : List Nat) (pos u : Nat) : Bool := (l.idxOf? u).any (· < pos) + +theorem posBefore_firstPosMap (l : List Nat) (pos u : Nat) : + posBefore (firstPosMap l 0 {}) pos u = idxBefore l pos u := by + unfold posBefore idxBefore + rw [firstPosMap_getElem?] + simp + +/-- The first position of `u` in `l` is before `pos + 1` exactly when it is +before `pos` or `u` is at `pos`. -/ +theorem idxBefore_succ (l : List Nat) (u : Nat) : + ∀ (pos : Nat) (h : pos < l.length), + idxBefore l (pos + 1) u = (idxBefore l pos u || u == l[pos]) := by + induction l with + | nil => intro pos h; simp at h + | cons a l ih => + intro pos h + unfold idxBefore + rw [List.idxOf?_cons] + by_cases hau : a = u + · subst hau + cases pos with + | zero => simp + | succ p => + simp only [beq_self_eq_true, if_true, Option.any_some] + have : 0 < p + 1 := Nat.zero_lt_succ p + simp [this] + · have h1 : (a == u) = false := by simpa using hau + simp only [h1, Bool.false_eq_true, if_false, Option.any_map] + cases pos with + | zero => + have h2 : (u == a) = false := by + simp only [beq_eq_false_iff_ne, ne_eq] + exact fun h => hau h.symm + cases l.idxOf? u <;> simp [h2] + | succ p => + have hp : p < l.length := by simp at h; omega + have := ih p hp + unfold idxBefore at this + simp only [List.getElem_cons_succ] + have e1 : (fun a => decide (a + 1 < p + 1 + 1)) = (fun x => decide (x < p + 1)) := by + funext x; simp + have e2 : (fun a => decide (a + 1 < p + 1)) = (fun x => decide (x < p)) := by + funext x; simp + rw [e1, e2] + exact this + +theorem posBefore_zero (l : List Nat) (u : Nat) : + posBefore (firstPosMap l 0 {}) 0 u = false := by + rw [posBefore_firstPosMap] + unfold idxBefore + cases l.idxOf? u <;> simp + +theorem posBefore_succ (items : Array Nat) (pos : Nat) (h : pos < items.size) (u : Nat) : + posBefore (firstPosMap items.toList 0 {}) (pos + 1) u = + (posBefore (firstPosMap items.toList 0 {}) pos u || u == items[pos]) := by + rw [posBefore_firstPosMap, posBefore_firstPosMap, + idxBefore_succ items.toList u pos (by simpa using h)] + simp + +/-- The excluded-set invariant of a search node at `pos`. -/ +def ExclInv (posMap : Std.HashMap Nat Nat) (pos : Nat) (inF : List Nat) + (excluded : Std.HashSet Nat) : Prop := + ∀ u, excluded.contains u = tierExcluded posMap pos inF u + +/-- Skipping a chosen item keeps the invariant. -/ +theorem ExclInv.skip {items : Array Nat} {pos : Nat} (hlt : pos < items.size) {inF : List Nat} + {excluded : Std.HashSet Nat} (hinv : ExclInv (firstPosMap items.toList 0 {}) pos inF excluded) + (hin : items[pos] ∈ inF) : + ExclInv (firstPosMap items.toList 0 {}) (pos + 1) inF excluded := by + intro u + rw [hinv u] + unfold tierExcluded + rw [posBefore_succ items pos hlt u] + by_cases hu : u = items[pos] + · subst hu; simp [hin] + · have : (u == items[pos]) = false := by simpa using hu + simp [this] + +/-- Excluding an unchosen item keeps the invariant. -/ +theorem ExclInv.exclude {items : Array Nat} {pos : Nat} (hlt : pos < items.size) + {inF : List Nat} {excluded : Std.HashSet Nat} + (hinv : ExclInv (firstPosMap items.toList 0 {}) pos inF excluded) (hin : items[pos] ∉ inF) : + ExclInv (firstPosMap items.toList 0 {}) (pos + 1) inF (excluded.insert items[pos]) := by + intro u + rw [Std.HashSet.contains_insert, hinv u] + unfold tierExcluded + rw [posBefore_succ items pos hlt u] + by_cases hu : u = items[pos] + · subst hu; simp [hin] + · have h1 : (items[pos] == u) = false := by + simp only [beq_eq_false_iff_ne, ne_eq] + exact fun h => hu h.symm + have h2 : (u == items[pos]) = false := by simpa using hu + simp [h1, h2] + +/-- Choosing the closure of an unchosen item keeps the invariant, when the +closure contains the item and no excluded term. -/ +theorem ExclInv.include {items : Array Nat} {pos : Nat} (hlt : pos < items.size) + {inF c : List Nat} {excluded : Std.HashSet Nat} + (hinv : ExclInv (firstPosMap items.toList 0 {}) pos inF excluded) (hin : items[pos] ∉ inF) + (htc : items[pos] ∈ c) + (hany : c.any (tierExcluded (firstPosMap items.toList 0 {}) pos inF) = false) : + ExclInv (firstPosMap items.toList 0 {}) (pos + 1) (inF ++ c.filter (!inF.contains ·)) + excluded := by + have hnot : ∀ x ∈ c, tierExcluded (firstPosMap items.toList 0 {}) pos inF x = false := by + intro x hx + cases h : tierExcluded (firstPosMap items.toList 0 {}) pos inF x + · rfl + · have : c.any (tierExcluded (firstPosMap items.toList 0 {}) pos inF) = true := + List.any_eq_true.mpr ⟨x, hx, h⟩ + rw [hany] at this + cases this + intro u + rw [hinv u] + by_cases hu : u = items[pos] + · subst hu + rw [hnot _ htc] + unfold tierExcluded + simp [hin, htc] + · unfold tierExcluded + rw [posBefore_succ items pos hlt u] + have h2 : (u == items[pos]) = false := by simpa using hu + simp only [h2, Bool.or_false] + cases hb : posBefore (firstPosMap items.toList 0 {}) pos u + · simp + · by_cases hi : u ∈ inF + · simp [hi] + · have huc : u ∉ c := by + intro huc + have := hnot u huc + simp [tierExcluded, hb, hi] at this + simp [hi, huc] + +theorem tierDfs_eq_fast (items : Array Nat) (weight : Nat → Nat) + (closure : Nat → Option (List Nat)) (cap : Nat) (limits : Limits) + (hself : closuresContainSelf items closure = true) : + ∀ (fuel pos cur : Nat) (inF : List Nat) (excluded : Std.HashSet Nat) (st : TierState), + ExclInv (firstPosMap items.toList 0 {}) pos inF excluded → + tierDfs items weight closure cap limits fuel pos cur inF excluded st = + tierDfsFast (firstPosMap items.toList 0 {}) weight closure cap limits fuel pos + (items.toList.drop pos) cur inF st := by + intro fuel + induction fuel with + | zero => intro pos cur inF excluded st _; simp [tierDfs, tierDfsFast] + | succ fuel ih => + intro pos cur inF excluded st hinv + simp only [tierDfs, tierDfsFast] + split + · rfl + · split + · rfl + · by_cases hpos : pos ≥ items.size + · have hd : items.toList.drop pos = [] := by simp; omega + simp only [hpos, if_true, hd] + · have hlt : pos < items.size := by omega + have hd : items.toList.drop pos = items[pos] :: items.toList.drop (pos + 1) := by + rw [List.drop_eq_getElem_cons (by simpa using hlt)] + simp + simp only [hpos, if_false, hd, getElem!_pos items pos hlt] + by_cases hin : items[pos] ∈ inF + · have hc : inF.contains items[pos] = true := by simpa using hin + simp only [hc, if_true] + exact ih _ _ _ _ _ (hinv.skip hlt hin) + · have hc : inF.contains items[pos] = false := by simpa using hin + simp only [hc, Bool.false_eq_true, if_false] + have hfun : excluded.contains = tierExcluded (firstPosMap items.toList 0 {}) pos inF := + funext hinv + have hex := hinv.exclude hlt hin + cases hcl : closure items[pos] with + | none => + simp only [pure_bind] + exact ih _ _ _ _ _ hex + | some c => + simp only + rw [hfun] + split + · rename_i hcond + have hany : c.any (tierExcluded (firstPosMap items.toList 0 {}) pos inF) = false := by + simp only [Bool.and_eq_true, Bool.not_eq_true'] at hcond + exact hcond.1 + have htc : items[pos] ∈ c := by + have hall := Array.all_eq_true.mp hself pos hlt + simp only [hcl, Option.all_some] at hall + simpa using hall + rw [ih _ _ _ _ _ (hinv.include hlt hin htc hany)] + congr 1 + funext st' + exact ih _ _ _ _ _ hex + · simp only [pure_bind] + exact ih _ _ _ _ _ hex + +theorem firstTier_eq_fast_apply (topo : Array Nat) (weight : Nat → Nat) (deps : Nat → List Nat) + (cap : Nat) (limits : Limits) : + firstTier topo weight deps cap limits = firstTierFast topo weight deps cap limits := by + unfold firstTier firstTierFast + simp only + refine congrArg (fun f => tierClosures topo deps cap >>= f) (funext fun cl => ?_) + split + · rename_i hself + rw [tierDfs_eq_fast _ weight _ cap limits hself _ 0 0 [] {} {} + (fun u => by simp [tierExcluded, posBefore_zero])] + simp only [List.drop_zero] + rfl + · rfl + +@[csimp] theorem firstTier_eq_fast : @firstTier = @firstTierFast := by + funext topo weight deps cap limits + exact firstTier_eq_fast_apply topo weight deps cap limits + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/Tiered.lean b/Ix/Sharing/Exact/Tiered.lean new file mode 100644 index 000000000..ab5af4ff2 --- /dev/null +++ b/Ix/Sharing/Exact/Tiered.lean @@ -0,0 +1,535 @@ +/- + Tiered canonical sharing: uniform-width selection, slot allocation, and + re-materialization under a Share layout `widthAt : index → width`. + + Layout (`ShareLayout.widthAt`, monotone, at least 1): the single layout + `tagN` is the wire Share code (`putTagN 4 0xB idx`), whose widths climb in + rungs of 1, 2, 3, 4, 5 and 9 bytes (`tagNWidth`, which also documents the bit + layout). The output is written with the wire codec; `modelBytes` is the + layout price, and the two agree for the wire layout (`ShareLayout.wire`), + which is checked. + + ## Width selection + Phase 1 runs at each uniform width `w ∈ {1, 2, 3}`, each result is carried + through phases 2 and 3, and the construction returns the candidate with + the fewest real layout bytes (the phase-3 length priced by the layout); + ties go to the lower `w` (then `setPrec` on the stored set). Each + candidate is exact per phase as described below; the final choice is the + real-byte minimum over the three candidates, not a global optimum over + all tables and orders. (Choosing `w` from the candidate count alone + overestimates the widths: the optimum stores far fewer terms than there + are candidates.) `tieredAtWidth` is the candidate at one width. + + Proved (`Ix/Compile/Verify/Tiered*.lean` and, for phase 1, + `UniformOptimality.lean`; no `sorry`): the width selection + (`canonicalTieredCore_select`), phase 1 (`optimizeUniform_least`, for the + default branch-and-bound search), the first tier, backwardness and the + 2-byte-tier optimality of phase 2 + (`firstTier_spec`, `allocate_spec`, `allocate_optimal`), the per-part + minimality, expansion and length bound of phase 3 + (`materializeTable_min`, `rematerialize_spec`, `phase3_le_phase1`), and the + determinism, round trip and format domain of the output + (`canonicalTiered_det`, `canonicalTiered_reexpand`, `canonicalTiered_format`). + The composition is not claimed to be a global byte minimum. + + ## Phase 1: selection (exact for the uniform model) + `S` and its bodies are `optimizeSharingUniform w`: a minimum of the + uniform-`w` model length (exact, with the pinned tie order). + + ## Phase 2: slot allocation + From the phase-1 output: `ref(t)` = the number of `Share(t)` in the phase-1 + entries and roots; `t` depends on `u` when `t`'s phase-1 body contains + `Share(u)`. + * First tier (exact): `F` is a maximum-`ref` set of at most 8 stored terms + closed under dependencies, so `F` can occupy indices `0..|F|-1`. Ties: + order the stored terms by (`ref` descending, ID ascending); among + maximum sets the one that, at the first term in this order where two + sets differ, contains it. Found by branch and bound with the bound + "current weight + the largest remaining weights that still fit". + * Remaining entries (pinned, not optimized): `F` in the pinned priority + order (stored descendants first, larger in-degree, smaller ID), then the + rest in the Kahn priority order (`kahnOrder`): repeatedly the available + entry (every entry its phase-1 body references already placed) with the + largest `ref`, ties by the smaller ID. + * Guard: if this order's reference cost `Σ ref(t)·widthAt(index t)` is + larger than the phase-1 order's, the phase-1 order is kept. + Optimality (`allocate_optimal`): with the `ref` counts fixed, the + allocation minimizes `Σ ref·widthAt` over all orders respecting the + dependencies whenever all entries beyond the first tier share one width + (`|S| ≤ tier2End`), since then that sum is `2·Σref − Σ_{first 8} ref`. + Beyond that only the first tier is optimized. + + ## Phase 3: re-materialization (exact per part) + Every entry is re-encoded with `C_M` under the entries before it, priced + by their real widths `widthAt(index)`, and the roots under all entries + (so an occurrence may now inline instead of referencing). Each part is a + minimum for its dictionary, with the byte-least tie-break. The phase-1 + bodies are valid in the allocated order (dependencies come first), so + the result is no longer than the phase-1 bodies in this order, which by + the guard is no longer than the phase-1 output priced by the layout + (`phase3_le_phase1`). This is also checked at run time, the output is + re-expanded, and every output expression is checked to be in the wire + domain, where its layout length is its serialized length (proved: + `Ix.Compile.Verify.Tiered.canonicalSharingTiered_serialized`). + + The construction is a function of the expanded AST and the layout, so + normalizing its output reproduces it. +-/ +module + +public import Ix.Sharing.Exact.Uniform + +public section + +namespace Ix.Sharing.Exact + +open Ixon + +/-! ## TagN Share code + +A Share is the `f = 4` instance of the Ixon TagN integer code +(`Ixon.putTagN 4`, see `Ix/Ixon.lean`): one header byte +`[flag:4][L][M][c1][c0]` (flag `0xB`) followed by 0, 1, 2, 3, 4 or 8 +little-endian bytes. The low nibble selects a rung: + +* `L = 0`: no following byte; the 3 bits `M c1 c0` are the index, `0..7`. +* `L = 1, M = 0`: 1 following byte; `value = c1 c0 · 2^8 + byte` (10 bits) + and `index = 8 + value`, so indices `8 .. 8 + 2^10 - 1`. +* `L = 1, M = 1, c = c1 c0 ∈ {0, 1, 2, 3}`: `2`, `3`, `4` or `8` following + bytes holding `value`, and `index = (end of the previous rung) + value`. + Every code is valid. + +Every rung starts where the previous one ends, so each index has exactly +one encoding and every valid encoding is the encoding of its index (the code +is bijective). Rung ends: `8`, `8 + 2^10`, `+ 2^16`, `+ 2^24`, `+ 2^32`, +`+ 2^64`; byte widths: 1, 2, 3, 4, 5, 9. The rung ends and `tagNWidth` below are by definition +`Ixon.tagNEnd* 4` and `Ixon.tagNByteWidth 4`, the single width-by-index +function for this code. -/ + +/-- End (exclusive) of the 1-byte rung. -/ +def tagNRung1End : Nat := Ixon.tagNEnd1 4 +/-- End of the 2-byte rung (2 + 8 value bits). -/ +def tagNRung2End : Nat := Ixon.tagNEnd2 4 +/-- End of the 3-byte rung (2 following bytes). -/ +def tagNRung3End : Nat := Ixon.tagNEnd3 4 +/-- End of the 4-byte rung (3 following bytes). -/ +def tagNRung4End : Nat := Ixon.tagNEnd4 4 +/-- End of the 5-byte rung (4 following bytes). -/ +def tagNRung5End : Nat := Ixon.tagNEnd5 4 +/-- End of the 9-byte rung (8 following bytes); larger indices have no +encoding. -/ +def tagNRung6End : Nat := Ixon.tagNEnd6 4 + +/-- Byte width of the TagN Share at index `i` (`i < tagNRung6End`; +larger indices are not encodable and are priced at the top rung). -/ +def tagNWidth (i : Nat) : Nat := Ixon.tagNByteWidth 4 i + +/-! ## Layouts -/ + +/-- A Share width layout. TagN is the only Share code, so this is the only +layout; the type is kept so that layouts stay explicit in the API (and match +the Rust `ShareLayout::TagN`). -/ +inductive ShareLayout where + /-- The TagN Share code (`tagNWidth`). -/ + | tagN + deriving BEq, Repr, Inhabited + +/-- The layout of the wire Share code. -/ +def ShareLayout.wire : ShareLayout := .tagN + +/-- Width of the Share at table index `i`. -/ +def ShareLayout.widthAt : ShareLayout → Nat → Nat + | .tagN, i => tagNWidth i + +/-- First index whose width exceeds 2. -/ +def ShareLayout.tier2End : ShareLayout → Nat + | .tagN => tagNRung2End + +/-- Variable length of an encoding with Shares priced by the layout. -/ +def layoutBytes (l : ShareLayout) (sharing roots : Array Ixon.Expr) : Nat := + let size := fun e => (sizeInfoWith l.widthAt e).full + tag0Size sharing.size + sharing.foldl (fun acc e => acc + size e) 0 + + roots.foldl (fun acc e => acc + size e) 0 + +/-! ## Share references of an encoding -/ + +/-- All `Share` indices in an expression, with multiplicity. -/ +def shareIndices : Ixon.Expr → Array Nat → Array Nat + | .share i, acc => acc.push i.toNat + | .prj _ _ v, acc => shareIndices v acc + | .app f a, acc => shareIndices a (shareIndices f acc) + | .lam _ t b, acc => shareIndices b (shareIndices t acc) + | .all _ _ t b, acc => shareIndices b (shareIndices t acc) + | .letE _ t v b, acc => shareIndices b (shareIndices v (shareIndices t acc)) + | _, acc => acc + +/-! ## First-tier allocation -/ + +/-- Fail with an internal error unless `b` holds. -/ +def checkInternal (b : Bool) (msg : String) : Except SharingError Unit := + if b then pure () else throw (.internal msg) + +/-- Add the closure of `d` to a partial closure (`none` once above `cap`). -/ +def tierClosureUnion (cap : Nat) (cl : Std.HashMap Nat (Option (List Nat))) + (acc : Option (List Nat)) (d : Nat) : Option (List Nat) := + match acc, cl.getD d none with + | some a, some c => + let u := c.foldl (fun a x => a.insert x) a + if u.length ≤ cap then some u else none + | _, _ => none + +/-- The first-tier closures, in an order `topo` where every term's +dependencies come before it: the closure of `t` is `t` with the closures of +its dependencies, or `none` when it has more than `cap` terms. A dependency +that is not yet closed, or a repeated term, is an internal error. -/ +def tierClosures (topo : Array Nat) (deps : Nat → List Nat) (cap : Nat) : + Except SharingError (Std.HashMap Nat (Option (List Nat))) := + topo.foldlM (init := {}) fun cl t => do + checkInternal (!cl.contains t) "a stored term repeats in the phase-1 table" + checkInternal ((deps t).all cl.contains) "a phase-1 body references a later entry" + let acc := (deps t).foldl (tierClosureUnion cap cl) (some [t]) + return cl.insert t (acc.bind fun a => if a.length ≤ cap then some a else none) + +/-- Bound of the first-tier search: `acc` plus the largest `room` weights +among `rest` outside `inF` (`rest` is in decreasing weight). -/ +def tierBound (weight : Nat → Nat) (inF : List Nat) : List Nat → Nat → Nat → Nat + | [], _, acc => acc + | t :: ts, room, acc => + if room = 0 then acc + else if inF.contains t then tierBound weight inF ts room acc + else tierBound weight inF ts (room - 1) (acc + weight t) + +/-- First-tier search state: the best set with its weight, and the states +visited. -/ +structure TierState where + best : Option (Nat × List Nat) := none + states : Nat := 0 + deriving Inhabited + +/-- Whether a subtree with bound `bound` is pruned: some set of weight at +least `bound` is already found. -/ +def tierPruned (best : Option (Nat × List Nat)) (bound : Nat) : Bool := + match best with + | some (b, _) => bound ≤ b + | none => false + +/-- Keep the best set: `inF` (of weight `cur`) replaces it only if heavier. -/ +def tierUpd (best : Option (Nat × List Nat)) (cur : Nat) (inF : List Nat) : + Option (Nat × List Nat) := + match best with + | some (b, _) => if cur > b then some (cur, inF) else best + | none => some (cur, inF) + +/-- Depth-first branch and bound over `items` (in the search order), deciding +`items[pos]`: "include" (its closure joins `inF`, if no excluded term is in +it and it fits) before "exclude". `cur` is the weight of `inF`. The first +maximum found is the tie-break winner, so a subtree is pruned when its +bound does not exceed the best weight. -/ +def tierDfs (items : Array Nat) (weight : Nat → Nat) (closure : Nat → Option (List Nat)) + (cap : Nat) (limits : Limits) : + Nat → Nat → Nat → List Nat → Std.HashSet Nat → TierState → + Except SharingError TierState + | 0, _, _, _, _, _ => throw (.internal "first-tier search fuel exhausted") + | fuel + 1, pos, cur, inF, excluded, st => + if st.states + 1 > limits.maxStates then + throw (.resourceExhausted .states limits.maxStates) + else + let st := { st with states := st.states + 1 } + if tierPruned st.best + (tierBound weight inF (items.toList.drop pos) (cap - inF.length) cur) then + pure st + else if pos ≥ items.size then + pure { st with best := tierUpd st.best cur inF } + else + let t := items[pos]! + if inF.contains t then + tierDfs items weight closure cap limits fuel (pos + 1) cur inF excluded st + else do + let st ← match closure t with + | some c => + let new := c.filter (!inF.contains ·) + if !c.any excluded.contains && inF.length + new.length ≤ cap then + tierDfs items weight closure cap limits fuel (pos + 1) + (new.foldl (fun acc u => acc + weight u) cur) (inF ++ new) excluded st + else pure st + | none => pure st + tierDfs items weight closure cap limits fuel (pos + 1) cur inF (excluded.insert t) st + +/-- The first-tier search order: weight descending, then ID ascending. -/ +def tierOrder (weight : Nat → Nat) (a b : Nat) : Bool := + weight a > weight b || (weight a == weight b && a ≤ b) + +/-- Maximum-weight set of at most `cap` stored terms closed under `deps` +(tie order as in the module doc). The stored terms are given in an order +`topo` with every term's dependencies before it. Returns the set +(ascending) and the states visited. -/ +def firstTier (topo : Array Nat) (weight : Nat → Nat) (deps : Nat → List Nat) (cap : Nat) + (limits : Limits) : Except SharingError (Array Nat × Nat) := do + let items := (topo.toList.mergeSort (tierOrder weight)).toArray + let cl ← tierClosures topo deps cap + let st ← tierDfs items weight (fun t => cl.getD t none) cap limits (items.size + 2) 0 0 [] + {} {} + match st.best with + | some (_, s) => return ((s.mergeSort (· ≤ ·)).toArray, st.states) + | none => return (#[], st.states) + +/-! ## Phase 2: slot allocation -/ + +/-- Reference counts by phase-1 index: the `Share(i)` (`i < m`) in `exprs`. -/ +def shareCounts (m : Nat) (exprs : Array Ixon.Expr) : Array Nat := + exprs.foldl (fun refs e => (shareIndices e #[]).foldl + (fun refs i => if i < refs.size then refs.modify i (· + 1) else refs) refs) + (Array.replicate m 0) + +/-- The terms a phase-1 body references: `order1[i]` for every `Share(i)`. -/ +def bodyRefs (order1 : Array Nat) (e : Ixon.Expr) : List Nat := + ((shareIndices e #[]).filterMap (order1[·]?)).toList + +/-- Reference count of every stored term: its Shares in the phase-1 entries +and roots. -/ +def tierWeights (order1 : Array Nat) (entries1 roots1 : Array Ixon.Expr) : + Std.HashMap Nat Nat := + let refs := shareCounts order1.size (entries1 ++ roots1) + (List.range order1.size).foldl (fun m i => m.insert order1[i]! refs[i]!) {} + +/-- The stored terms each phase-1 body references. -/ +def tierDeps (order1 : Array Nat) (entries1 : Array Ixon.Expr) : + Std.HashMap Nat (List Nat) := + (List.range order1.size).foldl + (fun m i => m.insert order1[i]! (bodyRefs order1 (entries1[i]?.getD default))) {} + +/-- Whether every term's dependencies come before it in `order`. -/ +def respectsDeps (order : Array Nat) (deps : Nat → List Nat) : Bool := + let pos : Std.HashMap Nat Nat := order.zipIdx.foldl (fun m (t, i) => m.insert t i) {} + order.zipIdx.all fun (t, i) => (deps t).all fun d => (pos.get? d).any (· < i) + +/-- The Kahn priority order of `rest`: repeatedly place the available term +(every dependency of it in `rest` already placed) of the largest weight, +ties by the smaller ID (`tierOrder`). Terms left over, which acyclic +dependencies never leave, follow in priority order. -/ +def kahnOrder (weight : Nat → Nat) (deps : Nat → List Nat) (rest : Array Nat) : Array Nat := + Id.run do + -- Ranks in priority order; the ready set is kept by rank. + let sorted := (rest.toList.mergeSort (tierOrder weight)).toArray + let m := sorted.size + let rank : Std.HashMap Nat Nat := sorted.zipIdx.foldl (fun r (t, i) => r.insert t i) {} + let mut pend : Array Nat := Array.replicate m 0 + let mut users : Array (Array Nat) := Array.replicate m #[] + for h : i in [0:m] do + let ds := ((deps sorted[i]).filterMap rank.get?).eraseDups + pend := pend.set! i ds.length + for d in ds do + users := users.modify d (·.push i) + let mut ready : Std.TreeSet Nat := + Std.TreeSet.ofList ((List.range m).filter (pend[·]! == 0)) + let mut placed : Array Bool := Array.replicate m false + let mut out : Array Nat := #[] + for _ in [0:m] do + match ready.min? with + | none => break + | some r => + ready := ready.erase r + placed := placed.set! r true + out := out.push sorted[r]! + for u in users[r]! do + pend := pend.modify u (· - 1) + if pend[u]! == 0 then ready := ready.insert u + for h : i in [0:m] do + if !placed[i]! then out := out.push sorted[i] + return out + +/-- Reference cost `Σ weight(t) · widthAt(index t)` of a table order. -/ +def refCost (layout : ShareLayout) (weight : Nat → Nat) (order : Array Nat) : Nat := + order.zipIdx.foldl (fun acc (t, i) => acc + weight t * layout.widthAt i) 0 + +/-- The slot allocation of phase 2. -/ +structure Allocation where + /-- The first tier (ascending). -/ + tier : Array Nat + slotStates : Nat + /-- The final table order. -/ + order : Array Nat + /-- The guard kept the phase-1 order. -/ + kept : Bool + /-- Reference cost of the phase-1 order and of the final order. -/ + refCost1 : Nat + refCostFinal : Nat + deriving Inhabited + +/-- Phase 2 on the phase-1 table `order1` with entries `entries1` and roots +`roots1`: the first tier, then the pinned order, unless the guard keeps the +phase-1 order. The final order is checked to place every body reference +before its user, and the pinned order to be a permutation of the phase-1 +table. -/ +def allocate (layout : ShareLayout) (limits : Limits) (dag : Dag) (deg : Array Nat) + (order1 : Array Nat) (entries1 roots1 : Array Ixon.Expr) : + Except SharingError Allocation := do + let wm := tierWeights order1 entries1 roots1 + let dm := tierDeps order1 entries1 + let weight := fun t => wm.getD t 0 + let deps := fun t => dm.getD t [] + let stored := (order1.toList.mergeSort (· ≤ ·)).toArray + let (tier, slotStates) ← firstTier order1 weight deps (min 8 order1.size) limits + let rest := stored.filter (!tier.contains ·) + let order2 := pinnedOrder dag deg tier ++ kahnOrder weight deps rest + checkInternal ((order2.toList.mergeSort (· ≤ ·)).toArray == stored) + "the allocated order is not a permutation of the phase-1 table" + let kept : Bool := refCost layout weight order2 > refCost layout weight order1 + let order := if kept then order1 else order2 + checkInternal (respectsDeps order deps) "the allocated order places a body reference after its user" + return { tier, slotStates, order, kept, refCost1 := refCost layout weight order1, + refCostFinal := refCost layout weight order } + +/-! ## Result -/ + +/-- Statistics of the tiered construction. -/ +structure TieredStats where + layout : ShareLayout + /-- Terms with in-degree ≥ 2 and unshared length ≥ 2. -/ + candidateCount : Nat + /-- Phase-1 uniform width of the returned candidate (the winning width). -/ + w : Nat + /-- Final layout length of every candidate run, as `(w, bytes)` in + increasing `w` (one entry for a single candidate, `tieredAtWidth`). -/ + candidateLengths : Array (Nat × Nat) := #[] + /-- Phase-1 uniform-model length. -/ + phase1ModelBytes : Nat + /-- Phase-1 output priced by the layout (its own order). -/ + phase1LayoutBytes : Nat + /-- First-tier search states. -/ + slotStates : Nat + firstTier : Array Nat + /-- The guard kept the phase-1 order. -/ + keptPhase1Order : Bool + /-- Reference cost `Σ ref·widthAt` of the phase-1 and the final order. -/ + phase1RefCost : Nat + finalRefCost : Nat + /-- Final length priced by the layout. -/ + phase3LayoutBytes : Nat + /-- `phase1LayoutBytes - phase3LayoutBytes`. -/ + savings : Nat + deriving Repr, Inhabited + +/-- Tiered result: the usual result (`modelBytes` = layout price, +`variableBytes` = serialized length), the phase-1 +result, statistics. -/ +structure TieredSharingResult where + result : ExactSharingResult + phase1 : UniformSharingResult + stats : TieredStats + deriving Inhabited + +/-- Phase-3 output of one candidate. -/ +structure Rematerialized where + entries : Array Ixon.Expr + roots : Array Ixon.Expr + /-- Length priced by the layout. -/ + bytes : Nat + work : Nat + /-- The layout length of the output (`bytes`). For the wire layout it is the + serialized length (`Ix.Compile.Verify.Tiered.canonicalSharingTiered_serialized`). -/ + measured : Nat + deriving Inhabited + +/-- Phase 3: re-materialize the table `order` and the roots under the real +widths, and check the output. The table is materialized from one evaluation +of the whole dictionary when its order allows it (`materializeTableOnePass`, +equal to `materializeTable`: `Ix.Compile.Verify.Tiered.materializeTableOnePass_eq`). +The run-time checks, each failing closed with an internal error: the layout +length of the output is the evaluated length, it is at most the phase-1 +layout length, the output re-expands to the stored terms and the input +roots, and every output expression is in the wire domain. On the wire domain +the TagN layout length is the length the wire codec writes, so the length +recorded (`bytes`, `measured`) is the serialized length for the wire layout +(`Ix.Compile.Verify.Tiered.canonicalSharingTiered_serialized`). -/ +def rematerialize (layout : ShareLayout) (limits : Limits) (ex : Expanded) (order : Array Nat) + (phase1Layout : Nat) : Except SharingError Rematerialized := do + let (entries, roots, predicted, work) ← + materializeTableOnePass (Prep.ofDag ex.dag) order ex.roots limits layout.widthAt + let priced := layoutBytes layout entries roots + checkInternal (priced == predicted) + s!"layout length {priced} differs from the evaluation {predicted}" + checkInternal (predicted ≤ phase1Layout) + s!"re-materialization {predicted} is longer than phase 1 {phase1Layout}" + let (entryIds, rootIds, _) ← reexpand limits ex.dag entries roots + checkInternal (entryIds == order) "re-materialized entries do not expand to the stored terms" + checkInternal (rootIds == ex.roots) "re-materialized roots do not expand to the input roots" + checkInternal ((entries ++ roots).all fun e => (wireCounts e).isSome) + "a re-materialized expression has a count outside the wire domain" + return { entries, roots, bytes := predicted, work, measured := priced } + +/-- Assemble one candidate from its three phases. -/ +def tieredResult (layout : ShareLayout) (ex : Expanded) (w : Nat) (u : UniformSharingResult) + (a : Allocation) (m : Rematerialized) : TieredSharingResult := + let p := Prep.ofDag ex.dag + let f := graphFacts ex.dag ex.roots + let k := ((Array.range ex.dag.size).filter fun t => f.deg[t]! ≥ 2 && p.base[t]! ≥ 2).size + let phase1Layout := layoutBytes layout u.result.sharing u.result.roots + let stats : TieredStats := + { layout := layout, candidateCount := k, w := w, + candidateLengths := #[(w, m.bytes)], phase1ModelBytes := u.result.modelBytes, + phase1LayoutBytes := phase1Layout, slotStates := a.slotStates, firstTier := a.tier, + keptPhase1Order := a.kept, phase1RefCost := a.refCost1, finalRefCost := a.refCostFinal, + phase3LayoutBytes := m.bytes, savings := phase1Layout - m.bytes } + let rstats : Stats := + { u.result.stats with materializedNodes := m.work, outputBytes := m.measured } + let res : ExactSharingResult := + { u.result with + roots := m.roots, sharing := m.entries, tableTerms := a.order, + variableBytes := m.measured, modelBytes := m.bytes, stats := rstats } + { result := res, phase1 := u, stats := stats } + +/-- One candidate of the tiered construction: phases 1–3 with phase-1 +uniform width `w`. -/ +def tieredAtWidth (layout : ShareLayout) (limits : Limits) (ex : Expanded) (w : Nat) : + Except SharingError TieredSharingResult := do + let u ← optimizeUniformExpanded w limits ex + let a ← allocate layout limits ex.dag (graphFacts ex.dag ex.roots).deg u.result.tableTerms + u.result.sharing u.result.roots + let m ← rematerialize layout limits ex a.order + (layoutBytes layout u.result.sharing u.result.roots) + return tieredResult layout ex w u a m + +/-- Whether candidate `a` beats `b`: fewer final layout bytes, then the +lower width, then `setPrec` on the stored set. -/ +def tieredBetter (a b : TieredSharingResult) : Bool := + a.stats.phase3LayoutBytes < b.stats.phase3LayoutBytes || + (a.stats.phase3LayoutBytes == b.stats.phase3LayoutBytes && + (a.stats.w < b.stats.w || + (a.stats.w == b.stats.w && setPrec a.phase1.stored b.phase1.stored))) + +/-- The tiered construction on the canonical DAG `dag` and root IDs +`roots` alone: the candidate with the fewest final layout bytes over the +phase-1 widths 1, 2 and 3 (module doc). -/ +def canonicalTieredCore (layout : ShareLayout) (limits : Limits) (dag : Dag) + (roots : Array Nat) : Except SharingError TieredSharingResult := + let ex : Expanded := { dag, roots, visits := 0, internedNodes := 0 } + do + let c1 ← tieredAtWidth layout limits ex 1 + let c2 ← tieredAtWidth layout limits ex 2 + let c3 ← tieredAtWidth layout limits ex 3 + let best := #[c2, c3].foldl (fun b c => if tieredBetter c b then c else b) c1 + let lengths := #[c1, c2, c3].map fun c => (c.stats.w, c.stats.phase3LayoutBytes) + return { best with stats := { best.stats with candidateLengths := lengths } } + +/-- Record the expansion statistics of `ex` in a result. -/ +def withExpansionStats (ex : Expanded) (r : TieredSharingResult) : TieredSharingResult := + { r with + result := { r.result with + stats := { r.result.stats with exprVisits := ex.visits, internedNodes := ex.internedNodes } } + phase1 := { r.phase1 with + result := { r.phase1.result with + stats := { r.phase1.result.stats with + exprVisits := ex.visits, internedNodes := ex.internedNodes } } } } + +/-- The tiered canonical construction on an expanded input: a function of +its DAG and root IDs (`canonicalTieredCore`), with the expansion statistics +recorded. -/ +def canonicalTieredExpanded (layout : ShareLayout) (limits : Limits) (ex : Expanded) : + Except SharingError TieredSharingResult := do + let r ← canonicalTieredCore layout limits ex.dag ex.roots + return withExpansionStats ex r + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/TieredFast.lean b/Ix/Sharing/Exact/TieredFast.lean new file mode 100644 index 000000000..9ecf6a521 --- /dev/null +++ b/Ix/Sharing/Exact/TieredFast.lean @@ -0,0 +1,399 @@ +/- + The compiled tiered construction. + + `@[csimp]` replaces a call only in code compiled after the replacement + theorem, so the fast parts proved equal in the modules this one imports + (`Exact.TierFast` for `firstTier`, `Exact.PinnedFast` for `pinnedOrder`, + `Exact.KnapsackFast` for `uniformKnapsack`) do not reach `allocate`, + `tieredAtWidth`, `canonicalTieredCore`, `canonicalTieredExpanded` and + `optimizeUniformExpanded`, which `Exact.Tiered` and `Exact.Uniform` + compiled earlier. This module compiles each of them again and attaches the + copy with `@[csimp]`, so every caller compiled after it (`Ix.Sharing.Exact` + and everything that imports it, including the compiler) runs the fast + parts. The copies also compute the width-independent tables (`Prep.ofDag`, + `graphFacts`, the DAG checks and the candidate count) once per constant + instead of once per width and phase; each copy is the specification's + body with those tables passed in, and each equality is proved by unfolding. + For a DAG of at least `tieredParMin` terms the three candidates run as + parallel tasks and are combined in width order, which is the same value + (`tieredCandidates_eq`); only the latency of a large constant changes. +-/ +module + +public import Ix.Sharing.Exact.TierFast +public import Ix.Sharing.Exact.PinnedFast +public import Ix.Sharing.Exact.KnapsackFast +import all Ix.Sharing.Exact.Tiered +import all Ix.Sharing.Exact.Uniform +import all Ix.Sharing.Exact.UniformSearch + +public section + +namespace Ix.Sharing.Exact + +/-- `allocate`, compiled with the fast first tier. -/ +def allocateC (layout : ShareLayout) (limits : Limits) (dag : Dag) (deg : Array Nat) + (order1 : Array Nat) (entries1 roots1 : Array Ixon.Expr) : + Except SharingError Allocation := do + let wm := tierWeights order1 entries1 roots1 + let dm := tierDeps order1 entries1 + let weight := fun t => wm.getD t 0 + let deps := fun t => dm.getD t [] + let stored := (order1.toList.mergeSort (· ≤ ·)).toArray + let (tier, slotStates) ← firstTier order1 weight deps (min 8 order1.size) limits + let rest := stored.filter (!tier.contains ·) + let order2 := pinnedOrder dag deg tier ++ kahnOrder weight deps rest + checkInternal ((order2.toList.mergeSort (· ≤ ·)).toArray == stored) + "the allocated order is not a permutation of the phase-1 table" + let kept : Bool := refCost layout weight order2 > refCost layout weight order1 + let order := if kept then order1 else order2 + checkInternal (respectsDeps order deps) "the allocated order places a body reference after its user" + return { tier, slotStates, order, kept, refCost1 := refCost layout weight order1, + refCostFinal := refCost layout weight order } + +@[csimp] theorem allocate_eq_C : @allocate = @allocateC := by + funext layout limits dag deg order1 entries1 roots1 + unfold allocate allocateC + rfl + +/-! ## Width-independent tables, computed once per constant + +The three candidates of `canonicalTieredCore` run phases 1-3 on the same +DAG. `Prep.ofDag`, `graphFacts`, the DAG checks of `optimizeUniformExpanded` +and the candidate count of `tieredResult` do not depend on the width; the +copies below take them as arguments, and `canonicalTieredCoreC` computes +them once. Each copy is the specification's body with the table passed in +(the equalities are definitional, plus the order of the checks). -/ + +/-- The DAG checks of `optimizeUniformExpanded` that come before +`Prep.ofDag`. -/ +def uniformDagChecks (ex : Expanded) : Except SharingError Unit := do + unless childrenPrecede ex.dag.nodes do + throw (.internal "DAG children do not precede their parents") + unless ex.dag.nodes.all (fun node => node.children.size == node.head.arity) do + throw (.internal "DAG node arity") + unless ex.roots.all (· < ex.dag.size) do + throw (.internal "root ID out of range") + unless (reachMarks ex.dag.nodes ex.roots).all id do + throw (.internal "DAG term unreachable from the roots") + +/-- The telescope-spine check of `optimizeUniformExpanded`. -/ +def uniformSpineCheck (ex : Expanded) (p : Prep) : Except SharingError Unit := do + unless (List.range ex.dag.size).all (fun t => p.spineLen[t]! < teleSubaddEnd) do + throw (.formatBound "telescope spine length" teleSubaddEnd) + +/-- `uniformStage` with the graph facts `f` passed in. -/ +def uniformStageF (w : Nat) (ex : Expanded) (p : Prep) (f : GraphFacts) : UStage := + let n := ex.dag.size + let cand := searchCandidates p f w + let b0 := uniformBounds p w cand + let vis0 := visibleCounts ex.dag ex.roots cand + let nCand := (cand.filter id).size + let thetaMax : _root_.Int := tag0StepBound nCand + 1 + let clsMax := classifyWith p f w b0 vis0 thetaMax + let nCsMax := (clsMax.filter (· == .certainStored)).size + let theta : _root_.Int := if tag0Size nCand == tag0Size nCsMax then 1 else thetaMax + let cls := if theta == 1 then classifyWith p f w b0 vis0 1 else clsMax + let pick (c : UClass) := (Array.range n).filter (cls[·]! == c) + let cs := pick .certainStored + let unc := pick .uncertain + let opaq := cs.foldl (fun acc t => acc.set! t true) (Array.replicate n false) + let widthCs : Array (Option Nat) := + cs.foldl (fun acc t => acc.set! t (some w)) (Array.replicate n none) + let allTrue := Array.replicate n true + { f, cand, b0, vis0, theta, cls, cs, ce := pick .certainExcluded, unc, + low := pick .lowDegree, opaq, up := UPrep.mk' p w opaq, widthCs, allTrue, + baseEv := p.eval widthCs allTrue, comps := uncertainComponents ex.dag cls, + slack := tag0Size (cs.size + unc.size) - tag0Size cs.size, + rootCount := ex.roots.foldl (fun acc r => acc.modify r (· + 1)) (Array.replicate n 0) } + +theorem uniformStage_eq_F (w : Nat) (ex : Expanded) (p : Prep) : + uniformStage w ex p = uniformStageF w ex p (graphFacts ex.dag ex.roots) := by + unfold uniformStage uniformStageF + rfl + +/-- `uniformChoose` with the graph facts `f` passed in. -/ +def uniformChooseF (w : Nat) (limits : Limits) (ex : Expanded) (p : Prep) (f : GraphFacts) : + Except SharingError UniformChoice := do + let sg := uniformStageF w ex p f + unless componentsChecked ex.dag sg.cls sg.opaq sg.comps (componentLabels ex.dag.size sg.comps) do + throw (.internal "uncertain components are not a separated partition") + let (results, states, costEvals) ← searchComponents limits ex sg + let (chosenDelta, chosenX, lowerBracket) ← uniformKnapsack limits sg.cs.size results + let modelInt : _root_.Int := (csBase ex p sg : Nat) + chosenDelta + + (tag0Size (sg.cs.size + chosenX.size) : _root_.Int) + if modelInt < 0 then throw (.internal "negative model length") + let model := modelInt.toNat + if model > limits.maxOutputBytes then + throw (.resourceExhausted .outputBytes limits.maxOutputBytes) + return { facts := sg.f, certainStored := sg.cs, certainExcluded := sg.ce, uncertain := sg.unc, + lowDegree := sg.low, components := sg.comps, stored := mergeSorted sg.cs chosenX, model, + states, costEvals, lowerBracket } + +theorem uniformChoose_eq_F (w : Nat) (limits : Limits) (ex : Expanded) (p : Prep) : + uniformChoose w limits ex p = uniformChooseF w limits ex p (graphFacts ex.dag ex.roots) := by + unfold uniformChoose uniformChooseF + rw [uniformStage_eq_F] + +/-- `inClassCheck` with the in-degrees `deg` passed in. -/ +def inClassCheckD (deg : Array Nat) (stored : Array Nat) : Bool := + (List.range stored.size).all (fun i => decide (i + 1 < stored.size → stored[i]! < stored[i + 1]!)) && + stored.all (fun t => decide (2 ≤ deg[t]!)) + +/-- `uniformFinish` with the in-degrees `deg` passed in. -/ +def uniformFinishF (w : Nat) (limits : Limits) (ex : Expanded) (p : Prep) (deg : Array Nat) + (c : UniformChoice) : Except SharingError UniformSharingResult := do + let n := ex.dag.size + let stored := c.stored + let model := c.model + unless stored.all (· < n) do + throw (.internal "stored term out of range") + unless inClassCheckD deg stored do + throw (.internal "stored terms are not increasing terms of in-degree at least 2") + let order := pinnedOrder ex.dag c.facts.deg stored + let width := stored.foldl (fun acc t => acc.set! t (some w)) (Array.replicate n none) + let (entries, roots, predicted, work) ← p.materializeDependent order ex.roots width limits + unless predicted == model do + throw (.internal s!"uniform model length {model} differs from the full evaluation {predicted}") + let (entryIds, rootIds, _) ← reexpand limits ex.dag entries roots + unless entryIds == order do + throw (.internal "materialized entries do not expand to the stored terms") + unless rootIds == ex.roots do + throw (.internal "materialized roots do not expand to the input roots") + let measured := tag0Size entries.size + exprsSize entries + exprsSize roots + let unshared := tag0Size 0 + rootsCost p.base ex.roots + let stats : Stats := + { exprVisits := ex.visits, internedNodes := ex.internedNodes, distinctSubterms := n, + candidates := c.certainStored.size + c.uncertain.size, statesExpanded := c.states, + costEvals := c.costEvals, materializedNodes := work, outputBytes := measured } + return { + result := { roots, sharing := entries, tableTerms := order, variableBytes := measured, + modelBytes := model, unsharedBytes := unshared, stats } + stored, certainStored := c.certainStored, certainExcluded := c.certainExcluded, + uncertain := c.uncertain, lowDegree := c.lowDegree, components := c.components, + statesVisited := c.states, lowerBracket := c.lowerBracket } + +theorem uniformFinish_eq_F (w : Nat) (limits : Limits) (ex : Expanded) (p : Prep) + (c : UniformChoice) : + uniformFinish w limits ex p c = + uniformFinishF w limits ex p (graphFacts ex.dag ex.roots).deg c := by + unfold uniformFinish uniformFinishF inClassCheck inClassCheckD + rfl + +/-- `optimizeUniformExpanded` after its DAG checks, with the DAG tables `p`, +the graph facts `f` and the outcome of the spine check passed in. -/ +def optimizeUniformF (w : Nat) (limits : Limits) (ex : Expanded) (p : Prep) (f : GraphFacts) + (spine : Except SharingError Unit) : Except SharingError UniformSharingResult := do + spine + let c ← uniformChooseF w limits ex p f + uniformFinishF w limits ex p f.deg c + +theorem optimizeUniformExpanded_eq_F (w : Nat) (limits : Limits) (ex : Expanded) : + optimizeUniformExpanded w limits ex = + if w == 0 then throw (.formatBound "uniform Share width" 0) + else (uniformDagChecks ex).bind fun _ => + optimizeUniformF w limits ex (Prep.ofDag ex.dag) (graphFacts ex.dag ex.roots) + (uniformSpineCheck ex (Prep.ofDag ex.dag)) := by + unfold optimizeUniformExpanded optimizeUniformF uniformDagChecks uniformSpineCheck + simp only [uniformChoose_eq_F, uniformFinish_eq_F] + cases (w == 0) <;> + cases childrenPrecede ex.dag.nodes <;> + cases ex.dag.nodes.all (fun node => node.children.size == node.head.arity) <;> + cases ex.roots.all (· < ex.dag.size) <;> + cases (reachMarks ex.dag.nodes ex.roots).all id <;> + cases (List.range ex.dag.size).all (fun t => (Prep.ofDag ex.dag).spineLen[t]! < teleSubaddEnd) <;> + rfl + +/-- `tieredResult` with the candidate count `k` and the phase-1 layout length +passed in. -/ +def tieredResultF (layout : ShareLayout) (w : Nat) (u : UniformSharingResult) (a : Allocation) + (m : Rematerialized) (k phase1Layout : Nat) : TieredSharingResult := + let stats : TieredStats := + { layout := layout, candidateCount := k, w := w, + candidateLengths := #[(w, m.bytes)], phase1ModelBytes := u.result.modelBytes, + phase1LayoutBytes := phase1Layout, slotStates := a.slotStates, firstTier := a.tier, + keptPhase1Order := a.kept, phase1RefCost := a.refCost1, finalRefCost := a.refCostFinal, + phase3LayoutBytes := m.bytes, savings := phase1Layout - m.bytes } + let rstats : Stats := + { u.result.stats with materializedNodes := m.work, outputBytes := m.measured } + let res : ExactSharingResult := + { u.result with + roots := m.roots, sharing := m.entries, tableTerms := a.order, + variableBytes := m.measured, modelBytes := m.bytes, stats := rstats } + { result := res, phase1 := u, stats := stats } + +/-- The candidate count of `tieredResult`: terms with in-degree at least 2 +and unshared length at least 2. -/ +def tieredCandidateCount (n : Nat) (p : Prep) (f : GraphFacts) : Nat := + ((Array.range n).filter fun t => f.deg[t]! ≥ 2 && p.base[t]! ≥ 2).size + +theorem tieredResult_eq_F (layout : ShareLayout) (ex : Expanded) (w : Nat) + (u : UniformSharingResult) (a : Allocation) (m : Rematerialized) : + tieredResult layout ex w u a m = + tieredResultF layout w u a m + (tieredCandidateCount ex.dag.size (Prep.ofDag ex.dag) (graphFacts ex.dag ex.roots)) + (layoutBytes layout u.result.sharing u.result.roots) := by + unfold tieredResult tieredResultF tieredCandidateCount + rfl + +/-- `rematerialize` with the DAG tables `p` passed in. -/ +def rematerializeP (p : Prep) (layout : ShareLayout) (limits : Limits) (ex : Expanded) + (order : Array Nat) (phase1Layout : Nat) : Except SharingError Rematerialized := do + let (entries, roots, predicted, work) ← + materializeTableOnePass p order ex.roots limits layout.widthAt + let priced := layoutBytes layout entries roots + checkInternal (priced == predicted) + s!"layout length {priced} differs from the evaluation {predicted}" + checkInternal (predicted ≤ phase1Layout) + s!"re-materialization {predicted} is longer than phase 1 {phase1Layout}" + let (entryIds, rootIds, _) ← reexpand limits ex.dag entries roots + checkInternal (entryIds == order) "re-materialized entries do not expand to the stored terms" + checkInternal (rootIds == ex.roots) "re-materialized roots do not expand to the input roots" + checkInternal ((entries ++ roots).all fun e => (wireCounts e).isSome) + "a re-materialized expression has a count outside the wire domain" + return { entries, roots, bytes := predicted, work, measured := priced } + +theorem rematerialize_eq_P (layout : ShareLayout) (limits : Limits) (ex : Expanded) + (order : Array Nat) (phase1Layout : Nat) : + rematerialize layout limits ex order phase1Layout = + rematerializeP (Prep.ofDag ex.dag) layout limits ex order phase1Layout := by + unfold rematerialize rematerializeP + rfl + +/-- One candidate (`tieredAtWidth`) after the DAG checks, with the +width-independent tables passed in. -/ +def tieredAtWidthF (layout : ShareLayout) (limits : Limits) (ex : Expanded) (w : Nat) + (p : Prep) (f : GraphFacts) (spine : Except SharingError Unit) (k : Nat) : + Except SharingError TieredSharingResult := do + let u ← optimizeUniformF w limits ex p f spine + let a ← allocate layout limits ex.dag f.deg u.result.tableTerms u.result.sharing u.result.roots + let phase1Layout := layoutBytes layout u.result.sharing u.result.roots + let m ← rematerializeP p layout limits ex a.order phase1Layout + return tieredResultF layout w u a m k phase1Layout + +theorem tieredAtWidth_eq_F (layout : ShareLayout) (limits : Limits) (ex : Expanded) (w : Nat) + (hw : (w == 0) = false) : + tieredAtWidth layout limits ex w = + (uniformDagChecks ex).bind fun _ => + tieredAtWidthF layout limits ex w (Prep.ofDag ex.dag) (graphFacts ex.dag ex.roots) + (uniformSpineCheck ex (Prep.ofDag ex.dag)) + (tieredCandidateCount ex.dag.size (Prep.ofDag ex.dag) (graphFacts ex.dag ex.roots)) := by + unfold tieredAtWidth tieredAtWidthF + rw [optimizeUniformExpanded_eq_F] + simp only [hw, Bool.false_eq_true, if_false, tieredResult_eq_F, rematerialize_eq_P] + cases uniformDagChecks ex <;> rfl + +/-- `tieredAtWidth` with the width-independent tables computed once for its +three phases. -/ +def tieredAtWidthC (layout : ShareLayout) (limits : Limits) (ex : Expanded) (w : Nat) : + Except SharingError TieredSharingResult := + if w == 0 then throw (.formatBound "uniform Share width" 0) + else + (uniformDagChecks ex).bind fun _ => + let p := Prep.ofDag ex.dag + let f := graphFacts ex.dag ex.roots + tieredAtWidthF layout limits ex w p f (uniformSpineCheck ex p) + (tieredCandidateCount ex.dag.size p f) + +@[csimp] theorem tieredAtWidth_eq_C : @tieredAtWidth = @tieredAtWidthC := by + funext layout limits ex w + unfold tieredAtWidthC + split + · rename_i hw + unfold tieredAtWidth + rw [optimizeUniformExpanded_eq_F] + simp only [hw, if_true] + rfl + · rename_i hw + exact tieredAtWidth_eq_F layout limits ex w (by simpa using hw) + +/-- The best of the three candidates with every candidate's length (the tail +of `canonicalTieredCore`). -/ +def tieredPick (c1 c2 c3 : TieredSharingResult) : TieredSharingResult := + let best := #[c2, c3].foldl (fun b c => if tieredBetter c b then c else b) c1 + let lengths := #[c1, c2, c3].map fun c => (c.stats.w, c.stats.phase3LayoutBytes) + { best with stats := { best.stats with candidateLengths := lengths } } + +/-- Constants with at least this many distinct subterms compute their three +candidates as parallel tasks. -/ +def tieredParMin : Nat := 1024 + +/-- The three candidates `run 1`, `run 2`, `run 3`, combined in width order +(the first failure in width order is the result). For a DAG of at least +`tieredParMin` terms the three are spawned as tasks before the first is +awaited; the value is the same (`(Task.spawn f).get = f ()`). -/ +def tieredCandidates (n : Nat) (run : Nat → Except SharingError TieredSharingResult) : + Except SharingError TieredSharingResult := + if n < tieredParMin then do + let c1 ← run 1 + let c2 ← run 2 + let c3 ← run 3 + return tieredPick c1 c2 c3 + else + let ts := #[1, 2, 3].map fun w => Task.spawn fun _ => run w + do + let c1 ← ts[0]!.get + let c2 ← ts[1]!.get + let c3 ← ts[2]!.get + return tieredPick c1 c2 c3 + +theorem tieredCandidates_eq (n : Nat) (run : Nat → Except SharingError TieredSharingResult) : + tieredCandidates n run = do + let c1 ← run 1 + let c2 ← run 2 + let c3 ← run 3 + return tieredPick c1 c2 c3 := by + unfold tieredCandidates + split + · rfl + · simp [Task.spawn] + +/-- `canonicalTieredCore` with the DAG checks run once, the width-independent +tables computed once for the three candidates, and the candidates of a large +DAG computed in parallel. -/ +def canonicalTieredCoreC (layout : ShareLayout) (limits : Limits) (dag : Dag) + (roots : Array Nat) : Except SharingError TieredSharingResult := + let ex : Expanded := { dag, roots, visits := 0, internedNodes := 0 } + (uniformDagChecks ex).bind fun _ => + let p := Prep.ofDag dag + let f := graphFacts dag roots + let spine := uniformSpineCheck ex p + let k := tieredCandidateCount dag.size p f + tieredCandidates dag.size fun w => tieredAtWidthF layout limits ex w p f spine k + +@[csimp] theorem canonicalTieredCore_eq_C : @canonicalTieredCore = @canonicalTieredCoreC := by + funext layout limits dag roots + unfold canonicalTieredCore canonicalTieredCoreC + simp only [tieredAtWidth_eq_F _ _ _ 1 rfl, tieredAtWidth_eq_F _ _ _ 2 rfl, + tieredAtWidth_eq_F _ _ _ 3 rfl, tieredCandidates_eq] + cases uniformDagChecks { dag, roots, visits := 0, internedNodes := 0 } <;> rfl + +/-- `canonicalTieredExpanded`, compiled with the parts above. -/ +def canonicalTieredExpandedC (layout : ShareLayout) (limits : Limits) (ex : Expanded) : + Except SharingError TieredSharingResult := do + let r ← canonicalTieredCore layout limits ex.dag ex.roots + return withExpansionStats ex r + +@[csimp] theorem canonicalTieredExpanded_eq_C : + @canonicalTieredExpanded = @canonicalTieredExpandedC := by + funext layout limits ex + unfold canonicalTieredExpanded canonicalTieredExpandedC + rfl + +/-- `optimizeUniformExpanded` with `Prep.ofDag` and the graph facts computed +once for its stages. -/ +def optimizeUniformExpandedC (w : Nat) (limits : Limits) (ex : Expanded) : + Except SharingError UniformSharingResult := + if w == 0 then throw (.formatBound "uniform Share width" 0) + else (uniformDagChecks ex).bind fun _ => + let p := Prep.ofDag ex.dag + optimizeUniformF w limits ex p (graphFacts ex.dag ex.roots) (uniformSpineCheck ex p) + +@[csimp] theorem optimizeUniformExpanded_eq_C : + @optimizeUniformExpanded = @optimizeUniformExpandedC := by + funext w limits ex + exact optimizeUniformExpanded_eq_F w limits ex + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/Uniform.lean b/Ix/Sharing/Exact/Uniform.lean new file mode 100644 index 000000000..c641fa76c --- /dev/null +++ b/Ix/Sharing/Exact/Uniform.lean @@ -0,0 +1,492 @@ +/- + Exact minimum sharing under a uniform reference width. + + Cost model: every `Share` costs exactly `w ≥ 1` bytes regardless of its + index; the table count is an exact `Tag0`; telescopes and all other bytes + are as written by `putExpr`. The variable length of a table set `S` is + + L(S) = tag0Size |S| + Σ_{t ∈ S} inl_S(t) + Σ_{roots r} C_S(r) + + where `C_S` is the fixed-dictionary optimum (`Exact.Dictionary`) with every + term of `S` available at width `w`, and `inl_S(t)` is `t`'s cost with an + inline top. Order is irrelevant to the model length: in any dependency + order (stored descendants first) each entry already sees every stored term + that can occur inside it, and a Share's price does not depend on its index. + So only the set is chosen; the table order is then pinned (children before + parents; among ready terms, larger in-degree first, then smaller structural + ID). + + ## Facts about a term `t` of the compact DAG + * `deg(t)`: in-degree, counting edge multiplicity and root occurrences. + * `headDeg(t)`: the in-edges at head positions (roots are heads). The other + edges are continuations: an App as the function of an App, a Lam as the + body of a Lam, an All as the body of an All. + * `occ(t)`: the fully expanded occurrence count. + * `size(t)`: the unshared standalone length `C_∅(t)`. + + ## Classes + * CERTAIN-EXCLUDED (in no minimum) when `(occ-1)·size < occ·w`. + Take any minimum storing `t` and replace each of its `R` references by + `t`'s entry body (at a telescope continuation the merged header is + subadditive), then delete the entry; the table count cannot grow. The + length changes by at most `(R-1)·body - R·w` with `body ≤ size` and, as a + minimum has no unreachable entry, `R ≤ occ`. This is negative when the + condition holds (for `size ≤ w` for every `R`), contradicting minimality. + It subsumes R1 (`occ = 1`) and R2 (one-byte terms). + * Search candidates: in-degree `≥ 2`, not certain-excluded. In-degree-1 + terms are left out by an exchange that does not increase the length (so + some minimum avoids them, although ties can also store them): let `p` be + the single parent of `t`; every reference to `t` sits in an inline write + of `p`, and each such write costs more than `w`. If `t` is referenced at + most once, inlining it (or dropping it) is strictly shorter. Otherwise, + if `p` is stored, a write of `p` outside its entry becomes `Share(p)` + (strictly shorter). If `p` is not stored, store `p` instead of `t`, built + from the write `W₁` with the smallest inline spine prefix `j₁`, and turn + the other writes into `Share(p)`: the new header `tag4Size(j₁) ≤ j₁` is + covered by another write's surplus over `w`, which is at least its own + prefix length `≥ j₁`. The count is unchanged. Each step removes an + in-degree-1 term and adds only a strict ancestor, so it terminates. + * CERTAIN-STORED (in every minimum whose table holds only candidates; such + minima have the global minimum length by the in-degree-1 exchange) for a + candidate when `g ≥ θ`, with `d`, `h` the visible counts (below) and `b` + a lower bound on the bytes of `t` inside a telescope that runs through it + (excluding the header): + non-telescope: g = (d-1)·inl⁻ - d·w + telescope, h ≥ 1: g = (d-1)·b + (h-1) - d·w + telescope, h = 0: g = (d-1)·b - tag4Size(spine length) - d·w + Exchange: in a candidate-only minimum `E` not storing `t`, `t` has at + least `d` inline occurrences, at least `h` of them at head positions. Add + the entry `t` (its optimal body, which costs exactly what one head + occurrence costs, or at most one continuation occurrence plus its header + `≤ tag4Size(spine length)`), and replace every occurrence by `Share(t)`: + descendants lose occurrences, ancestors get a `w`-byte leaf where the + subtree was, telescopes only shorten. The length drops by at least `g` + minus the growth of the table count's TagN, contradicting minimality. + Threshold: with `n` candidates, one more entry grows the count by at most + `tag0StepBound n` bytes (1 below 4311826560, the TagN `f = 0` rung-5 end), so + `θ = θmax = tag0StepBound n + 1` always holds; `θ = 1` holds when + `tag0Size(#candidates) = tag0Size(#terms with g ≥ θmax)`, since every + candidate-only minimum contains the `g ≥ θmax` terms and only candidates, + so its count and that count plus one share a TagN bracket. + Visible counts, for a maybe-stored set `M` (here the candidates): lower + bounds `d(t)`, `h(t)` on the inline occurrences of `t` in an encoding of + any `S ⊆ M` with `t ∉ S`. One per root occurrence, plus per edge from `z` + (for `h`: head edges only) the writes of `z`: at least 1 when `z ∈ M` + (every reachable term is written somewhere) and at least `d(z)` otherwise + (every occurrence of an unstored term is an inline write). So `d ≥ deg`. + The bounds `inl⁻`, `b` are computed bottom-up with every child in `M` + priced at `min(w, ·)` (it might be stored), every other child at its + inline bound, and a header of at least 1 byte. + * UNCERTAIN: the remaining candidates. + + ## Certain-stored terms are opaque + `g ≥ 1` forces `b ≥ w` (and `inl⁻ > w`), so in every candidate encoding a + certain-stored term costs exactly `w` wherever it occurs, and a telescope + running into it is never shorter than one cut there. Costs above it are + therefore computed with it as a `w`-byte leaf that ends the spine; this + truncated evaluation equals the real one (checked on the output). + + ## Components + Two uncertain terms are connected when a DAG path joins them whose + intermediate terms are not certain-stored. Every cost is then a sum of + functions of the chosen terms of one component each: children add; a + telescope's minimum over cut options couples a cut node only with the + terms below it; a term's own Share option couples it with the terms below + it. The table-count prefix is the only coupling: each component search + returns, per chosen count, its best change `Δ` within `slack` of its + optimum, where `slack` is the largest `Tag0` difference between two + candidate-only sets that contain the certain-stored terms. When the + combined choice is in a higher count bracket than the certain-stored terms + alone, a small knapsack over components checks whether a lower bracket is + at least as short. + + ## Component search: reclassifying branch and bound + A node is a partial assignment of the component's members (stored, not + stored, undecided) within the decisions of the enclosing searches. At each + node: + 1. Reclassify. With `M` = the candidates minus every member decided not + stored, recompute `inl⁻`, `b` and the visible counts over the + component's area and decide stored every undecided member with + `g ≥ θ`. The exchange above holds for every minimum that respects the + partial assignment, since such a minimum lies in `M`. + 2. Bound. The cost with every undecided member available and its entry + free is a lower bound on every completion (costs only drop when more + terms are available; entries cost ≥ 0). Prune when it exceeds the best + completion of this search by more than `slack`; never on equality + (ties are left to the tie order). + 3. Split. A member decided stored with `inl⁻ ≥ w` (non-telescope) or + `b ≥ w` (telescope) under the node's bounds is opaque, like a + certain-stored term. The undecided members are grouped by DAG paths + whose intermediate terms are not opaque; the groups below a decided + stored member that is not opaque are also joined (its `min(w, ·)` + couples them). Each group is solved by a sub-search with the node's + decisions as context and the per-count tables are combined. A single + group is also handed to a sub-search when one of this search's + decisions no longer reaches it. Sub-search tables are memoized under + the group and the decisions that reach it: those joined to a group + member by a directed DAG path (up or down) whose intermediate terms are + not opaque, and those below (through non-opaque terms) a stored + non-opaque ancestor reached that way, whose `min(w, ·)` couples its + subterms. Any other decision is reached only through ancestors whose + cost it enters additively, so it does not change the group's `Δ`. + 4. Branch on the undecided member with the largest `|g|` (then the smaller + ID), "stored" first when `g > 0`. + Each node and each sub-search counts as one search state. The plain subset + enumeration of each component is kept as a test oracle + (`Limits.uniformSubsetSearch`, off by default and excluded from the + optimality theorems); it is not the compiler path. + + ## Tie-break + Among minimum-length sets the least one in the order "the smaller + structural ID in the symmetric difference is not stored". Components, + groups, memoized tables and the bracket knapsack preserve this order + exactly: the parts of a union are disjoint, so the order of unions is + decided inside one part. +-/ +module + +public import Ix.Sharing.Exact.UniformSearchLocal + +public section + +namespace Ix.Sharing.Exact + +open Ixon + +/-! ## Result -/ + +/-- Uniform-width optimization result: the usual result (with `modelBytes` +the exact uniform-model length and `variableBytes` the real serialized +length of the same output) plus the classification and search statistics. -/ +structure UniformSharingResult where + result : ExactSharingResult + /-- The stored set, ascending. -/ + stored : Array Nat + certainStored : Array Nat + certainExcluded : Array Nat + uncertain : Array Nat + lowDegree : Array Nat + components : Array (Array Nat) + /-- Search states (component subsets evaluated). -/ + statesVisited : Nat + /-- Whether the table-count knapsack chose a lower count bracket. -/ + lowerBracket : Bool + deriving Inhabited + +/-- Telescope spines must be shorter than this. Below `Ixon.tagNEnd5 4` (the +start of the 9-byte TagN rung) the telescope headers are subadditive, +`tag4Size (a + b) ≤ tag4Size a + tag4Size b`, which the certain-excluded class +relies on (merging two telescopes when a Share is unshared). +`optimizeUniformExpanded` fails closed on a longer spine. -/ +def teleSubaddEnd : Nat := Ixon.tagNEnd5 4 + +/-- First count with the same TagN (`f = 0`) width as `k` (`tag0Size`): the +start of `k`'s rung. -/ +def tag0BracketStart (k : Nat) : Nat := + if k < Ixon.tagNEnd1 0 then 0 + else if k < Ixon.tagNEnd2 0 then Ixon.tagNEnd1 0 + else if k < Ixon.tagNEnd3 0 then Ixon.tagNEnd2 0 + else if k < Ixon.tagNEnd4 0 then Ixon.tagNEnd3 0 + else if k < Ixon.tagNEnd5 0 then Ixon.tagNEnd4 0 + else Ixon.tagNEnd5 0 + +/-- An upper bound on `tag0Size (k + 1) - tag0Size k` for every `k < n`: the +TagN (`f = 0`) width grows by one byte at 128, 16512, 82048 and 16859264, and +by four at 4311826560. -/ +def tag0StepBound (n : Nat) : Nat := + if n < Ixon.tagNEnd5 0 then 1 else 4 + +/-- The next term of the pinned order: among the remaining terms whose +nearest stored descendants are all placed, the larger in-degree first, then +the smaller ID. -/ +def pinnedPick (deg : Array Nat) (deps : Std.HashMap Nat (Array Nat)) + (placed : Std.HashSet Nat) (remaining : Array Nat) : Option Nat := + let ready := remaining.filter fun t => ((deps.getD t #[]).all placed.contains) + ready.foldl (init := none) fun acc t => + match acc with + | none => some t + | some a => if deg[t]! > deg[a]! || (deg[t]! == deg[a]! && t < a) then some t else acc + +/-- Place up to `fuel` terms in the pinned order; anything left unplaced (never +the case for a DAG) is appended as given. -/ +def pinnedPlace (deg : Array Nat) (deps : Std.HashMap Nat (Array Nat)) : + Nat → Array Nat → Array Nat → Std.HashSet Nat → Array Nat + | 0, order, remaining, _ => order ++ remaining + | fuel + 1, order, remaining, placed => + match pinnedPick deg deps placed remaining with + | none => order ++ remaining + | some pick => + pinnedPlace deg deps fuel (order.push pick) (remaining.erase pick) (placed.insert pick) + +/-- Nearest stored descendants of each stored term. -/ +def pinnedDeps (dag : Dag) (stored : Array Nat) : Std.HashMap Nat (Array Nat) := Id.run do + let n := dag.size + let isStored := stored.foldl (fun acc t => acc.set! t true) (Array.replicate n false) + let mut deps : Std.HashMap Nat (Array Nat) := {} + for t in stored do + let mut seen : Std.HashSet Nat := {} + let mut stack := (dag.node t).children + let mut out : Array Nat := #[] + for _ in [0:4 * n + 4] do + match stack.back? with + | none => break + | some u => + stack := stack.pop + if seen.contains u then continue + seen := seen.insert u + if isStored[u]! then + out := out.push u + else + stack := stack ++ (dag.node u).children + deps := deps.insert t out + return deps + +/-- Pinned table order of a stored set: stored descendants first; among +ready terms the larger in-degree first, then the smaller ID. -/ +def pinnedOrder (dag : Dag) (deg : Array Nat) (stored : Array Nat) : Array Nat := + pinnedPlace deg (pinnedDeps dag stored) stored.size #[] stored {} + +/-- The stored set chosen by the uniform-width search, before +materialization, with its model length and the search statistics. -/ +structure UniformChoice where + facts : GraphFacts + certainStored : Array Nat + certainExcluded : Array Nat + uncertain : Array Nat + lowDegree : Array Nat + components : Array (Array Nat) + /-- The stored set, ascending. -/ + stored : Array Nat + /-- The uniform-model length of `stored`, from the truncated evaluation. -/ + model : Nat + states : Nat + costEvals : Nat + lowerBracket : Bool + +/-- One knapsack step: the best `(Δ, set)` per count up to `cap`, combining the +counts so far with a component's table. -/ +def knapStep (cap : Nat) (dp : Array (Option (_root_.Int × Array Nat))) (bySize : CTable) : + Array (Option (_root_.Int × Array Nat)) := + (List.range dp.size).foldl (fun ndp c => + match dp[c]! with + | none => ndp + | some (d, s) => (List.range bySize.size).foldl (fun ndp k => + match bySize[k]! with + | none => ndp + | some (dk, sk) => + if c + k > cap then ndp + else + let cand : _root_.Int × Array Nat := (d + dk, mergeSorted s sk) + if betterEntry cand ndp[c + k]! then ndp.set! (c + k) (some cand) else ndp) ndp) + (Array.replicate (cap + 1) none) + +/-- Pick the shortest count bracket candidate (ties by `setPrec`). -/ +def knapChoose (kCS : Nat) (dp : Array (Option (_root_.Int × Array Nat))) + (init : _root_.Int × Array Nat × Bool) : _root_.Int × Array Nat × Bool := + (List.range dp.size).foldl (fun (acc : _root_.Int × Array Nat × Bool) c => + match dp[c]! with + | none => acc + | some (d, s) => + let l : _root_.Int := d + (tag0Size (kCS + c) : _root_.Int) + let l0 : _root_.Int := acc.1 + (tag0Size (kCS + acc.2.1.size) : _root_.Int) + if l < l0 || (l == l0 && setPrec s acc.2.1) then (d, s, true) else acc) init + +/-- The classification stage of the uniform optimizer: the classes, the +certain-stored evaluation, the components and the shared search tables. -/ +structure UStage where + f : GraphFacts + cand : Array Bool + b0 : UBounds + vis0 : Array Nat × Array Nat + theta : _root_.Int + cls : Array UClass + cs : Array Nat + ce : Array Nat + unc : Array Nat + low : Array Nat + opaq : Array Bool + up : UPrep + widthCs : Array (Option Nat) + allTrue : Array Bool + baseEv : DictEval + comps : Array (Array Nat) + slack : Nat + rootCount : Array Nat + +/-- Classify the terms and prepare the component searches. -/ +def uniformStage (w : Nat) (ex : Expanded) (p : Prep) : UStage := + let n := ex.dag.size + let f := graphFacts ex.dag ex.roots + let cand := searchCandidates p f w + let b0 := uniformBounds p w cand + let vis0 := visibleCounts ex.dag ex.roots cand + -- The certain-stored threshold: `1 + tag0StepBound nCand` always holds (one + -- more entry grows the table count by at most that many bytes; 2 below + -- 4311826560 candidates); 1 holds when every minimum lies in one count bracket + -- (it contains the certain-stored terms and only candidates). + let nCand := (cand.filter id).size + let thetaMax : _root_.Int := tag0StepBound nCand + 1 + let clsMax := classifyWith p f w b0 vis0 thetaMax + let nCsMax := (clsMax.filter (· == .certainStored)).size + let theta : _root_.Int := if tag0Size nCand == tag0Size nCsMax then 1 else thetaMax + let cls := if theta == 1 then classifyWith p f w b0 vis0 1 else clsMax + let pick (c : UClass) := (Array.range n).filter (cls[·]! == c) + let cs := pick .certainStored + let unc := pick .uncertain + let opaq := cs.foldl (fun acc t => acc.set! t true) (Array.replicate n false) + let widthCs : Array (Option Nat) := + cs.foldl (fun acc t => acc.set! t (some w)) (Array.replicate n none) + let allTrue := Array.replicate n true + { f, cand, b0, vis0, theta, cls, cs, ce := pick .certainExcluded, unc, + low := pick .lowDegree, opaq, up := UPrep.mk' p w opaq, widthCs, allTrue, + baseEv := p.eval widthCs allTrue, comps := uncertainComponents ex.dag cls, + -- Largest table-count difference between two sets that contain the + -- certain-stored terms and only candidates. + slack := tag0Size (cs.size + unc.size) - tag0Size cs.size, + rootCount := ex.roots.foldl (fun acc r => acc.modify r (· + 1)) (Array.replicate n 0) } + +/-- Search every component. -/ +def searchComponents (limits : Limits) (ex : Expanded) (sg : UStage) : + Except SharingError (Array CompResult × Nat × Nat) := + sg.comps.foldlM (init := ((#[] : Array CompResult), 0, 0)) + fun (acc : Array CompResult × Nat × Nat) members => do + let (results, states, costEvals) := acc + if limits.uniformSubsetSearch then + let (r, states, costEvals) ← searchComponentRef sg.up sg.f sg.opaq ex.roots sg.slack + limits members states costEvals + pure (results.push r, states, costEvals) + else + let cx := mkSCtx ex sg.f sg.up sg.cand sg.b0 sg.vis0 sg.rootCount sg.slack sg.theta + sg.baseEv sg.widthCs sg.allTrue sg.unc members + let (r, states, costEvals) ← searchComponent cx limits states costEvals + pure (results.push r, states, costEvals) + +/-- `searchComponents` as `searchComponentsWith` on the stage's tables (the +same loop), so that compiled code runs `searchComponentsWithFast`. -/ +def searchComponentsVia (limits : Limits) (ex : Expanded) (sg : UStage) : + Except SharingError (Array CompResult × Nat × Nat) := + searchComponentsWith limits ex sg.f sg.up sg.cand sg.b0 sg.vis0 sg.rootCount sg.slack sg.theta + sg.baseEv sg.widthCs sg.allTrue sg.unc sg.opaq sg.comps + +@[csimp] theorem searchComponents_eq_via : @searchComponents = @searchComponentsVia := by + funext limits ex sg + rfl + +/-- The chosen `Δ` and set: the per-component optima, unless a lower count +bracket is shorter (and whether one was). -/ +def uniformKnapsack (limits : Limits) (kCS : Nat) (results : Array CompResult) : + Except SharingError (_root_.Int × Array Nat × Bool) := do + let bestX := results.foldl (fun acc r => mergeSorted acc r.bestSet) #[] + let bestDelta := results.foldl (fun acc r => acc + r.bestDelta) (0 : _root_.Int) + let start := tag0BracketStart (kCS + bestX.size) + if start > kCS then + let cap := start - 1 - kCS + if (results.size + 1) * (cap + 1) > limits.maxKnapsackCells then + throw (.resourceExhausted .knapsackCells limits.maxKnapsackCells) + -- dp[c]: best (Δ, set) with c chosen terms, over the components so far. + let dp := results.foldl (fun dp r => knapStep cap dp r.bySize) + (#[some (0, #[])] ++ Array.replicate cap none) + pure (knapChoose kCS dp (bestDelta, bestX, false)) + else pure (bestDelta, bestX, false) + +/-- The uniform-model length of the certain-stored terms without the count's +`Tag0`: the roots and the certain-stored entries, by the full evaluation. -/ +def csBase (ex : Expanded) (p : Prep) (sg : UStage) : Nat := + ex.roots.foldl (fun acc r => acc + sg.baseEv.cost[r]!) 0 + + sg.cs.foldl (fun acc c => acc + + (evalStep p.dag p.family p.spineLen p.tail (sg.widthCs.set! c none) sg.allTrue sg.baseEv + c).cost[c]!) 0 + +/-- `csBase` with each entry cost read in place (`evalHidden`). -/ +def csBaseFast (ex : Expanded) (p : Prep) (sg : UStage) : Nat := + ex.roots.foldl (fun acc r => acc + sg.baseEv.cost[r]!) 0 + + sg.cs.foldl (fun acc c => acc + + evalHidden p.dag p.family p.spineLen p.tail sg.widthCs sg.allTrue sg.baseEv c) 0 + +@[csimp] theorem csBase_eq_fast : @csBase = @csBaseFast := by + funext ex p sg + simp only [csBase, csBaseFast, evalHidden_eq] + +/-- Classify, search every component and combine: the stored set and its +model length. -/ +def uniformChoose (w : Nat) (limits : Limits) (ex : Expanded) (p : Prep) : + Except SharingError UniformChoice := do + let sg := uniformStage w ex p + unless componentsChecked ex.dag sg.cls sg.opaq sg.comps (componentLabels ex.dag.size sg.comps) do + throw (.internal "uncertain components are not a separated partition") + let (results, states, costEvals) ← searchComponents limits ex sg + let (chosenDelta, chosenX, lowerBracket) ← uniformKnapsack limits sg.cs.size results + let modelInt : _root_.Int := (csBase ex p sg : Nat) + chosenDelta + + (tag0Size (sg.cs.size + chosenX.size) : _root_.Int) + if modelInt < 0 then throw (.internal "negative model length") + let model := modelInt.toNat + if model > limits.maxOutputBytes then + throw (.resourceExhausted .outputBytes limits.maxOutputBytes) + return { facts := sg.f, certainStored := sg.cs, certainExcluded := sg.ce, uncertain := sg.unc, + lowDegree := sg.low, components := sg.comps, stored := mergeSorted sg.cs chosenX, model, + states, costEvals, lowerBracket } + +/-- The stored set is strictly increasing and every term has in-degree at +least 2. -/ +def inClassCheck (dag : Dag) (roots : Array Nat) (stored : Array Nat) : Bool := + let deg := edgeCounts dag roots false + (List.range stored.size).all (fun i => decide (i + 1 < stored.size → stored[i]! < stored[i + 1]!)) && + stored.all (fun t => decide (2 ≤ deg[t]!)) + +/-- Materialize a chosen set in the pinned order with the real evaluation, and +check it against the model length and the input. -/ +def uniformFinish (w : Nat) (limits : Limits) (ex : Expanded) (p : Prep) (c : UniformChoice) : + Except SharingError UniformSharingResult := do + let n := ex.dag.size + let stored := c.stored + let model := c.model + unless stored.all (· < n) do + throw (.internal "stored term out of range") + unless inClassCheck ex.dag ex.roots stored do + throw (.internal "stored terms are not increasing terms of in-degree at least 2") + let order := pinnedOrder ex.dag c.facts.deg stored + let width := stored.foldl (fun acc t => acc.set! t (some w)) (Array.replicate n none) + let (entries, roots, predicted, work) ← p.materializeDependent order ex.roots width limits + unless predicted == model do + throw (.internal s!"uniform model length {model} differs from the full evaluation {predicted}") + let (entryIds, rootIds, _) ← reexpand limits ex.dag entries roots + unless entryIds == order do + throw (.internal "materialized entries do not expand to the stored terms") + unless rootIds == ex.roots do + throw (.internal "materialized roots do not expand to the input roots") + let measured := tag0Size entries.size + exprsSize entries + exprsSize roots + let unshared := tag0Size 0 + rootsCost p.base ex.roots + let stats : Stats := + { exprVisits := ex.visits, internedNodes := ex.internedNodes, distinctSubterms := n, + candidates := c.certainStored.size + c.uncertain.size, statesExpanded := c.states, + costEvals := c.costEvals, materializedNodes := work, outputBytes := measured } + return { + result := { roots, sharing := entries, tableTerms := order, variableBytes := measured, + modelBytes := model, unsharedBytes := unshared, stats } + stored, certainStored := c.certainStored, certainExcluded := c.certainExcluded, + uncertain := c.uncertain, lowDegree := c.lowDegree, components := c.components, + statesVisited := c.states, lowerBracket := c.lowerBracket } + +/-- Exact uniform-width optimization of an expanded input. Fails closed +(`formatBound "telescope spine length"`) when a telescope spine reaches +`teleSubaddEnd`. -/ +def optimizeUniformExpanded (w : Nat) (limits : Limits) (ex : Expanded) : + Except SharingError UniformSharingResult := do + if w == 0 then throw (.formatBound "uniform Share width" 0) + unless childrenPrecede ex.dag.nodes do + throw (.internal "DAG children do not precede their parents") + unless ex.dag.nodes.all (fun node => node.children.size == node.head.arity) do + throw (.internal "DAG node arity") + unless ex.roots.all (· < ex.dag.size) do + throw (.internal "root ID out of range") + unless (reachMarks ex.dag.nodes ex.roots).all id do + throw (.internal "DAG term unreachable from the roots") + let p := Prep.ofDag ex.dag + unless (List.range ex.dag.size).all (fun t => p.spineLen[t]! < teleSubaddEnd) do + throw (.formatBound "telescope spine length" teleSubaddEnd) + let c ← uniformChoose w limits ex p + uniformFinish w limits ex p c + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/UniformSearch.lean b/Ix/Sharing/Exact/UniformSearch.lean new file mode 100644 index 000000000..412755767 --- /dev/null +++ b/Ix/Sharing/Exact/UniformSearch.lean @@ -0,0 +1,982 @@ +/- + Exact minimum sharing under a uniform reference width: graph facts, + classification, components and the per-component exact search. + + This is the first part of the uniform-width optimizer; the cost model, the + classes, the components, the reclassifying branch and bound and the tie + order are described in the module doc of `Ix.Sharing.Exact.Uniform`, which + combines the component tables (count-bracket knapsack), materializes the + chosen set and checks it. +-/ +module + +public import Ix.Sharing.Exact.Search + +public section + +namespace Ix.Sharing.Exact + +open Ixon + +/-! ## Graph facts -/ + +/-- In-degrees, head in-degrees, occurrences and parent lists. -/ +structure GraphFacts where + deg : Array Nat + headDeg : Array Nat + occ : Array Nat + parents : Array (Array Nat) + deriving Inhabited + +/-- Edge counts per target: the root occurrences plus, over every node and +child index, one per child edge (only non-continuation edges if `headOnly`). -/ +def edgeCounts (dag : Dag) (roots : Array Nat) (headOnly : Bool) : Array Nat := + let base := roots.foldl (fun acc r => acc.modify r (· + 1)) (Array.replicate dag.size 0) + foldRange (fun acc t => + let node := dag.node t + (List.range node.children.size).foldl (fun acc i => + let c := node.child i + if headOnly && continuationEdge node i (dag.node c) then acc + else acc.modify c (· + 1)) acc) + 0 dag.size base + +/-- Distinct parents of every term, in increasing order. Terms are visited in +increasing order, so a repeated child edge of `t` can only meet `t` as the +last parent recorded: checking `back?` instead of searching the whole list +keeps this linear in the edges. -/ +def parentLists (dag : Dag) : Array (Array Nat) := Id.run do + let n := dag.size + let mut parents : Array (Array Nat) := Array.replicate n #[] + for t in [0:n] do + let node := dag.node t + for c in node.children do + unless (parents[c]!).back? == some t do parents := parents.modify c (·.push t) + return parents + +def graphFacts (dag : Dag) (roots : Array Nat) : GraphFacts := + { deg := edgeCounts dag roots false, headDeg := edgeCounts dag roots true, + occ := occurrences dag roots, parents := parentLists dag } + +/-! ## Classes -/ + +/-- Classification of a term for the uniform-width search. -/ +inductive UClass where + /-- Not certain-excluded, but in-degree `< 2`: never searched. -/ + | lowDegree + | certainExcluded + | certainStored + | uncertain + deriving BEq, Repr, Inhabited + +/-- Lower bounds used by the certain-stored test. `inlineLB`: bytes of the +term written inline at a head position; `mergedLB`: bytes of a telescope +node inside a telescope running through it (no header); `headLB`/`contLB`: +the same at a head/continuation position when the term may be a Share. -/ +structure UBounds where + inlineLB : Array Nat + mergedLB : Array Nat + headLB : Array Nat + contLB : Array Nat + deriving Inhabited + +/-- One step of `uniformBounds`: the bounds of `t` from those of its +children. -/ +def boundsStep (p : Prep) (w : Nat) (maybeStored : Array Bool) (b : UBounds) (t : Nat) : + UBounds := + let node := p.dag.node t + let fam := p.family[t]! + let (i, m) := + if fam == .none then + let i := node.children.foldl (fun acc c => acc + b.headLB[c]!) node.head.ownBytes + (i, i) + else + let nxt := node.spineNext + let rest := if p.family[nxt]! == fam then b.contLB[nxt]! else b.headLB[nxt]! + let m := node.sideExtra + b.headLB[node.sideChild]! + rest + (1 + m, m) + { inlineLB := b.inlineLB.set! t i, mergedLB := b.mergedLB.set! t m, + headLB := b.headLB.set! t (if maybeStored[t]! then min w i else i), + contLB := b.contLB.set! t (if maybeStored[t]! then min w m else m) } + +def uniformBounds (p : Prep) (w : Nat) (maybeStored : Array Bool) : UBounds := + let n := p.dag.size + foldRange (boundsStep p w maybeStored) 0 n + { inlineLB := Array.replicate n 0, mergedLB := Array.replicate n 0, + headLB := Array.replicate n 0, contLB := Array.replicate n 0 } + +/-- The certain-stored gain bound with explicit occurrence lower bounds: `d` +inline occurrences in all, `h` of them at head positions (see the module +doc). -/ +def storedGainWith (p : Prep) (b : UBounds) (w t d h : Nat) : _root_.Int := + let deg := _root_.Int.ofNat d + let wI := _root_.Int.ofNat w + if p.family[t]! == .none then + (deg - 1) * _root_.Int.ofNat b.inlineLB[t]! - deg * wI + else if h ≥ 1 then + (deg - 1) * _root_.Int.ofNat b.mergedLB[t]! + (_root_.Int.ofNat h - 1) - deg * wI + else + (deg - 1) * _root_.Int.ofNat b.mergedLB[t]! - _root_.Int.ofNat (tag4Size p.spineLen[t]!) - deg * wI + +/-- The certain-stored gain bound `g` of a term with its in-degrees as the +occurrence counts. -/ +def storedGain (p : Prep) (f : GraphFacts) (b : UBounds) (w t : Nat) : _root_.Int := + storedGainWith p b w t f.deg[t]! f.headDeg[t]! + +/-- Cap of the visible counts (any lower bound keeps the gain test sound). -/ +def visibleCap : Nat := 1 <<< 20 + +/-- Visible occurrence counts: lower bounds on the inline occurrences of each +term `t` in every encoding of a set `S ⊆ maybeStored` with `t ∉ S`. Each root +occurrence counts 1, and each edge from `z` counts the writes of `z`: at least +1 when `z` may be stored (every reachable term is written somewhere), else at +least the visible count of `z` (every occurrence of an unstored term is an +inline write). The second array counts only head (non-continuation) edges. +Values are capped at `visibleCap` where they are passed on. -/ +def visibleCounts (dag : Dag) (roots : Array Nat) (maybeStored : Array Bool) : + Array Nat × Array Nat := + propagateCounts dag roots fun y c => if maybeStored[y]! then 1 else min c visibleCap + +/-- Whether a term is certain-excluded: `(occ-1)·size < occ·w`. -/ +def certainExcludedTest (p : Prep) (f : GraphFacts) (w t : Nat) : Bool := + (f.occ[t]! - 1) * p.base[t]! < f.occ[t]! * w + +/-- The search candidates (in-degree ≥ 2, not certain-excluded): only these +can be stored in the encodings the search ranges over. -/ +def searchCandidates (p : Prep) (f : GraphFacts) (w : Nat) : Array Bool := + (Array.range p.dag.size).map fun t => !certainExcludedTest p f w t && f.deg[t]! ≥ 2 + +/-- Classify every term under the root-level bounds `b` +(`uniformBounds p w (searchCandidates p f w)`) and the certain-stored +threshold `theta` (`uniformStage` passes 1 or `tag0StepBound n + 1`). -/ +def classifyWith (p : Prep) (f : GraphFacts) (w : Nat) (b : UBounds) + (vis : Array Nat × Array Nat) (theta : _root_.Int) : Array UClass := + (Array.range p.dag.size).map fun t => + if certainExcludedTest p f w t then .certainExcluded + else if f.deg[t]! < 2 then .lowDegree + else if storedGainWith p b w t vis.1[t]! vis.2[t]! ≥ theta then .certainStored + else .uncertain + +/-! ## Components -/ + +/-- Union-find root (fuel-bounded; `parent[x] ≤ x` is maintained). -/ +def ufFind (parent : Array Nat) (x : Nat) : Nat := Id.run do + let mut cur := x + for _ in [0:parent.size + 1] do + let q := parent[cur]! + if q == cur then break + cur := q + return cur + +/-- Components of the uncertain terms: joined by DAG paths that avoid +certain-stored terms. Each component is sorted; components are sorted by +their smallest term. -/ +def uncertainComponents (dag : Dag) (cls : Array UClass) : Array (Array Nat) := Id.run do + let n := dag.size + let mut uf : Array Nat := Array.range n + -- Component representatives reachable at or below each term. + let mut reps : Array (Array Nat) := Array.replicate n #[] + for t in [0:n] do + if cls[t]! == .certainStored then continue + let mut rs : Array Nat := #[] + for c in (dag.node t).children do + for r in reps[c]! do + let fr := ufFind uf r + unless rs.contains fr do rs := rs.push fr + if cls[t]! == .uncertain then + for r in rs do + let a := ufFind uf t + let b := ufFind uf r + if a != b then + if a < b then uf := uf.set! b a else uf := uf.set! a b + reps := reps.set! t #[t] + else + reps := reps.set! t rs + let mut groups : Std.HashMap Nat (Array Nat) := {} + for t in [0:n] do + if cls[t]! == .uncertain then + let r := ufFind uf t + groups := groups.insert r ((groups.getD r #[]).push t) + let comps := groups.toArray.map (·.2) + return comps.qsort fun a b => a[0]! < b[0]! + +/-! ## Checked separation of labeled terms -/ + +/-- Join of two reach summaries: `none` (no labeled term), `some (some ℓ)` +(every labeled term has label `ℓ`), `some none` (several labels). -/ +def labelJoin : Option (Option Nat) → Option (Option Nat) → Option (Option Nat) + | none, x => x + | some x, none => some x + | some (some a), some (some b) => if a = b then some (some a) else some none + | some _, some _ => some none + +/-- For every term, the labels of the labeled terms reachable from it along +DAG paths whose intermediate terms are not opaque (children first). -/ +def reachLabels (dag : Dag) (opq : Nat → Bool) (lab : Nat → Option Nat) : + Array (Option (Option Nat)) := + foldRange (fun acc t => + acc.set! t ((dag.node t).children.foldl (fun v c => + labelJoin v (if opq c then (lab c).map some else acc[c]!)) ((lab t).map some))) + 0 dag.size (Array.replicate dag.size none) + +/-- `reachLabels` computed only at the terms of `order` (ascending), every +other entry staying `none`: exact at those terms when `order` contains every +non-opaque child of its terms that reaches a labeled term. -/ +def reachLabelsOn (dag : Dag) (order : Array Nat) (opq : Nat → Bool) (lab : Nat → Option Nat) : + Array (Option (Option Nat)) := + order.foldl (fun acc t => + acc.set! t ((dag.node t).children.foldl (fun v c => + labelJoin v (if opq c then (lab c).map some else acc[c]!)) ((lab t).map some))) + (Array.replicate dag.size none) + +/-- Every term of `terms` reaches only terms carrying its own label. -/ +def labelsSeparated (dag : Dag) (opq : Nat → Bool) (lab : Nat → Option Nat) + (terms : Array Nat) : Bool := + let rl := reachLabels dag opq lab + terms.all fun y => match lab y with + | some ℓ => rl[y]! == some (some ℓ) + | none => false + +/-- The components partition the uncertain terms (each listed once, in +increasing order, labeled with its component) and are separated by the +certain-stored terms. -/ +def componentsChecked (dag : Dag) (cls : Array UClass) (opaq : Array Bool) + (comps : Array (Array Nat)) (label : Array (Option Nat)) : Bool := + let n := dag.size + ((Array.range comps.size).all fun i => + (List.range comps[i]!.size).all (fun j => + let t := comps[i]![j]! + t < n && cls[t]! == .uncertain && label[t]! == some i && + (j + 1 < comps[i]!.size → t < comps[i]![j + 1]!))) && + ((Array.range n).all fun t => + cls[t]! != .uncertain || match label[t]! with + | some i => i < comps.size && comps[i]!.contains t + | none => false) && + labelsSeparated dag (opaq[·]!) (label[·]!) ((Array.range n).filter (cls[·]! == .uncertain)) + +/-- Component index of every listed term. -/ +def componentLabels (n : Nat) (comps : Array (Array Nat)) : Array (Option Nat) := + (Array.range comps.size).foldl + (fun acc i => comps[i]!.foldl (fun acc t => acc.set! t (some i)) acc) (Array.replicate n none) + +/-! ## Truncated evaluation (certain-stored terms opaque) -/ + +/-- Values of one term in the truncated evaluation. -/ +structure UVal where + cost : Nat := 0 + inl : Nat := 0 + sides : Nat := 0 + below : Option Nat := none + deriving Inhabited, Repr + +/-- Static data of the truncated evaluation. -/ +structure UPrep where + prep : Prep + w : Nat + opaq : Array Bool + /-- Spine length and natural tail, with spines ending at opaque terms. -/ + tLen : Array Nat + tTail : Array Nat + /-- Values with no uncertain term available. -/ + base : Array UVal + deriving Inhabited + +/-- Evaluate one term given its children's values. Returns the value and the +number of available spine descendants visited. -/ +def UPrep.node (up : UPrep) (get : Nat → UVal) (avail : Nat → Bool) (t : Nat) : + UVal × Nat := Id.run do + let p := up.prep + let node := p.dag.node t + let fam := p.family[t]! + let mut steps := 0 + let mut v : UVal := {} + if fam == .none then + v := { v with inl := node.children.foldl (fun acc c => acc + (get c).cost) node.head.ownBytes } + else + let nxt := node.spineNext + let same := p.family[nxt]! == fam && !up.opaq[nxt]! + let s := node.sideExtra + (get node.sideChild).cost + (if same then (get nxt).sides else 0) + let bl : Option Nat := + if same then (if avail nxt then some nxt else (get nxt).below) else none + let l := up.tLen[t]! + let mut best := tag4Size l + s + (get up.tTail[t]!).cost + let mut cur := bl + for _ in [0:l] do + match cur with + | none => break + | some u => + steps := steps + 1 + let cand := tag4Size (l - up.tLen[u]!) + (s - (get u).sides) + up.w + if cand < best then best := cand + cur := (get u).below + v := { v with inl := best, sides := s, below := bl } + let cost := + if up.opaq[t]! then up.w + else if avail t then min up.w v.inl + else v.inl + return ({ v with cost }, steps) + +/-- Build the truncated evaluation with certain-stored terms opaque. -/ +def UPrep.mk' (p : Prep) (w : Nat) (opaq : Array Bool) : UPrep := Id.run do + let n := p.dag.size + let mut tLen : Array Nat := Array.replicate n 0 + let mut tTail : Array Nat := Array.replicate n 0 + for t in [0:n] do + let fam := p.family[t]! + if fam != .none then + let nxt := (p.dag.node t).spineNext + if p.family[nxt]! == fam && !opaq[nxt]! then + tLen := tLen.set! t (tLen[nxt]! + 1) + tTail := tTail.set! t tTail[nxt]! + else + tLen := tLen.set! t 1 + tTail := tTail.set! t nxt + let up0 : UPrep := { prep := p, w, opaq, tLen, tTail, base := #[] } + let mut base : Array UVal := Array.mkEmpty n + for t in [0:n] do + let (v, _) := up0.node (fun c => base[c]!) (fun _ => false) t + base := base.push v + return { up0 with base } + +/-! ## Per-component exact search -/ + +/-- Static context of one component search. -/ +structure CompCtx where + up : UPrep + members : Array Nat + /-- Terms whose truncated values can depend on the component, ascending. -/ + area : Array Nat + /-- Roots in `area` with their multiplicities. -/ + rootMult : Array (Nat × Nat) + /-- Certain-stored terms in `area` (their entry bodies may change). -/ + storedIn : Array Nat + /-- The component's cost with nothing chosen. -/ + phi0 : Nat + /-- Keep subsets within this much of the best (table-count coupling). -/ + slack : Nat + +/-- Numeric order reversed: the element order under which `setPrec` is a +lexicographic order. -/ +def compareDesc (x y : Nat) : Ordering := compare y x + +/-- Tie order on sorted sets: `a` precedes `b` when the smallest term of their +symmetric difference is in `b` (so `a` leaves it out). On sorted arrays this +is the lexicographic order under `compareDesc`, a proper prefix first: at the +first position where they differ, the smaller term belongs to one set only. -/ +def setPrec (a b : Array Nat) : Bool := + Array.compareLex compareDesc a b == .lt + +/-- Union of two sorted arrays (sorted). -/ +def mergeSorted (a b : Array Nat) : Array Nat := + ((a.toList ++ b.toList).mergeSort fun x y => decide (x ≤ y)).toArray + +/-- Strictly increasing. -/ +def strictInc (a : Array Nat) : Bool := + (List.range a.size).all fun i => decide (i + 1 < a.size → a[i]! < a[i + 1]!) + +/-- The groups partition `und`: their terms, sorted, are `und`'s, sorted. -/ +def partitionCheck (und : Array Nat) (groups : Array (Array Nat)) : Bool := + (groups.toList.flatMap (·.toList)).mergeSort (fun x y => decide (x ≤ y)) == + und.toList.mergeSort (fun x y => decide (x ≤ y)) + +/-- Search state of one component. -/ +structure CompState where + best : Option (_root_.Int × Array Nat) := none + /-- Best `(Δ, set)` per chosen-set size, within `slack` of the best. -/ + bySize : Array (Option (_root_.Int × Array Nat)) := #[] + states : Nat := 0 + costEvals : Nat := 0 + +abbrev CompM := StateT CompState (Except SharingError) + +/-- Cost of the component's parts with `avail` available and `chosen` +stored (the entries of undecided terms are omitted), and the evaluation +work. -/ +def CompCtx.phi (cx : CompCtx) (avail : Nat → Bool) (chosen : Array Nat) : Nat × Nat := Id.run do + let mut vals : Std.HashMap Nat UVal := {} + let mut work := 0 + for t in cx.area do + let get := fun c => (vals.get? c).getD cx.up.base[c]! + let (v, s) := cx.up.node get avail t + vals := vals.insert t v + work := work + 1 + s + let get := fun c => (vals.get? c).getD cx.up.base[c]! + let roots := cx.rootMult.foldl (fun acc (r, m) => acc + m * (get r).cost) 0 + let stored := cx.storedIn.foldl (fun acc c => acc + (get c).inl) 0 + let entries := chosen.foldl (fun acc x => acc + (get x).inl) 0 + return (roots + stored + entries, work) + +/-- Record a complete choice. -/ +def CompState.record (st : CompState) (delta : _root_.Int) (set : Array Nat) : CompState := + let better (o : Option (_root_.Int × Array Nat)) : Bool := + match o with + | none => true + | some (d, s) => delta < d || (delta == d && setPrec set s) + let best := if better st.best then some (delta, set) else st.best + let k := set.size + let bySize := if st.bySize.size ≤ k then + st.bySize ++ Array.replicate (k + 1 - st.bySize.size) none + else st.bySize + let bySize := if better bySize[k]! then bySize.set! k (some (delta, set)) else bySize + { st with best, bySize } + +/-- Depth-first branch and bound over the members (ascending), trying +"not stored" first. -/ +def CompCtx.dfs (cx : CompCtx) (limits : Limits) : Nat → Nat → Array Nat → CompM Unit + | 0, _, _ => throw (.internal "component search fuel exhausted") + | fuel + 1, i, chosen => do + let st ← get + if st.states + 1 > limits.maxStates then + throw (.resourceExhausted .states limits.maxStates) + let undecided := cx.members.extract i cx.members.size + let avail := fun t => chosen.contains t || undecided.contains t + let (phi, work) := cx.phi avail chosen + if st.costEvals + work > limits.maxCostEvals then + throw (.resourceExhausted .costEvals limits.maxCostEvals) + set { st with states := st.states + 1, costEvals := st.costEvals + work } + let delta : _root_.Int := (phi : _root_.Int) - (cx.phi0 : _root_.Int) + if i ≥ cx.members.size then + modify fun st => st.record delta chosen + else + match (← get).best with + | some (b, _) => if delta > b + (cx.slack : _root_.Int) then return + | none => pure () + let t := cx.members[i]! + cx.dfs limits fuel (i + 1) chosen + cx.dfs limits fuel (i + 1) (chosen.push t) + +/-- Terms whose truncated values can change with the component: its members +and their ancestors, not continuing above an opaq term. -/ +def componentArea (up : UPrep) (f : GraphFacts) (members : Array Nat) : Array Nat := Id.run do + let mut seen : Std.HashSet Nat := {} + let mut stack := members + for t in members do seen := seen.insert t + for _ in [0:up.prep.dag.size + 1] do + match stack.back? with + | none => break + | some t => + stack := stack.pop + if up.opaq[t]! then continue + for q in f.parents[t]! do + unless seen.contains q do + seen := seen.insert q + stack := stack.push q + return seen.toArray.qsort (· < ·) + +/-- The undecided member to branch on: the largest `|gain|`, then the smaller +ID. -/ +def pickBranch (gains : Array (Nat × _root_.Int)) : Option (Nat × _root_.Int) := + gains.foldl (init := none) fun acc (t, g) => + match acc with + | none => some (t, g) + | some (a, ga) => if g.natAbs > ga.natAbs || (g.natAbs == ga.natAbs && t < a) then some (t, g) else acc + +/-! ## Reclassifying branch and bound with splitting -/ + +/-- Best `(Δ, set)` per chosen count (index = set size). -/ +abbrev CTable := Array (Option (_root_.Int × Array Nat)) + +/-- Whether `e` beats the entry `o` (smaller `Δ`, then `setPrec`). -/ +def betterEntry (e : _root_.Int × Array Nat) (o : Option (_root_.Int × Array Nat)) : Bool := + match o with + | none => true + | some (d, s) => e.1 < d || (e.1 == d && setPrec e.2 s) + +/-- The smallest `Δ` of a table. -/ +def CTable.best (tb : CTable) : Option _root_.Int := + tb.foldl (init := none) fun acc o => + match o, acc with + | none, _ => acc + | some (d, _), none => some d + | some (d, _), some b => some (min d b) + +/-- Record an entry at its count. -/ +def CTable.add (tb : CTable) (e : _root_.Int × Array Nat) : CTable := + let k := e.2.size + let tb := if tb.size ≤ k then tb ++ Array.replicate (k + 1 - tb.size) none else tb + if betterEntry e tb[k]! then tb.set! k (some e) else tb + +/-- Whether a lower bound exceeds the table's best by more than `slack`. -/ +def CTable.prunes (tb : CTable) (delta : _root_.Int) (slack : Nat) : Bool := + match tb.best with + | some bd => decide (delta > bd + (slack : _root_.Int)) + | none => false + +/-- Drop the entries more than `slack` above the best. -/ +def CTable.trim (tb : CTable) (slack : Nat) : CTable := + match tb.best with + | none => tb + | some b => tb.map fun o => + match o with + | some (d, s) => if d > b + (slack : _root_.Int) then none else some (d, s) + | none => none + +/-- Combine the tables of disjoint groups: every pair of entries, summed. -/ +def CTable.conv (a b : CTable) : CTable := + a.foldl (fun out oa => match oa with + | none => out + | some (da, sa) => b.foldl (fun out ob => match ob with + | none => out + | some (db, sb) => out.add (da + db, mergeSorted sa sb)) out) #[] + +/-- Static context of one component's search. -/ +structure SCtx where + up : UPrep + facts : GraphFacts + /-- Root-level search candidates, bounds and visible counts. -/ + cand : Array Bool + bounds0 : UBounds + vis0 : Array Nat × Array Nat + members : Array Nat + memberIdx : Std.HashMap Nat Nat + /-- Members and their ancestors, not continuing above a certain-stored + term, ascending; and the index of each. -/ + area : Array Nat + areaIdx : Std.HashMap Nat Nat + /-- Per area node: `(parent, edges, head edges)` for every distinct parent, + and its root occurrences. -/ + inEdges : Array (Array (Nat × Nat × Nat)) + rootOcc : Array Nat + slack : Nat + theta : _root_.Int + /-- Full evaluation with the certain-stored terms available, their widths, + the members and their ancestors (ascending), the roots among them (with + repetitions), and the certain-stored terms among them. -/ + baseEv : DictEval + widthCs : Array (Option Nat) + allTrue : Array Bool + closure : Array Nat + rootsC : Array Nat + storedInC : Array Nat + /-- Every uncertain term (all components). -/ + allUnc : Array Nat + +/-- Search state of one component. -/ +structure SState where + states : Nat := 0 + costEvals : Nat := 0 + memo : Std.HashMap (Array Nat × Array Nat) CTable := {} + memoHits : Nat := 0 + +/-- Members and their ancestors, ascending. -/ +def upClosure (dag : Dag) (isMember : Nat → Bool) : Array Nat := + let marks := foldRange (fun (acc : Array Bool) t => + acc.set! t (isMember t || (dag.node t).children.any (acc[·]!))) 0 dag.size + (Array.replicate dag.size false) + (Array.range dag.size).filter (marks[·]!) + +/-- The component's cost by the full evaluation, recomputing only the members +and their ancestors. -/ +def SCtx.phiE (cx : SCtx) (avail : Nat → Bool) (stored : Array Nat) : Nat × Nat := + let p := cx.up.prep + let width := cx.members.foldl (fun acc t => if avail t then acc.set! t (some cx.up.w) else acc) + cx.widthCs + let ev := cx.closure.foldl (evalStep p.dag p.family p.spineLen p.tail width cx.allTrue) cx.baseEv + let inl := fun x => + (evalStep p.dag p.family p.spineLen p.tail (width.set! x none) cx.allTrue ev x).cost[x]! + let roots := cx.rootsC.foldl (fun acc r => acc + ev.cost[r]!) 0 + let base := cx.storedInC.foldl (fun acc c => acc + inl c) 0 + let entries := stored.foldl (fun acc x => acc + inl x) 0 + (roots + base + entries, cx.closure.size + stored.size) + +/-- `SCtx.phiE` with each entry cost read in place (`evalHidden`). -/ +def SCtx.phiEFast (cx : SCtx) (avail : Nat → Bool) (stored : Array Nat) : Nat × Nat := + let p := cx.up.prep + let width := cx.members.foldl (fun acc t => if avail t then acc.set! t (some cx.up.w) else acc) + cx.widthCs + let ev := cx.closure.foldl (evalStep p.dag p.family p.spineLen p.tail width cx.allTrue) cx.baseEv + let inl := fun x => evalHidden p.dag p.family p.spineLen p.tail width cx.allTrue ev x + let roots := cx.rootsC.foldl (fun acc r => acc + ev.cost[r]!) 0 + let base := cx.storedInC.foldl (fun acc c => acc + inl c) 0 + let entries := stored.foldl (fun acc x => acc + inl x) 0 + (roots + base + entries, cx.closure.size + stored.size) + +@[csimp] theorem SCtx.phiE_eq_fast : @SCtx.phiE = @SCtx.phiEFast := by + funext cx avail stored + simp only [SCtx.phiE, SCtx.phiEFast, evalHidden_eq] + +/-- Bounds under a decided-out set: the root-level bounds recomputed over the +area (ascending) with the decided-out members no longer maybe-stored. Every +value is at most the bounds of exactly that maybe-stored set (`boundsStep` is +monotone and the start is pointwise below). -/ +def SCtx.rebound (cx : SCtx) (ms : Array Bool) : UBounds := + cx.area.foldl (boundsStep cx.up.prep cx.up.w ms) cx.bounds0 + +/-- Visible counts under a maybe-stored set: the area nodes recomputed from +their parents (descending), every other term at its root-level count. -/ +def SCtx.revisible (cx : SCtx) (ms : Array Bool) : Array Nat × Array Nat := + (List.range cx.area.size).foldl (fun (acc : Array Nat × Array Nat) k => + match acc with + | (ds, hs) => + let j := cx.area.size - 1 - k + let y := cx.area[j]! + let r := cx.rootOcc[j]! + let dh := cx.inEdges[j]!.foldl (fun (dh : Nat × Nat) (e : Nat × Nat × Nat) => + let wq := if ms[e.1]! then 1 else min ds[e.1]! visibleCap + (dh.1 + e.2.1 * wq, dh.2 + e.2.2 * wq)) (r, r) + (ds.set! y dh.1, hs.set! y dh.2)) cx.vis0 + +/-- Whether a decided-stored term costs exactly `w` wherever it occurs and +ends every telescope running into it, under bounds `b`. -/ +def SCtx.opaqueUnder (cx : SCtx) (b : UBounds) (t : Nat) : Bool := + if cx.up.prep.family[t]! == .none then b.inlineLB[t]! ≥ cx.up.w + else b.mergedLB[t]! ≥ cx.up.w + +/-- Groups of the undecided members: joined by DAG paths whose intermediate +terms are not opaque, and below a common non-opaque decided-stored term. -/ +def SCtx.groups (cx : SCtx) (opq : Nat → Bool) (availFixed : Nat → Bool) (und : Array Nat) : + Array (Array Nat) := Id.run do + let undSet : Std.HashSet Nat := und.foldl (·.insert ·) {} + let mut uf : Array Nat := Array.range cx.members.size + let mut reps : Array (Array Nat) := Array.replicate cx.area.size #[] + for j in [0:cx.area.size] do + let y := cx.area[j]! + if opq y then continue + let mut rs : Array Nat := #[] + for c in (cx.up.prep.dag.node y).children do + match cx.areaIdx.get? c with + | none => pure () + | some jc => + for r in reps[jc]! do + let fr := ufFind uf r + unless rs.contains fr do rs := rs.push fr + if undSet.contains y then + let iy := cx.memberIdx.getD y 0 + for r in rs do + let a := ufFind uf iy + let b := ufFind uf r + if a != b then + if a < b then uf := uf.set! b a else uf := uf.set! a b + reps := reps.set! j #[ufFind uf iy] + else if availFixed y && rs.size > 1 then + for r in rs do + let a := ufFind uf rs[0]! + let b := ufFind uf r + if a != b then + if a < b then uf := uf.set! b a else uf := uf.set! a b + reps := reps.set! j #[ufFind uf rs[0]!] + else + reps := reps.set! j rs + let mut groups : Std.HashMap Nat (Array Nat) := {} + for t in und do + let r := ufFind uf (cx.memberIdx.getD t 0) + groups := groups.insert r ((groups.getD r #[]).push t) + let gs := groups.toArray.map fun (_, g) => g.qsort (· < ·) + return gs.qsort fun a b => a[0]! < b[0]! + +/-- Memo key of a group: its members and the decisions that can change the +group's `Δ`, each as `3·t + code` (code 0 not stored, 1 stored, 2 stored +and opaque). Those are the decided members joined to a group member by a +directed DAG path (up or down) whose intermediate terms are not opaque, and +the decided members below (through non-opaque terms) a stored, non-opaque +ancestor reached that way, whose `min(w, ·)` couples its subterms. Any other +decision is reached only through ancestors whose cost it enters additively. +Also returns the set of those decided members. -/ +def SCtx.memoKey (cx : SCtx) (opq : Nat → Bool) (inSet outSet : Std.HashSet Nat) + (g : Array Nat) : Array Nat × Std.HashSet Nat := Id.run do + let mut entries : Array Nat := #[] + let mut rel : Std.HashSet Nat := {} + -- Up from the group; stored non-opaque ancestors also start a down search. + let mut downStart := g + let mut seen : Std.HashSet Nat := g.foldl (·.insert ·) {} + let mut stack := g + for _ in [0:cx.area.size + 1] do + match stack.back? with + | none => break + | some y => + stack := stack.pop + for q in cx.facts.parents[y]! do + if !cx.areaIdx.contains q || seen.contains q then continue + seen := seen.insert q + if outSet.contains q then + entries := entries.push (3 * q) + rel := rel.insert q + else if inSet.contains q then + entries := entries.push (3 * q + (if opq q then 2 else 1)) + rel := rel.insert q + unless opq q do downStart := downStart.push q + unless opq q do stack := stack.push q + -- Down through non-opaque terms. + seen := downStart.foldl (·.insert ·) {} + stack := downStart + for _ in [0:cx.area.size + 1] do + match stack.back? with + | none => break + | some y => + stack := stack.pop + for c in (cx.up.prep.dag.node y).children do + if !cx.areaIdx.contains c || seen.contains c then continue + seen := seen.insert c + if !rel.contains c then + if outSet.contains c then + entries := entries.push (3 * c) + rel := rel.insert c + else if inSet.contains c then + entries := entries.push (3 * c + (if opq c then 2 else 1)) + rel := rel.insert c + unless opq c do stack := stack.push c + return (entries.qsort (· < ·), rel) + +/-- One search state: count it, charge `work`, enforce the limits. -/ +def chargeP (limits : Limits) (work : Nat) (st : SState) : Except SharingError SState := do + if st.states + 1 > limits.maxStates then + throw (.resourceExhausted .states limits.maxStates) + if st.costEvals + work > limits.maxCostEvals then + throw (.resourceExhausted .costEvals limits.maxCostEvals) + pure { st with states := st.states + 1, costEvals := st.costEvals + work } + +/-- The opaque terms under a decided context, as a table: the certain-stored +terms and the decided-stored terms whose bounds (with the decided-out terms +removed from the maybe-stored set) reach `w`. -/ +def SCtx.opaqueArr (cx : SCtx) (inAll outAll : Array Nat) : Array Bool := + let b := cx.rebound (outAll.foldl (fun acc t => acc.set! t false) cx.cand) + inAll.foldl (fun acc t => acc.set! t (acc[t]! || cx.opaqueUnder b t)) cx.up.opaq + +/-- The reduced context encoded by a memo key's entries: the decided-stored +and the decided-unstored terms. -/ +def keyContext (entries : Array Nat) : Array Nat × Array Nat := + (entries.filterMap fun e => if e % 3 == 0 then none else some (e / 3), + entries.filterMap fun e => if e % 3 == 0 then some (e / 3) else none) + +/-- Mark the terms of `ts` in a table of `n` entries. -/ +def markTable (n : Nat) (ts : Array Nat) : Array Bool := + ts.foldl (fun acc t => acc.set! t true) (Array.replicate n false) + +/-- Labels of the separation check: group terms 1, other members outside the +context 2, everything else unlabeled. -/ +def sepLabels (n : Nat) (members g inRed outRed : Array Nat) : Array (Option Nat) := + let lab := members.foldl (fun acc t => acc.set! t (some 2)) (Array.replicate n none) + let lab := g.foldl (fun acc t => acc.set! t (some 1)) lab + (inRed ++ outRed).foldl (fun acc t => acc.set! t none) lab + +/-- **Separation check of a group under a reduced context.** The group's +terms are members outside the context; and with the opaque terms of the +context, no non-opaque member that can be stored (every member not in +`outRed`) reaches both a group term and a member outside the group and the +context. Computed over the members and their ancestors. -/ +def SCtx.sepCheck (cx : SCtx) (g inRed outRed : Array Nat) : Bool := + let n := cx.up.prep.dag.size + let opqR := cx.opaqueArr inRed outRed + let isMem := markTable n cx.members + let isOut := markTable n outRed + let lab := sepLabels n cx.members g inRed outRed + let rl := reachLabelsOn cx.up.prep.dag cx.closure (opqR[·]!) (lab[·]!) + g.all (fun t => isMem[t]! && lab[t]! == some 1) && + cx.members.all fun v => isOut[v]! || opqR[v]! || rl[v]! != some none + +/-- Reclassification at a search node: the undecided members whose gain under +the node's bounds (with the decided-out members no longer maybe-stored) and +recomputed counts reaches the threshold are merged into `localIn`; returns +the new `localIn`, the open members with their gains, and the node's bounds. -/ +def SCtx.reclassify (cx : SCtx) (outAll localIn und : Array Nat) : + Array Nat × Array (Nat × _root_.Int) × UBounds := + let ms := outAll.foldl (fun acc t => acc.set! t false) cx.cand + let b := cx.rebound ms + let vis := cx.revisible ms + let gains := und.map fun t => + let d := vis.1[t]! + let h := vis.2[t]! + (t, storedGainWith cx.up.prep b cx.up.w t d h, 1 ≤ d && h ≤ d) + let isForced := fun (e : Nat × _root_.Int × Bool) => e.2.2 && e.2.1 ≥ cx.theta + let forced := (gains.filter isForced).map (·.1) + let localIn := if forced.isEmpty then localIn else mergeSorted localIn forced + let open_ := (gains.filter (!isForced ·)).map fun e => (e.1, e.2.1) + (localIn, open_, b) + +mutual +/-- Exact table of a group under the decided sets `inAll`/`outAll` (members +of the component decided stored / not stored outside the group): for each +count, the best `Δ` within `slack` of the group's best, where `Δ` is the +change of the component cost from leaving the whole group unstored. Only the +decisions that reach the group (`memoKey`) enter its search, which is +memoized under them; the group's separation is checked first. -/ +def SCtx.solveP (cx : SCtx) (limits : Limits) : + Nat → Array Nat → Array Nat → Array Nat → SState → Except SharingError (CTable × SState) + | 0, _, _, _, _ => throw (.internal "component search fuel exhausted") + | fuel + 1, g, inAll, outAll, st => do + let opqA := cx.opaqueArr inAll outAll + let inSet : Std.HashSet Nat := inAll.foldl (·.insert ·) {} + let outSet : Std.HashSet Nat := outAll.foldl (·.insert ·) {} + let (entries, _) := cx.memoKey (opqA[·]!) inSet outSet g + let (inRed, outRed) := keyContext entries + unless strictInc g && strictInc inRed && strictInc outRed && + inRed.all inSet.contains && outRed.all outSet.contains do + throw (.internal "memo key context is not part of the decided context") + match st.memo.get? (g, entries) with + | some tb => pure (tb, { st with memoHits := st.memoHits + 1 }) + | none => + unless cx.sepCheck g inRed outRed do + throw (.internal "search group is not separated") + let (tb, st) ← cx.solveBody limits fuel g inRed outRed st + pure (tb, { st with memo := st.memo.insert (g, entries) tb }) + +/-- The search of a group under its reduced context. -/ +def SCtx.solveBody (cx : SCtx) (limits : Limits) : + Nat → Array Nat → Array Nat → Array Nat → SState → Except SharingError (CTable × SState) + | 0, _, _, _, _ => throw (.internal "component search fuel exhausted") + | fuel + 1, g, inRed, outRed, st => do + let inSet : Std.HashSet Nat := inRed.foldl (·.insert ·) {} + let (phi0, work) := cx.phiE (fun t => inSet.contains t) inRed + let st ← chargeP limits (work + cx.area.size) st + let (tb, st) ← cx.nodeP limits fuel phi0 inRed outRed outRed.size #[] g #[] st + pure (tb.trim cx.slack, st) + +/-- Branch-and-bound node of a group: `localIn` are the group's members +decided stored, `und` the undecided ones, `tb` the table so far. -/ +def SCtx.nodeP (cx : SCtx) (limits : Limits) : + Nat → Nat → Array Nat → Array Nat → Nat → Array Nat → Array Nat → CTable → SState → + Except SharingError (CTable × SState) + | 0, _, _, _, _, _, _, _, _ => throw (.internal "component search fuel exhausted") + | fuel + 1, phi0, inCtx, outAll, nOutCtx, localIn, und, tb, st => do + -- Reclassify: an undecided member whose gain under this partial + -- assignment reaches the threshold is stored in every minimum that + -- respects it. + let (localIn, open_, b) := cx.reclassify outAll localIn und + let und := open_.map (·.1) + let inAll := inCtx ++ localIn + let inSet : Std.HashSet Nat := inAll.foldl (·.insert ·) {} + let undSet : Std.HashSet Nat := und.foldl (·.insert ·) {} + -- Lower bound: every undecided member available, its entry free. + let (phi, work) := cx.phiE (fun t => inSet.contains t || undSet.contains t) inAll + let st ← chargeP limits (work + 2 * cx.area.size) st + let delta : _root_.Int := (phi : _root_.Int) - (phi0 : _root_.Int) + if und.isEmpty then return (tb.add (delta, localIn), st) + if tb.prunes delta cx.slack then return (tb, st) + -- Split into independent groups. + let opq := fun t => cx.up.opaq[t]! || (inSet.contains t && cx.opaqueUnder b t) + let availFixed := fun t => inSet.contains t && !opq t + let groups := cx.groups opq availFixed und + unless partitionCheck und groups do + throw (.internal "search groups do not partition the undecided members") + -- Hand a single group to the memoized solver when a decision of this + -- search no longer reaches it. + let route := + if groups.size > 1 then true + else if groups.size == 1 then + let outSet : Std.HashSet Nat := outAll.foldl (·.insert ·) {} + let (_, rel) := cx.memoKey opq inSet outSet groups[0]! + localIn.any (!rel.contains ·) || (outAll.extract nOutCtx outAll.size).any (!rel.contains ·) + else false + if route then + let (phiNone, work) := cx.phiE (fun t => inSet.contains t) inAll + let st ← chargeP limits work st + let base : _root_.Int := (phiNone : _root_.Int) - (phi0 : _root_.Int) + let (comb, st) ← cx.splitP limits fuel inAll outAll groups.toList + #[some (base, localIn)] st + return (comb.foldl (fun acc o => match o with + | some e => acc.add e + | none => acc) tb, st) + -- Branch on the largest |gain|, "stored" first when it is positive. + let some (t, gt) := pickBranch open_ | return (tb, st) + let und' := und.erase t + if gt > 0 then + let (tb, st) ← cx.nodeP limits fuel phi0 inCtx outAll nOutCtx (mergeSorted localIn #[t]) und' tb st + cx.nodeP limits fuel phi0 inCtx (outAll.push t) nOutCtx localIn und' tb st + else + let (tb, st) ← cx.nodeP limits fuel phi0 inCtx (outAll.push t) nOutCtx localIn und' tb st + cx.nodeP limits fuel phi0 inCtx outAll nOutCtx (mergeSorted localIn #[t]) und' tb st + +/-- Solve the groups of a split one after the other and combine their +tables. -/ +def SCtx.splitP (cx : SCtx) (limits : Limits) : + Nat → Array Nat → Array Nat → List (Array Nat) → CTable → SState → + Except SharingError (CTable × SState) + | 0, _, _, _, _, _ => throw (.internal "component search fuel exhausted") + | _ + 1, _, _, [], comb, st => pure (comb, st) + | fuel + 1, inAll, outAll, grp :: grps, comb, st => do + let (sub, st) ← cx.solveP limits fuel grp inAll outAll st + cx.splitP limits fuel inAll outAll grps (comb.conv sub) st +end + + +/-- Result of one component search. -/ +structure CompResult where + members : Array Nat + bestDelta : _root_.Int + bestSet : Array Nat + bySize : Array (Option (_root_.Int × Array Nat)) + deriving Inhabited + +/-- The edge counts from `q` into `y`: all edges and head (non-continuation) +edges. -/ +def edgeCount (dag : Dag) (q y : Nat) : Nat × Nat × Nat := + let node := dag.node q + (List.range node.children.size).foldl (fun (acc : Nat × Nat × Nat) i => + if node.child i == y then + (q, acc.2.1 + 1, acc.2.2 + (if continuationEdge node i (dag.node y) then 0 else 1)) + else acc) (q, 0, 0) + +/-- The search context of a component. -/ +def mkSCtx (ex : Expanded) (f : GraphFacts) (up : UPrep) (cand : Array Bool) (b0 : UBounds) + (vis0 : Array Nat × Array Nat) (rootCount : Array Nat) (slack : Nat) (theta : _root_.Int) + (baseEv : DictEval) (widthCs : Array (Option Nat)) (allTrue : Array Bool) (unc : Array Nat) + (members : Array Nat) : SCtx := + let n := ex.dag.size + let area := componentArea up f members + let areaIdx : Std.HashMap Nat Nat := + (Array.range area.size).foldl (fun acc j => acc.insert area[j]! j) {} + let memberIdx : Std.HashMap Nat Nat := + (Array.range members.size).foldl (fun acc j => acc.insert members[j]! j) {} + let inEdges := area.map fun y => f.parents[y]!.map fun q => edgeCount ex.dag q y + let rootOcc := area.map (rootCount[·]!) + let isMem := markTable n members + let closure := upClosure ex.dag (isMem[·]!) + let inClosure := markTable n closure + let rootsC := ex.roots.filter (inClosure[·]!) + let storedInC := closure.filter (up.opaq[·]!) + { up, facts := f, cand, bounds0 := b0, vis0, members, memberIdx, area, areaIdx, + inEdges, rootOcc, slack, theta, baseEv, widthCs, allTrue, closure, rootsC, storedInC, + allUnc := unc } + +/-- The recorded parents of every area node are strictly increasing terms. -/ +def areaParentsOK (n : Nat) (cx : SCtx) : Bool := + (List.range cx.area.size).all fun j => + strictInc ((cx.inEdges[j]!).map (·.1)) && (cx.inEdges[j]!).all (·.1 < n) + +/-- The entry of a table with value `bd` whose set comes first in `setPrec`. -/ +def bestSetOf (tb : CTable) (bd : _root_.Int) : Option (Array Nat) := + tb.foldl (init := (none : Option (Array Nat))) fun acc o => + match o with + | some (d, s) => + if d == bd then + match acc with + | none => some s + | some a => if setPrec s a then some s else acc + else acc + | none => acc + +/-- Search one component and pick its best entry. -/ +def searchComponent (cx : SCtx) (limits : Limits) (states costEvals : Nat) : + Except SharingError (CompResult × Nat × Nat) := do + unless areaParentsOK cx.up.prep.dag.size cx do + throw (.internal "component parents are not duplicate-free terms") + let st0 : SState := { states, costEvals } + let (tb, st) ← cx.solveP limits (8 * cx.members.size + 8) cx.members #[] #[] st0 + let some bd := tb.best | throw (.internal "component search found no choice") + let some bs := bestSetOf tb bd | throw (.internal "component search found no choice") + pure ({ members := cx.members, bestDelta := bd, bestSet := bs, bySize := tb }, + st.states, st.costEvals) + +/-- Search one component with the subset enumeration (the test oracle of +`Limits.uniformSubsetSearch`). -/ +def searchComponentRef (up : UPrep) (f : GraphFacts) (opaq : Array Bool) (roots : Array Nat) + (slack : Nat) (limits : Limits) (members : Array Nat) (states costEvals : Nat) : + Except SharingError (CompResult × Nat × Nat) := do + let area := componentArea up f members + let areaSet : Std.HashSet Nat := area.foldl (·.insert ·) {} + let rootMult : Std.HashMap Nat Nat := roots.foldl (fun acc r => + if areaSet.contains r then acc.insert r (acc.getD r 0 + 1) else acc) {} + let rootArr := rootMult.toArray.qsort (fun a b => a.1 < b.1) + let storedIn := area.filter (opaq[·]!) + let cx0 : CompCtx := + { up := up, members := members, area := area, rootMult := rootArr, + storedIn, phi0 := 0, slack := slack } + let (phi0, _) := cx0.phi (fun _ => false) #[] + let cx := { cx0 with phi0 } + let st0 : CompState := { states, costEvals } + let ((), st) ← (cx.dfs limits (members.size + 2) 0 #[]).run st0 + let some (bd, bs) := st.best | throw (.internal "component search found no choice") + pure ({ members, bestDelta := bd, bestSet := bs, bySize := st.bySize }, st.states, st.costEvals) + +end Ix.Sharing.Exact + +end diff --git a/Ix/Sharing/Exact/UniformSearchLocal.lean b/Ix/Sharing/Exact/UniformSearchLocal.lean new file mode 100644 index 000000000..4569df35f --- /dev/null +++ b/Ix/Sharing/Exact/UniformSearchLocal.lean @@ -0,0 +1,2539 @@ +/- + Exact minimum sharing under a uniform reference width: the compiled + component search. + + `searchComponentsWith` (the component loop of `searchComponents`) is the + specification; `searchComponentsWithFast` computes it with work bounded by + the components' areas and closures instead of the DAG's size, and + `searchComponentsWith_eq_fast` (`@[csimp]`) proves the two equal for every + input, so compiled code runs the fast loop while every theorem about the + search keeps talking about the specification. +-/ +module + +public import Ix.Sharing.Exact.UniformSearch +import all Ix.Sharing.Exact.Basic +import all Ix.Sharing.Exact.Dag +import all Ix.Sharing.Exact.Dictionary +import all Ix.Sharing.Exact.UniformSearch + +public section + +namespace Ix.Sharing.Exact + +open Ixon + +/-! ## Area- and closure-local values + +The search of `Ix.Sharing.Exact.UniformSearch` recomputes, at every node, +tables of the DAG's size +(`SCtx.rebound`, `SCtx.revisible`, `SCtx.opaqueArr`, `SCtx.sepCheck`, +`SCtx.phiE`), each from an n-sized array held by the context, so each node +costs Θ(n); and `mkSCtx` scans the whole DAG for every component. The +versions below compute the same values over the component's area (or its +closure) only, read every other term from the root-level tables, and find the +closure by an upward walk; `searchComponentsWith_eq_fast` attaches them to the +specification `searchComponentsWith`. + +Position tables: `pos[t]! = j + 1` when `t` is the `j`-th term of the area +(closure), `0` otherwise. -/ + +/-- The position recorded for `u` in a position table. -/ +@[inline] def posOf (pos : Array Nat) (u : Nat) : Option Nat := + let p := pos[u]! + if p == 0 then none else some (p - 1) + +/-- A field of the local value at `u`: of the entry at `u`'s position when that +is below `L.size`, else `base u`. -/ +@[inline] def readAtF {α β : Type} [Inhabited α] (posf : Nat → Option Nat) (L : Array α) + (proj : α → β) (base : Nat → β) (u : Nat) : β := + match posf u with + | some j => if j < L.size then proj L[j]! else base u + | none => base u + +/-- The local values of a fold over the terms `xsAt 0, …, xsAt (k - 1)`: entry +`i` is `G` of the entries before it. -/ +@[inline] def localFold {α : Type} (k : Nat) (xsAt : Nat → Nat) + (G : Array α → Nat → Nat → α) : Array α := + foldRange (fun L i => L.push (G L i (xsAt i))) 0 k (Array.mkEmpty k) + +/-- `cutScan` with readers for the spine sums, the descendant links and the +widths. -/ +@[specialize] def cutScanG (spineLen : Array Nat) (getS : Nat → Nat) (getB : Nat → Option Nat) + (widthG : Nat → Option Nat) (l s : Nat) : Nat → Option Nat → Nat → Nat → Nat × Nat + | 0, _, best, work => (best, work) + | _ + 1, none, best, work => (best, work) + | fuel + 1, some u, best, work => + let cand := tag4Size (l - spineLen[u]!) + (s - getS u) + (widthG u).getD 0 + cutScanG spineLen getS getB widthG l s fuel (getB u) (if cand < best then cand else best) + (work + 1) + +/-- The row (cost, spine sum, descendant link) that `evalStep` writes at an +affected term `t`, from readers of the evaluation before it. -/ +@[inline] def evalRowG (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (widthG : Nat → Option Nat) (getC getS : Nat → Nat) (getB : Nat → Option Nat) (t : Nat) : + Nat × Nat × Option Nat := + let node := dag.node t + let fam := family[t]! + if fam == .none then + let inl := node.children.foldl (fun acc c => acc + getC c) node.head.ownBytes + let c := match widthG t with + | some w => min inl w + | none => inl + (c, getS t, getB t) + else + let nxt := node.spineNext + let same := family[nxt]! == fam + let s := node.sideExtra + getC node.sideChild + (if same then getS nxt else 0) + let bl : Option Nat := + if same then (if (widthG nxt).isSome then some nxt else getB nxt) else none + let l := spineLen[t]! + let inl := (cutScanG spineLen (fun u => if u = t then s else getS u) + (fun u => if u = t then bl else getB u) widthG l s l bl + (tag4Size l + s + getC tail[t]!) 0).1 + let c := match widthG t with + | some w => min inl w + | none => inl + (c, s, bl) + +/-- `evalHidden` with readers (`inb`: the term is inside the tables). -/ +@[inline] def evalHiddenG (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (widthG : Nat → Option Nat) (aff inb : Bool) (getC getS : Nat → Nat) + (getB : Nat → Option Nat) (t : Nat) : Nat := + if aff then + let node := dag.node t + let fam := family[t]! + if fam == .none then + if inb then node.children.foldl (fun acc c => acc + getC c) node.head.ownBytes + else getC t + else + let nxt := node.spineNext + let same := family[nxt]! == fam + let s := node.sideExtra + getC node.sideChild + (if same then getS nxt else 0) + let bl : Option Nat := + if same then + (if (if nxt = t then none else widthG nxt).isSome then some nxt else getB nxt) + else none + let l := spineLen[t]! + if inb then + (cutScanG spineLen (fun u => if u = t then s else getS u) + (fun u => if u = t then bl else getB u) (fun u => if u = t then none else widthG u) + l s l bl (tag4Size l + s + getC tail[t]!) 0).1 + else getC t + else getC t + +/-- The width of `u` when the members satisfying `avail` are added at width +`w` to `widthCs` (the dictionary of `SCtx.phiE`). -/ +@[inline] def phiWidth (cx : SCtx) (avail : Nat → Bool) (u : Nat) : Option Nat := + if decide (u < cx.widthCs.size) && cx.members.contains u && avail u then some cx.up.w + else widthOf cx.widthCs u + +/-- The closure-local evaluation of `SCtx.phiE` (by closure position). -/ +def phiTable (cx : SCtx) (posC : Array Nat) (avail : Nat → Bool) : + Array (Nat × Nat × Option Nat) := + let p := cx.up.prep + let base := cx.baseEv + localFold cx.closure.size (cx.closure[·]!) fun L _ t => + if cx.allTrue[t]! then + evalRowG p.dag p.family p.spineLen p.tail (phiWidth cx avail) + (readAtF (posOf posC) L (·.1) (base.cost[·]!)) + (readAtF (posOf posC) L (·.2.1) (base.sides[·]!)) + (readAtF (posOf posC) L (·.2.2) (base.below[·]!)) t + else (base.cost[t]!, base.sides[t]!, base.below[t]!) + +/-- The component cost of `SCtx.phiE` from the closure-local evaluation. -/ +def phiEL (cx : SCtx) (posC : Array Nat) (avail : Nat → Bool) (stored : Array Nat) : + Nat × Nat := + let p := cx.up.prep + let base := cx.baseEv + let L := phiTable cx posC avail + let getC := readAtF (posOf posC) L (·.1) (base.cost[·]!) + let getS := readAtF (posOf posC) L (·.2.1) (base.sides[·]!) + let getB := readAtF (posOf posC) L (·.2.2) (base.below[·]!) + let inl := fun x => evalHiddenG p.dag p.family p.spineLen p.tail (phiWidth cx avail) + cx.allTrue[x]! (decide (x < base.cost.size)) getC getS getB x + let roots := cx.rootsC.foldl (fun acc r => acc + getC r) 0 + let baseSum := cx.storedInC.foldl (fun acc c => acc + inl c) 0 + let entries := stored.foldl (fun acc x => acc + inl x) 0 + (roots + baseSum + entries, cx.closure.size + stored.size) + +/-! The search runs `phiEL2`, which computes `phiEL` (`phiEL2_eq`) without +allocating a row per closure term: three tables in place of one table of +triples, the scan's best cost without its work count (`cutScanBest`), and the +widths read through flags over the area positions (`memberFlags`) in place of +a scan of the members per read. -/ + +/-- The best cost of `cutScanG` (without the work count). -/ +@[specialize] def cutScanBest (spineLen : Array Nat) (getS : Nat → Nat) + (getB : Nat → Option Nat) (widthG : Nat → Option Nat) (l s : Nat) : + Nat → Option Nat → Nat → Nat + | 0, _, best => best + | _ + 1, none, best => best + | fuel + 1, some u, best => + let cand := tag4Size (l - spineLen[u]!) + (s - getS u) + (widthG u).getD 0 + cutScanBest spineLen getS getB widthG l s fuel (getB u) (if cand < best then cand else best) + +/-- `evalRowG` with `cutScanBest`. -/ +@[inline] def evalRowB (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (widthG : Nat → Option Nat) (getC getS : Nat → Nat) (getB : Nat → Option Nat) (t : Nat) : + Nat × Nat × Option Nat := + let node := dag.node t + let fam := family[t]! + if fam == .none then + let inl := node.children.foldl (fun acc c => acc + getC c) node.head.ownBytes + let c := match widthG t with + | some w => min inl w + | none => inl + (c, getS t, getB t) + else + let nxt := node.spineNext + let same := family[nxt]! == fam + let s := node.sideExtra + getC node.sideChild + (if same then getS nxt else 0) + let bl : Option Nat := + if same then (if (widthG nxt).isSome then some nxt else getB nxt) else none + let l := spineLen[t]! + let inl := cutScanBest spineLen (fun u => if u = t then s else getS u) + (fun u => if u = t then bl else getB u) widthG l s l bl (tag4Size l + s + getC tail[t]!) + let c := match widthG t with + | some w => min inl w + | none => inl + (c, s, bl) + +/-- Flags over the area positions: the members satisfying `avail`. -/ +def memberFlags (cx : SCtx) (posA : Array Nat) (avail : Nat → Bool) : Array Bool := + cx.members.foldl (fun fl m => match posOf posA m with + | some j => if avail m then fl.set! j true else fl + | none => fl) (Array.replicate cx.area.size false) + +/-- The widths of `SCtx.phiE` read through member flags `fl`. -/ +@[inline] def flagWidth (cx : SCtx) (posA : Array Nat) (fl : Array Bool) (u : Nat) : + Option Nat := + match posOf posA u with + | some j => if fl[j]! then some cx.up.w else widthOf cx.widthCs u + | none => widthOf cx.widthCs u + +/-- The row of `phiTable3` at `t`, from the three tables so far. -/ +@[inline] def phiRow3 (cx : SCtx) (posA posC : Array Nat) (fl : Array Bool) (Lc Ls : Array Nat) + (Lb : Array (Option Nat)) (t : Nat) : Nat × Nat × Option Nat := + let p := cx.up.prep + let base := cx.baseEv + if cx.allTrue[t]! then + evalRowB p.dag p.family p.spineLen p.tail (flagWidth cx posA fl) + (readAtF (posOf posC) Lc id (base.cost[·]!)) + (readAtF (posOf posC) Ls id (base.sides[·]!)) + (readAtF (posOf posC) Lb id (base.below[·]!)) t + else (base.cost[t]!, base.sides[t]!, base.below[t]!) + +/-- `phiTable` as three tables (costs, spine sums, descendant links). -/ +def phiTable3 (cx : SCtx) (posA posC : Array Nat) (fl : Array Bool) : + Array Nat × Array Nat × Array (Option Nat) := + let k := cx.closure.size + foldRange (fun (st : Array Nat × Array Nat × Array (Option Nat)) i => + match st with + | (Lc, Ls, Lb) => + match phiRow3 cx posA posC fl Lc Ls Lb cx.closure[i]! with + | (c, s, b) => (Lc.push c, Ls.push s, Lb.push b)) + 0 k (Array.mkEmpty k, Array.mkEmpty k, Array.mkEmpty k) + +/-- `phiEL` on the three tables and the member flags. -/ +def phiEL2 (cx : SCtx) (posA posC : Array Nat) (avail : Nat → Bool) (stored : Array Nat) : + Nat × Nat := + let p := cx.up.prep + let base := cx.baseEv + let fl := memberFlags cx posA avail + let L := phiTable3 cx posA posC fl + let getC := readAtF (posOf posC) L.1 id (base.cost[·]!) + let getS := readAtF (posOf posC) L.2.1 id (base.sides[·]!) + let getB := readAtF (posOf posC) L.2.2 id (base.below[·]!) + let inl := fun x => evalHiddenG p.dag p.family p.spineLen p.tail (flagWidth cx posA fl) + cx.allTrue[x]! (decide (x < base.cost.size)) getC getS getB x + let roots := cx.rootsC.foldl (fun acc r => acc + getC r) 0 + let baseSum := cx.storedInC.foldl (fun acc c => acc + inl c) 0 + let entries := stored.foldl (fun acc x => acc + inl x) 0 + (roots + baseSum + entries, cx.closure.size + stored.size) + +/-- The four bounds `boundsStep` writes at `t`, from readers of the head and +continuation bounds. -/ +@[inline] def boundsValsG (p : Prep) (w : Nat) (msT : Bool) (getH getC : Nat → Nat) (t : Nat) : + Nat × Nat × Nat × Nat := + let node := p.dag.node t + let fam := p.family[t]! + let (i, m) := + if fam == .none then + let i := node.children.foldl (fun acc c => acc + getH c) node.head.ownBytes + (i, i) + else + let nxt := node.spineNext + let rest := if p.family[nxt]! == fam then getC nxt else getH nxt + let m := node.sideExtra + getH node.sideChild + rest + (1 + m, m) + (i, m, if msT then min w i else i, if msT then min w m else m) + +/-- Whether `t` may be stored: a candidate not in `outAll` (the table +`outAll.foldl (·.set! · false) cand`). -/ +@[inline] def maybeStoredAt (cx : SCtx) (outAll : Array Nat) (t : Nat) : Bool := + cx.cand[t]! && !outAll.contains t + +/-- `SCtx.rebound` for the maybe-stored set `cand` minus `outAll`, by area +position: `(inline, merged, head, continuation)`. -/ +def reboundL (cx : SCtx) (posA : Array Nat) (outAll : Array Nat) : + Array (Nat × Nat × Nat × Nat) := + let b0 := cx.bounds0 + localFold cx.area.size (cx.area[·]!) fun L _ t => + boundsValsG cx.up.prep cx.up.w (maybeStoredAt cx outAll t) + (readAtF (posOf posA) L (·.2.2.1) (b0.headLB[·]!)) + (readAtF (posOf posA) L (·.2.2.2) (b0.contLB[·]!)) t + +/-- `SCtx.opaqueUnder` on the local bounds. -/ +@[inline] def opaqueUnderL (cx : SCtx) (posA : Array Nat) (b : Array (Nat × Nat × Nat × Nat)) + (t : Nat) : Bool := + if cx.up.prep.family[t]! == .none then + readAtF (posOf posA) b (·.1) (cx.bounds0.inlineLB[·]!) t ≥ cx.up.w + else readAtF (posOf posA) b (·.2.1) (cx.bounds0.mergedLB[·]!) t ≥ cx.up.w + +/-- The reader of `SCtx.opaqueArr inAll outAll`, given +`b = reboundL cx posA outAll`. -/ +@[inline] def opqArrR (cx : SCtx) (posA : Array Nat) (b : Array (Nat × Nat × Nat × Nat)) + (inAll : Array Nat) (t : Nat) : Bool := + cx.up.opaq[t]! || (decide (t < cx.up.opaq.size) && inAll.contains t && opaqueUnderL cx posA b t) + +/-- Area positions in descending order: position `i` of the reversed area. -/ +@[inline] def posRev (k : Nat) (pos : Array Nat) (u : Nat) : Option Nat := + match posOf pos u with + | some j => some (k - 1 - j) + | none => none + +/-- `SCtx.revisible` for the maybe-stored set `cand` minus `outAll`, by +position in the reversed area: `(all, head)`. -/ +def revisibleL (cx : SCtx) (posA : Array Nat) (outAll : Array Nat) : Array (Nat × Nat) := + let k := cx.area.size + localFold k (fun i => cx.area[k - 1 - i]!) fun L i _ => + let j := k - 1 - i + let r := cx.rootOcc[j]! + cx.inEdges[j]!.foldl (fun (dh : Nat × Nat) (e : Nat × Nat × Nat) => + let wq := if maybeStoredAt cx outAll e.1 then 1 + else min (readAtF (posRev k posA) L (·.1) (cx.vis0.1[·]!) e.1) visibleCap + (dh.1 + e.2.1 * wq, dh.2 + e.2.2 * wq)) (r, r) + +/-- `storedGainWith` with readers of the inline and merged bounds. -/ +@[inline] def storedGainG (p : Prep) (inlR mrgR : Nat → Nat) (w t d h : Nat) : _root_.Int := + let deg := _root_.Int.ofNat d + let wI := _root_.Int.ofNat w + if p.family[t]! == .none then + (deg - 1) * _root_.Int.ofNat (inlR t) - deg * wI + else if h ≥ 1 then + (deg - 1) * _root_.Int.ofNat (mrgR t) + (_root_.Int.ofNat h - 1) - deg * wI + else + (deg - 1) * _root_.Int.ofNat (mrgR t) - _root_.Int.ofNat (tag4Size p.spineLen[t]!) - deg * wI + +/-- `SCtx.reclassify` on the local bounds and counts. -/ +def reclassifyL (cx : SCtx) (posA : Array Nat) (outAll localIn und : Array Nat) : + Array Nat × Array (Nat × _root_.Int) × Array (Nat × Nat × Nat × Nat) := + let b := reboundL cx posA outAll + let vis := revisibleL cx posA outAll + let k := cx.area.size + let gains := und.map fun t => + let d := readAtF (posRev k posA) vis (·.1) (cx.vis0.1[·]!) t + let h := readAtF (posRev k posA) vis (·.2) (cx.vis0.2[·]!) t + (t, storedGainG cx.up.prep (readAtF (posOf posA) b (·.1) (cx.bounds0.inlineLB[·]!)) + (readAtF (posOf posA) b (·.2.1) (cx.bounds0.mergedLB[·]!)) cx.up.w t d h, + 1 ≤ d && h ≤ d) + let isForced := fun (e : Nat × _root_.Int × Bool) => e.2.2 && e.2.1 ≥ cx.theta + let forced := (gains.filter isForced).map (·.1) + let localIn := if forced.isEmpty then localIn else mergeSorted localIn forced + let open_ := (gains.filter (!isForced ·)).map fun e => (e.1, e.2.1) + (localIn, open_, b) + +/-- `reachLabelsOn` over the closure, by closure position. -/ +def reachLabelsL (dag : Dag) (closure posC : Array Nat) (opq : Nat → Bool) + (lab : Nat → Option Nat) : Array (Option (Option Nat)) := + localFold closure.size (closure[·]!) fun L _ t => + (dag.node t).children.foldl (fun v c => + labelJoin v (if opq c then (lab c).map some else readAtF (posOf posC) L id (fun _ => none) c)) + ((lab t).map some) + +/-- The labels of `sepLabels n members g inRed outRed`. -/ +@[inline] def sepLab (n : Nat) (members g inRed outRed : Array Nat) (u : Nat) : Option Nat := + if u < n then + (if inRed.contains u || outRed.contains u then none + else if g.contains u then some 1 + else if members.contains u then some 2 + else none) + else none + +/-- `SCtx.sepCheck` on the local tables. -/ +def sepCheckL (cx : SCtx) (posA posC : Array Nat) (g inRed outRed : Array Nat) : Bool := + let n := cx.up.prep.dag.size + let bR := reboundL cx posA outRed + let opqR := fun t => opqArrR cx posA bR inRed t + let lab := sepLab n cx.members g inRed outRed + let rl := reachLabelsL cx.up.prep.dag cx.closure posC opqR lab + g.all (fun t => (decide (t < n) && cx.members.contains t) && lab t == some 1) && + cx.members.all fun v => (decide (v < n) && outRed.contains v) || opqR v || + readAtF (posOf posC) rl id (fun _ => none) v != some none + +mutual +/-- `SCtx.solveP` on the local tables. -/ +def solvePL (cx : SCtx) (posA posC : Array Nat) (limits : Limits) : + Nat → Array Nat → Array Nat → Array Nat → SState → Except SharingError (CTable × SState) + | 0, _, _, _, _ => throw (.internal "component search fuel exhausted") + | fuel + 1, g, inAll, outAll, st => do + let bA := reboundL cx posA outAll + let opqA := fun t => opqArrR cx posA bA inAll t + let inSet : Std.HashSet Nat := inAll.foldl (·.insert ·) {} + let outSet : Std.HashSet Nat := outAll.foldl (·.insert ·) {} + let (entries, _) := cx.memoKey opqA inSet outSet g + let (inRed, outRed) := keyContext entries + unless strictInc g && strictInc inRed && strictInc outRed && + inRed.all inSet.contains && outRed.all outSet.contains do + throw (.internal "memo key context is not part of the decided context") + match st.memo.get? (g, entries) with + | some tb => pure (tb, { st with memoHits := st.memoHits + 1 }) + | none => + unless sepCheckL cx posA posC g inRed outRed do + throw (.internal "search group is not separated") + let (tb, st) ← solveBodyL cx posA posC limits fuel g inRed outRed st + pure (tb, { st with memo := st.memo.insert (g, entries) tb }) + +/-- `SCtx.solveBody` on the local tables. -/ +def solveBodyL (cx : SCtx) (posA posC : Array Nat) (limits : Limits) : + Nat → Array Nat → Array Nat → Array Nat → SState → Except SharingError (CTable × SState) + | 0, _, _, _, _ => throw (.internal "component search fuel exhausted") + | fuel + 1, g, inRed, outRed, st => do + let inSet : Std.HashSet Nat := inRed.foldl (·.insert ·) {} + let (phi0, work) := phiEL2 cx posA posC (fun t => inSet.contains t) inRed + let st ← chargeP limits (work + cx.area.size) st + let (tb, st) ← nodePL cx posA posC limits fuel phi0 inRed outRed outRed.size #[] g #[] st + pure (tb.trim cx.slack, st) + +/-- `SCtx.nodeP` on the local tables. -/ +def nodePL (cx : SCtx) (posA posC : Array Nat) (limits : Limits) : + Nat → Nat → Array Nat → Array Nat → Nat → Array Nat → Array Nat → CTable → SState → + Except SharingError (CTable × SState) + | 0, _, _, _, _, _, _, _, _ => throw (.internal "component search fuel exhausted") + | fuel + 1, phi0, inCtx, outAll, nOutCtx, localIn, und, tb, st => do + let (localIn, open_, b) := reclassifyL cx posA outAll localIn und + let und := open_.map (·.1) + let inAll := inCtx ++ localIn + let inSet : Std.HashSet Nat := inAll.foldl (·.insert ·) {} + let undSet : Std.HashSet Nat := und.foldl (·.insert ·) {} + let (phi, work) := phiEL2 cx posA posC (fun t => inSet.contains t || undSet.contains t) inAll + let st ← chargeP limits (work + 2 * cx.area.size) st + let delta : _root_.Int := (phi : _root_.Int) - (phi0 : _root_.Int) + if und.isEmpty then return (tb.add (delta, localIn), st) + if tb.prunes delta cx.slack then return (tb, st) + let opq := fun t => cx.up.opaq[t]! || (inSet.contains t && opaqueUnderL cx posA b t) + let availFixed := fun t => inSet.contains t && !opq t + let groups := cx.groups opq availFixed und + unless partitionCheck und groups do + throw (.internal "search groups do not partition the undecided members") + let route := + if groups.size > 1 then true + else if groups.size == 1 then + let outSet : Std.HashSet Nat := outAll.foldl (·.insert ·) {} + let (_, rel) := cx.memoKey opq inSet outSet groups[0]! + localIn.any (!rel.contains ·) || (outAll.extract nOutCtx outAll.size).any (!rel.contains ·) + else false + if route then + let (phiNone, work) := phiEL2 cx posA posC (fun t => inSet.contains t) inAll + let st ← chargeP limits work st + let base : _root_.Int := (phiNone : _root_.Int) - (phi0 : _root_.Int) + let (comb, st) ← splitPL cx posA posC limits fuel inAll outAll groups.toList + #[some (base, localIn)] st + return (comb.foldl (fun acc o => match o with + | some e => acc.add e + | none => acc) tb, st) + let some (t, gt) := pickBranch open_ | return (tb, st) + let und' := und.erase t + if gt > 0 then + let (tb, st) ← nodePL cx posA posC limits fuel phi0 inCtx outAll nOutCtx + (mergeSorted localIn #[t]) und' tb st + nodePL cx posA posC limits fuel phi0 inCtx (outAll.push t) nOutCtx localIn und' tb st + else + let (tb, st) ← nodePL cx posA posC limits fuel phi0 inCtx (outAll.push t) nOutCtx localIn + und' tb st + nodePL cx posA posC limits fuel phi0 inCtx outAll nOutCtx (mergeSorted localIn #[t]) und' + tb st + +/-- `SCtx.splitP` on the local tables. -/ +def splitPL (cx : SCtx) (posA posC : Array Nat) (limits : Limits) : + Nat → Array Nat → Array Nat → List (Array Nat) → CTable → SState → + Except SharingError (CTable × SState) + | 0, _, _, _, _, _ => throw (.internal "component search fuel exhausted") + | _ + 1, _, _, [], comb, st => pure (comb, st) + | fuel + 1, inAll, outAll, grp :: grps, comb, st => do + let (sub, st) ← solvePL cx posA posC limits fuel grp inAll outAll st + splitPL cx posA posC limits fuel inAll outAll grps (comb.conv sub) st +end + +/-- `searchComponent` on the local tables. Every member is in the area +(`componentArea` starts from the members), so the fallback to +`searchComponent` for a member outside it is defensive. -/ +def searchComponentL (cx : SCtx) (posA posC : Array Nat) (limits : Limits) (states costEvals : Nat) : + Except SharingError (CompResult × Nat × Nat) := + if cx.members.all (fun m => (posOf posA m).isSome) then do + unless areaParentsOK cx.up.prep.dag.size cx do + throw (.internal "component parents are not duplicate-free terms") + let st0 : SState := { states, costEvals } + let (tb, st) ← solvePL cx posA posC limits (8 * cx.members.size + 8) cx.members #[] #[] st0 + let some bd := tb.best | throw (.internal "component search found no choice") + let some bs := bestSetOf tb bd | throw (.internal "component search found no choice") + pure ({ members := cx.members, bestDelta := bd, bestSet := bs, bySize := tb }, + st.states, st.costEvals) + else searchComponent cx limits states costEvals + +/-- The conditions under which the local search reads the same values as the +specification: the tables have the DAG's size, and the area and the closure +are strictly increasing terms inside them. Every context that +`searchComponentsWithFast` builds satisfies them (the stage's tables are +built at the DAG's size, `componentArea` sorts its terms and the closure is +sorted and duplicate-free), so the fallback to `searchComponent` in +`fastStep` is defensive. -/ +def localSearchOK (cx : SCtx) : Bool := + let n := cx.up.prep.dag.size + cx.cand.size == n && cx.bounds0.inlineLB.size == n && cx.bounds0.mergedLB.size == n && + cx.bounds0.headLB.size == n && cx.bounds0.contLB.size == n && + cx.vis0.1.size == n && cx.vis0.2.size == n && + cx.baseEv.cost.size == n && cx.baseEv.sides.size == n && cx.baseEv.below.size == n && + cx.widthCs.size == n && cx.allTrue.size == n && cx.up.opaq.size == n && + strictInc cx.area && cx.area.all (· < n) && strictInc cx.closure && cx.closure.all (· < n) + +/-! ### The component loop -/ + +/-- One component of the loop of `searchComponents`: search it and record its +table, threading the search counters. -/ +@[expose] def specStep (limits : Limits) (ex : Expanded) (f : GraphFacts) (up : UPrep) + (cand : Array Bool) (b0 : UBounds) (vis0 : Array Nat × Array Nat) (rootCount : Array Nat) + (slack : Nat) (theta : _root_.Int) (baseEv : DictEval) (widthCs : Array (Option Nat)) + (allTrue : Array Bool) (unc : Array Nat) (opaq : Array Bool) + (acc : Array CompResult × Nat × Nat) (members : Array Nat) : + Except SharingError (Array CompResult × Nat × Nat) := do + let (results, states, costEvals) := acc + if limits.uniformSubsetSearch then + let (r, states, costEvals) ← searchComponentRef up f opaq ex.roots slack + limits members states costEvals + pure (results.push r, states, costEvals) + else + let cx := mkSCtx ex f up cand b0 vis0 rootCount slack theta + baseEv widthCs allTrue unc members + let (r, states, costEvals) ← searchComponent cx limits states costEvals + pure (results.push r, states, costEvals) + +/-- The component loop of `searchComponents` (`Ix.Sharing.Exact.Uniform`), +with the stage's tables as arguments. -/ +@[expose] def searchComponentsWith (limits : Limits) (ex : Expanded) (f : GraphFacts) (up : UPrep) + (cand : Array Bool) (b0 : UBounds) (vis0 : Array Nat × Array Nat) (rootCount : Array Nat) + (slack : Nat) (theta : _root_.Int) (baseEv : DictEval) (widthCs : Array (Option Nat)) + (allTrue : Array Bool) (unc : Array Nat) (opaq : Array Bool) (comps : Array (Array Nat)) : + Except SharingError (Array CompResult × Nat × Nat) := + comps.foldlM (init := ((#[] : Array CompResult), 0, 0)) + (specStep limits ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc opaq) + +/-- The parents of every term (`q` is listed under each child `c < n` of +`q`, once per edge). -/ +def parentsOf (dag : Dag) : Array (Array Nat) := + foldRange (fun P q => (dag.node q).children.foldl (fun P c => P.modify c (·.push q)) P) + 0 dag.size (Array.replicate dag.size #[]) + +/-- One push of the closure walk: mark and record `q` if it is a new term +below `n`. State: marks, terms found, stack. -/ +@[inline] def walkPush (n : Nat) (st : Array Nat × Array Nat × Array Nat) (q : Nat) : + Array Nat × Array Nat × Array Nat := + match st with + | (vis, out, stack) => + if q < n && vis[q]! == 0 then (vis.set! q 1, out.push q, stack.push q) else (vis, out, stack) + +/-- The closure walk: pop a term and push its parents, at most `fuel` times. -/ +def walkLoop (P : Array (Array Nat)) (n : Nat) : + Nat → Array Nat × Array Nat × Array Nat → Array Nat × Array Nat × Array Nat + | 0, st => st + | fuel + 1, (vis, out, stack) => + match stack.back? with + | none => (vis, out, stack) + | some c => walkLoop P n fuel ((P[c]!).foldl (walkPush n) (vis, out, stack.pop)) + +/-- The members below `vis.size` and their ancestors through `P`, marked `1` +in `vis` (which must be `0` there), in the order found; the stack is empty +when the walk finished. -/ +def upWalk (P : Array (Array Nat)) (members : Array Nat) (vis : Array Nat) : + Array Nat × Array Nat × Array Nat := + let n := vis.size + walkLoop P n (n + 1) (members.foldl (walkPush n) (vis, #[], #[])) + + +/-- Write the positions `j + 1` of the terms of `xs` into `pos`. -/ +def setPositions (pos : Array Nat) (xs : Array Nat) : Array Nat := + foldRange (fun pos j => pos.set! xs[j]! (j + 1)) 0 xs.size pos + +/-- Clear the entries of the terms of `xs` in `pos`. -/ +def clearPositions (pos : Array Nat) (xs : Array Nat) : Array Nat := + xs.foldl (fun pos t => pos.set! t 0) pos + +/-- `mkSCtx` with the closure found by an upward walk over the parent lists +`P` (valid when `P` lists the parents of every term and children precede +their parents), using `posC` (all `0`) as marks; returns the context and +`posC` holding the closure positions. The walk pushes every term at most +once, so its fuel (`n + 1` pops) always suffices and the fallback to +`upClosure` is defensive. -/ +def mkSCtxL (ex : Expanded) (f : GraphFacts) (up : UPrep) (cand : Array Bool) (b0 : UBounds) + (vis0 : Array Nat × Array Nat) (rootCount : Array Nat) (slack : Nat) (theta : _root_.Int) + (baseEv : DictEval) (widthCs : Array (Option Nat)) (allTrue : Array Bool) (unc : Array Nat) + (P : Array (Array Nat)) (posC : Array Nat) (members : Array Nat) : SCtx × Array Nat := + let area := componentArea up f members + let areaIdx : Std.HashMap Nat Nat := + (Array.range area.size).foldl (fun acc j => acc.insert area[j]! j) {} + let memberIdx : Std.HashMap Nat Nat := + (Array.range members.size).foldl (fun acc j => acc.insert members[j]! j) {} + let inEdges := area.map fun y => f.parents[y]!.map fun q => edgeCount ex.dag q y + let rootOcc := area.map (rootCount[·]!) + let (vis, found, stack) := upWalk P members posC + let (closure, posC) := + if stack.isEmpty then ((found.toList.mergeSort fun a b => decide (a ≤ b)).toArray, vis) + else (upClosure ex.dag ((markTable ex.dag.size members)[·]!), clearPositions vis found) + let posC := setPositions posC closure + let rootsC := ex.roots.filter (posC[·]! != 0) + let storedInC := closure.filter (up.opaq[·]!) + ({ up, facts := f, cand, bounds0 := b0, vis0, members, memberIdx, area, areaIdx, + inEdges, rootOcc, slack, theta, baseEv, widthCs, allTrue, closure, rootsC, storedInC, + allUnc := unc }, posC) + +/-- One component of the compiled loop: build its context with the closure +walk, run the local search when its conditions hold (else the specification's +search), and clear the two position tables again. -/ +def fastStep (limits : Limits) (ex : Expanded) (f : GraphFacts) (up : UPrep) + (cand : Array Bool) (b0 : UBounds) (vis0 : Array Nat × Array Nat) (rootCount : Array Nat) + (slack : Nat) (theta : _root_.Int) (baseEv : DictEval) (widthCs : Array (Option Nat)) + (allTrue : Array Bool) (unc : Array Nat) (P : Array (Array Nat)) + (acc : (Array CompResult × Nat × Nat) × Array Nat × Array Nat) (members : Array Nat) : + Except SharingError ((Array CompResult × Nat × Nat) × Array Nat × Array Nat) := do + let ((results, states, costEvals), posA, posC) := acc + let (cx, posC) := mkSCtxL ex f up cand b0 vis0 rootCount slack theta baseEv widthCs + allTrue unc P posC members + if localSearchOK cx then + let posA := setPositions posA cx.area + let (r, states, costEvals) ← searchComponentL cx posA posC limits states costEvals + pure ((results.push r, states, costEvals), clearPositions posA cx.area, + clearPositions posC cx.closure) + else + let (r, states, costEvals) ← searchComponent cx limits states costEvals + pure ((results.push r, states, costEvals), posA, clearPositions posC cx.closure) + +/-- `searchComponentsWith` with the closure walk and the local search, sharing +two position tables across the components. It runs the specification when +`uniformSubsetSearch` is set (the test oracle) or the DAG's children do not +precede their parents, which never happens for an expanded DAG (the interner +numbers children first), so that second fallback is defensive. -/ +def searchComponentsWithFast (limits : Limits) (ex : Expanded) (f : GraphFacts) (up : UPrep) + (cand : Array Bool) (b0 : UBounds) (vis0 : Array Nat × Array Nat) (rootCount : Array Nat) + (slack : Nat) (theta : _root_.Int) (baseEv : DictEval) (widthCs : Array (Option Nat)) + (allTrue : Array Bool) (unc : Array Nat) (opaq : Array Bool) (comps : Array (Array Nat)) : + Except SharingError (Array CompResult × Nat × Nat) := + if limits.uniformSubsetSearch || !childrenPrecede ex.dag.nodes then + searchComponentsWith limits ex f up cand b0 vis0 rootCount slack theta baseEv widthCs + allTrue unc opaq comps + else + (comps.foldlM (init := (((#[] : Array CompResult), 0, 0), + Array.replicate up.prep.dag.size 0, Array.replicate ex.dag.size 0)) + (fastStep limits ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc + (parentsOf ex.dag))).map (·.1) + + +/-! ### Equality with the specification -/ + +namespace LocalSearch + +theorem foldRange_succ {σ : Type} (f : σ → Nat → σ) (k m : Nat) (s : σ) : + foldRange f k (m + 1) s = f (foldRange f k m s) (k + m) := by + induction m generalizing k s with + | zero => rfl + | succ m ih => + show foldRange f (k + 1) (m + 1) (f s k) = f (foldRange f (k + 1) m (f s k)) (k + (m + 1)) + rw [ih, show k + 1 + m = k + (m + 1) by omega] + +theorem foldRange_zero {σ : Type} (f : σ → Nat → σ) (k : Nat) (s : σ) : foldRange f k 0 s = s := by + rfl + +theorem list_range_foldl {σ : Type} (g : σ → Nat → σ) (k : Nat) (s : σ) : + (List.range k).foldl g s = foldRange g 0 k s := by + induction k with + | zero => rfl + | succ k ih => rw [List.range_succ, List.foldl_append, ih, foldRange_succ]; simp + +theorem array_foldl_eq {α σ : Type} [Inhabited α] (f : σ → α → σ) (xs : Array α) (s : σ) : + xs.foldl f s = foldRange (fun s i => f s xs[i]!) 0 xs.size s := by + have key : ∀ m, m ≤ xs.size → + foldRange (fun s i => f s xs[i]!) 0 m s = (xs.toList.take m).foldl f s := by + intro m + induction m with + | zero => intro _; rfl + | succ m ih => + intro hm + rw [foldRange_succ, ih (by omega), List.take_add_one, List.foldl_append] + have hm' : m < xs.toList.length := by simp; omega + simp [List.getElem?_eq_getElem hm', getElem!_pos xs m (by omega)] + rw [key xs.size (Nat.le_refl _), List.take_of_length_le (by simp), Array.foldl_toList] + +/-- `posf` lists the positions of the terms `xsAt 0, …, xsAt (k - 1)`. -/ +def PosFn (k : Nat) (xsAt : Nat → Nat) (posf : Nat → Option Nat) : Prop := + ∀ u j, posf u = some j ↔ (j < k ∧ xsAt j = u) + +theorem readAtF_proj {α β : Type} [Inhabited α] (posf : Nat → Option Nat) (L : Array α) + (proj : α → β) (base : Nat → α) (u : Nat) : + readAtF posf L proj (fun v => proj (base v)) u = proj (readAtF posf L id base u) := by + unfold readAtF + split + · split <;> rfl + · rfl + +theorem readAtF_empty {α β : Type} [Inhabited α] (posf : Nat → Option Nat) (proj : α → β) + (base : Nat → β) (u : Nat) : readAtF posf (#[] : Array α) proj base u = base u := by + unfold readAtF + split + · simp + · rfl + +/-- **Local folds.** A fold that writes, at the terms `xsAt 0, …, xsAt (k-1)` +in order, values computed from the state before (`hstep`), reads at every +term what the local fold `localFold` computes from those values and the +initial state elsewhere. -/ +theorem fold_local {S V : Type} [Inhabited V] (get : S → Nat → V) (step : S → Nat → Nat → S) + (F : (Nat → V) → Nat → Nat → V) (Ok : S → Prop) (k : Nat) (xsAt : Nat → Nat) + (posf : Nat → Option Nat) (hpos : PosFn k xsAt posf) + (hstep : ∀ s i, Ok s → i < k → Ok (step s i (xsAt i)) ∧ + ∀ u, get (step s i (xsAt i)) u = if u = xsAt i then F (get s) i (xsAt i) else get s u) + (s0 : S) (h0 : Ok s0) (G : Array V → Nat → Nat → V) + (hG : ∀ L i, L.size = i → i < k → + G L i (xsAt i) = F (readAtF posf L id (get s0)) i (xsAt i)) : + Ok (foldRange (fun s i => step s i (xsAt i)) 0 k s0) ∧ ∀ u, get (foldRange (fun s i => step s i (xsAt i)) 0 k s0) u = + readAtF posf (localFold k xsAt G) id (get s0) u := by + have key : ∀ m, m ≤ k → + Ok (foldRange (fun s i => step s i (xsAt i)) 0 m s0) ∧ + (foldRange (fun L i => L.push (G L i (xsAt i))) 0 m (Array.mkEmpty k)).size = m ∧ + ∀ u, get (foldRange (fun s i => step s i (xsAt i)) 0 m s0) u = + readAtF posf (foldRange (fun L i => L.push (G L i (xsAt i))) 0 m (Array.mkEmpty k)) + id (get s0) u := by + intro m + induction m with + | zero => + intro _ + refine ⟨h0, by simp [foldRange_zero], fun u => ?_⟩ + rw [foldRange_zero, foldRange_zero] + exact (readAtF_empty posf id (get s0) u).symm + | succ m ih => + intro hm + obtain ⟨hok, hsz, hrd⟩ := ih (by omega) + rw [foldRange_succ, foldRange_succ, Nat.zero_add] + generalize foldRange (fun s i => step s i (xsAt i)) 0 m s0 = s at hok hrd + generalize foldRange (fun L i => L.push (G L i (xsAt i))) 0 m (Array.mkEmpty k) = L + at hsz hrd + obtain ⟨hok', hget⟩ := hstep s m hok (by omega) + have hrd' : get s = readAtF posf L id (get s0) := funext hrd + refine ⟨hok', by simp [hsz], fun u => ?_⟩ + rw [hget u, hG L m hsz (by omega), ← hrd'] + have hxm : posf (xsAt m) = some m := (hpos _ m).mpr ⟨by omega, rfl⟩ + by_cases hu : u = xsAt m + · subst hu + simp only [if_true] + unfold readAtF + rw [hxm] + subst hsz + simp + · simp only [hu, if_false] + rw [hrd u] + unfold readAtF + cases hp : posf u with + | none => rfl + | some j => + have hjm : j ≠ m := by + intro h + subst h + exact hu ((hpos u j).mp hp).2.symm + simp only [Array.size_push, hsz] + by_cases hj : j < m + · simp only [hj, if_true, show j < m + 1 by omega] + rw [getElem!_pos (L.push _) j (by simp [hsz]; omega), getElem!_pos L j (by omega)] + simp [Array.getElem_push_lt (show j < L.size by omega)] + · simp only [hj, if_false, show ¬ j < m + 1 by omega] + obtain ⟨hok, _, h⟩ := key k (Nat.le_refl _) + exact ⟨hok, h⟩ + +end LocalSearch + +/-! ### Reading the tables of `set!` folds -/ + +namespace LocalSearch + +theorem foldl_setFalse_read (l : List Nat) (a : Array Bool) (u : Nat) : + (l.foldl (fun acc t => acc.set! t false) a)[u]! = (a[u]! && !l.contains u) := by + induction l generalizing a with + | nil => simp + | cons t l ih => + rw [List.foldl_cons, ih, getElem!_setBang] + by_cases hut : u = t + · subst hut + by_cases h : u < a.size + · simp [h] + · simp [h] + · simp [hut] + +/-- The maybe-stored table of `SCtx.reclassify` and `SCtx.opaqueArr`. -/ +theorem ms_read (cand : Array Bool) (outAll : Array Nat) (u : Nat) : + (outAll.foldl (fun acc t => acc.set! t false) cand)[u]! = (cand[u]! && !outAll.contains u) := by + rw [← Array.foldl_toList, foldl_setFalse_read, Array.contains_toList] + +theorem markTable_read (n : Nat) (ts : Array Nat) (u : Nat) : + (markTable n ts)[u]! = (decide (u < n) && ts.contains u) := by + unfold markTable + rw [← Array.foldl_toList, ← Array.contains_toList] + generalize ts.toList = l + have key : ∀ (a : Array Bool), a.size = n → + (l.foldl (fun acc t => acc.set! t true) a)[u]! = (a[u]! || (decide (u < n) && l.contains u)) := by + induction l with + | nil => intro a _; simp + | cons t l ih => + intro a ha + rw [List.foldl_cons, ih _ (by simp [ha]), getElem!_setBang] + by_cases hut : u = t + · subst hut + by_cases h : u < n + · simp [h, ha] + · simp [h, ha] + · simp [hut] + rw [key _ (by simp)] + by_cases h : u < n + · simp [h] + · simp [h] + +theorem foldl_setConst_size {α : Type} (l : List Nat) (v : α) (a : Array α) : + (l.foldl (fun acc t => acc.set! t v) a).size = a.size := by + induction l generalizing a with + | nil => rfl + | cons t l ih => rw [List.foldl_cons, ih]; simp + +theorem foldl_setConst_read {α : Type} [Inhabited α] (l : List Nat) (v : α) (a : Array α) + (u : Nat) : + (l.foldl (fun acc t => acc.set! t v) a)[u]! = if u < a.size ∧ u ∈ l then v else a[u]! := by + induction l generalizing a with + | nil => simp + | cons t l ih => + rw [List.foldl_cons, ih, getElem!_setBang] + simp only [Array.set!_eq_setIfInBounds, Array.size_setIfInBounds, List.mem_cons] + by_cases hut : u = t + · subst hut + by_cases h : u < a.size <;> simp [h] + · by_cases h : u < a.size <;> simp [h, hut] + +theorem sepLabels_read (n : Nat) (members g inRed outRed : Array Nat) (u : Nat) : + (sepLabels n members g inRed outRed)[u]! = sepLab n members g inRed outRed u := by + unfold sepLabels sepLab + simp only [← Array.foldl_toList] + rw [foldl_setConst_read, foldl_setConst_read, foldl_setConst_read, foldl_setConst_size, + foldl_setConst_size] + have hrep : (Array.replicate n (none : Option Nat))[u]! = none := by + by_cases h : u < n + · rw [getElem!_pos _ u (by simpa using h)]; simp + · rw [getElem!_neg _ u (by simpa using h)]; rfl + simp only [Array.size_replicate, Array.toList_append, List.mem_append, Array.mem_toList_iff, + hrep] + by_cases h : u < n <;> by_cases hi : u ∈ inRed <;> by_cases ho : u ∈ outRed <;> + by_cases hg : u ∈ g <;> by_cases hm : u ∈ members <;> simp [h, hi, ho, hg, hm] + + +/-- The widths of `SCtx.phiE`. -/ +theorem phiWidth_eq (cx : SCtx) (avail : Nat → Bool) (u : Nat) : + widthOf (cx.members.foldl (fun acc t => if avail t then acc.set! t (some cx.up.w) else acc) + cx.widthCs) u = phiWidth cx avail u := by + unfold phiWidth + rw [← Array.foldl_toList, ← Array.contains_toList] + have key : ∀ (l : List Nat) (a : Array (Option Nat)), a.size = cx.widthCs.size → + widthOf (l.foldl (fun acc t => if avail t then acc.set! t (some cx.up.w) else acc) a) u = + if decide (u < cx.widthCs.size) && l.contains u && avail u then some cx.up.w + else widthOf a u := by + intro l + induction l with + | nil => intro a _; simp + | cons t l ih => + intro a ha + rw [List.foldl_cons] + by_cases hat : avail t + · simp only [hat, if_true] + rw [ih _ (by simp [ha])] + unfold widthOf + simp only [Array.set!_eq_setIfInBounds, Array.getElem?_setIfInBounds] + by_cases hut : u = t + · subst hut + by_cases h : u < a.size + · simp [h, ha.symm ▸ h, hat] + · simp [h, ha ▸ h, hat] + · simp [hut, Ne.symm hut] + · simp only [hat, Bool.false_eq_true, if_false] + rw [ih _ ha] + by_cases hut : u = t + · subst hut; simp [hat] + · simp [hut] + rw [key _ _ rfl] + +end LocalSearch + +/-! ### Steps of the specification's folds -/ + +namespace LocalSearch + +theorem cutScan_eq_G (spineLen sides : Array Nat) (below : Array (Option Nat)) + (width : Array (Option Nat)) (l s : Nat) : + ∀ fuel cur best work, cutScan spineLen sides below width l s fuel cur best work = + cutScanG spineLen (sides[·]!) (below[·]!) (widthOf width) l s fuel cur best work + | 0, _, _, _ => by simp only [cutScan, cutScanG] + | _ + 1, none, _, _ => by simp only [cutScan, cutScanG] + | fuel + 1, some u, best, work => by + simp only [cutScan, cutScanG] + exact cutScan_eq_G spineLen sides below width l s fuel _ _ _ + +theorem cutScanAt_eq_G (spineLen sides : Array Nat) (below : Array (Option Nat)) + (width : Array (Option Nat)) (t s' : Nat) (bl' : Option Nat) (l s : Nat) : + ∀ fuel cur best work, cutScanAt spineLen sides below width t s' bl' l s fuel cur best work = + cutScanG spineLen (fun u => if u = t ∧ t < sides.size then s' else sides[u]!) + (fun u => if u = t ∧ t < below.size then bl' else below[u]!) + (fun u => if u = t then none else widthOf width u) l s fuel cur best work + | 0, _, _, _ => by simp only [cutScanAt, cutScanG] + | _ + 1, none, _, _ => by simp only [cutScanAt, cutScanG] + | fuel + 1, some u, best, work => by + simp only [cutScanAt, cutScanG] + exact cutScanAt_eq_G spineLen sides below width t s' bl' l s fuel _ _ _ + +/-- The cheapest cut does not depend on the work counter. -/ +theorem cutScanG_fst (spineLen : Array Nat) (getS : Nat → Nat) (getB : Nat → Option Nat) + (widthG : Nat → Option Nat) (l s : Nat) : + ∀ fuel cur best w1 w2, (cutScanG spineLen getS getB widthG l s fuel cur best w1).1 = + (cutScanG spineLen getS getB widthG l s fuel cur best w2).1 + | 0, _, _, _, _ => by simp only [cutScanG] + | _ + 1, none, _, _, _ => by simp only [cutScanG] + | fuel + 1, some u, best, w1, w2 => by + simp only [cutScanG] + exact cutScanG_fst spineLen getS getB widthG l s fuel _ _ _ _ + +/-- The rows of an evaluation. -/ +def eget (st : DictEval) (u : Nat) : Nat × Nat × Option Nat := + (st.cost[u]!, st.sides[u]!, st.below[u]!) + +/-- Its three tables have size `n`. -/ +def ESize (n : Nat) (st : DictEval) : Prop := + st.cost.size = n ∧ st.sides.size = n ∧ st.below.size = n + +theorem setBang_read {α : Type} [Inhabited α] {n t : Nat} (ht : t < n) (a : Array α) (v : α) + (ha : a.size = n) (x : Nat) : (a.set! t v)[x]! = if x = t then v else a[x]! := by + rw [getElem!_setBang] + by_cases hx : x = t <;> simp [hx, ha, ht] + +theorem cutScan_set_fst (spineLen sides : Array Nat) (below : Array (Option Nat)) + (width : Array (Option Nat)) {t : Nat} (s' : Nat) (bl' : Option Nat) (l s : Nat) + (hs : t < sides.size) (hb : t < below.size) (fuel : Nat) (cur : Option Nat) (best work : Nat) : + (cutScan spineLen (sides.set! t s') (below.set! t bl') width l s fuel cur best work).1 = + (cutScanG spineLen (fun x => if x = t then s' else sides[x]!) + (fun x => if x = t then bl' else below[x]!) (widthOf width) l s fuel cur best 0).1 := by + rw [cutScan_eq_G, cutScanG_fst _ _ _ _ _ _ _ _ _ _ 0] + congr 2 + · funext x; rw [getElem!_setBang]; by_cases hx : x = t <;> simp [hx, hs] + · funext x; rw [getElem!_setBang]; by_cases hx : x = t <;> simp [hx, hb] + +theorem evalStep_get (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (affected : Array Bool) {n : Nat} (st : DictEval) + (hst : ESize n st) {t : Nat} (ht : t < n) : + ESize n (evalStep dag family spineLen tail width affected st t) ∧ + ∀ u, eget (evalStep dag family spineLen tail width affected st t) u = + if u = t then + (if affected[t]! then + evalRowG dag family spineLen tail (widthOf width) (st.cost[·]!) (st.sides[·]!) + (st.below[·]!) t + else eget st t) + else eget st u := by + obtain ⟨hc, hs, hb⟩ := hst + unfold evalStep + by_cases ha : affected[t]! = true + · simp only [ha, if_true] + by_cases hf : (family[t]! == Family.none) = true + · simp only [hf, if_true] + refine ⟨⟨by simp [hc], hs, hb⟩, fun u => ?_⟩ + unfold eget evalRowG + simp only [hf, if_true] + rw [setBang_read ht _ _ hc] + by_cases hu : u = t + · subst hu + simp only [if_true] + rcases widthOf width u with _ | w <;> rfl + · simp [hu] + · simp only [hf, Bool.false_eq_true, if_false] + refine ⟨⟨by simp [hc], by simp [hs], by simp [hb]⟩, fun u => ?_⟩ + unfold eget evalRowG + simp only [hf, Bool.false_eq_true, if_false] + rw [setBang_read ht _ _ hc, setBang_read ht _ _ hs, setBang_read ht _ _ hb] + by_cases hu : u = t + · subst hu + simp only [if_true] + rw [cutScan_set_fst _ _ _ _ _ _ _ _ (by omega) (by omega)] + rcases widthOf width u with _ | w <;> rfl + · simp [hu] + · simp only [ha, Bool.false_eq_true, if_false] + refine ⟨⟨hc, hs, hb⟩, fun u => ?_⟩ + by_cases hu : u = t + · subst hu; simp + · simp [hu] + + +theorem evalHidden_eq_G (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (width : Array (Option Nat)) (affected : Array Bool) (st : DictEval) (t : Nat) + (hs : st.sides.size = st.cost.size) (hb : st.below.size = st.cost.size) : + evalHidden dag family spineLen tail width affected st t = + evalHiddenG dag family spineLen tail (widthOf width) affected[t]! + (decide (t < st.cost.size)) (st.cost[·]!) (st.sides[·]!) (st.below[·]!) t := by + unfold evalHidden evalHiddenG + by_cases ha : affected[t]! = true + · simp only [ha, if_true] + split + · by_cases ht : t < st.cost.size <;> simp [ht] + · by_cases ht : t < st.cost.size + · simp only [ht, decide_true, if_true] + rw [cutScanAt_eq_G, cutScanG_fst _ _ _ _ _ _ _ _ _ _ 0] + congr 2 + · funext v; simp only [hs, ht, and_true] + · funext v; simp only [hb, ht, and_true] + · simp [ht] + · simp only [ha, Bool.false_eq_true, if_false] + +/-- The bounds of a term. -/ +def bget (b : UBounds) (u : Nat) : Nat × Nat × Nat × Nat := + (b.inlineLB[u]!, b.mergedLB[u]!, b.headLB[u]!, b.contLB[u]!) + +/-- Its four tables have size `n`. -/ +def BSize (n : Nat) (b : UBounds) : Prop := + b.inlineLB.size = n ∧ b.mergedLB.size = n ∧ b.headLB.size = n ∧ b.contLB.size = n + +theorem boundsStep_get (p : Prep) (w : Nat) (ms : Array Bool) {n : Nat} (b : UBounds) + (hb : BSize n b) {t : Nat} (ht : t < n) : + BSize n (boundsStep p w ms b t) ∧ + ∀ u, bget (boundsStep p w ms b t) u = + if u = t then boundsValsG p w ms[t]! (b.headLB[·]!) (b.contLB[·]!) t else bget b u := by + obtain ⟨h1, h2, h3, h4⟩ := hb + unfold boundsStep + refine ⟨⟨by simp [h1], by simp [h2], by simp [h3], by simp [h4]⟩, fun u => ?_⟩ + unfold bget boundsValsG + by_cases hu : u = t + · subst hu + simp only [getElem!_setBang, h1, h2, h3, h4, ht, and_self, if_true] + · simp only [getElem!_setBang, hu, false_and, if_false] + +end LocalSearch + +/-! ### The local tables read as the specification's -/ + +namespace LocalSearch + +/-- What the local search needs of a context: `localSearchOK` and the two +position tables. -/ +structure Ready (cx : SCtx) (posA posC : Array Nat) : Prop where + ok : localSearchOK cx = true + area : PosFn cx.area.size (cx.area[·]!) (posOf posA) + closure : PosFn cx.closure.size (cx.closure[·]!) (posOf posC) + +theorem localSearchOK_spec {cx : SCtx} (h : localSearchOK cx = true) : + cx.cand.size = cx.up.prep.dag.size ∧ BSize cx.up.prep.dag.size cx.bounds0 ∧ + cx.vis0.1.size = cx.up.prep.dag.size ∧ cx.vis0.2.size = cx.up.prep.dag.size ∧ + ESize cx.up.prep.dag.size cx.baseEv ∧ + cx.widthCs.size = cx.up.prep.dag.size ∧ cx.allTrue.size = cx.up.prep.dag.size ∧ + cx.up.opaq.size = cx.up.prep.dag.size ∧ + (∀ i, i < cx.area.size → cx.area[i]! < cx.up.prep.dag.size) ∧ + (∀ i, i < cx.closure.size → cx.closure[i]! < cx.up.prep.dag.size) := by + unfold localSearchOK at h + simp only [Bool.and_eq_true, beq_iff_eq, Array.all_eq_true, decide_eq_true_eq] at h + obtain ⟨⟨⟨⟨⟨⟨⟨⟨⟨⟨⟨⟨⟨⟨⟨⟨h1, h2⟩, h3⟩, h4⟩, h5⟩, h6⟩, h7⟩, h8⟩, h9⟩, h10⟩, h11⟩, h12⟩, h13⟩, _⟩, + h15⟩, _⟩, h17⟩ := h + refine ⟨h1, ⟨h2, h3, h4, h5⟩, h6, h7, ⟨h8, h9, h10⟩, h11, h12, h13, fun i hi => ?_, + fun i hi => ?_⟩ + · rw [getElem!_pos cx.area i hi]; exact h15 i hi + · rw [getElem!_pos cx.closure i hi]; exact h17 i hi + +theorem readAtF_field {α β : Type} [Inhabited α] (posf : Nat → Option Nat) (L : Array α) + (proj : α → β) (base : Nat → α) (base' : Nat → β) (h : ∀ v, base' v = proj (base v)) + (u : Nat) : readAtF posf L proj base' u = proj (readAtF posf L id base u) := by + rw [show base' = fun v => proj (base v) from funext h] + exact readAtF_proj posf L proj base u + +theorem readAtF_field_fun {α β : Type} [Inhabited α] (posf : Nat → Option Nat) (L : Array α) + (proj : α → β) (base : Nat → α) (base' : Nat → β) (h : ∀ v, base' v = proj (base v)) : + readAtF posf L proj base' = fun u => proj (readAtF posf L id base u) := + funext (readAtF_field posf L proj base base' h) + +theorem readAtF_at_new {α β : Type} [Inhabited α] {k : Nat} {xsAt : Nat → Nat} + {posf : Nat → Option Nat} (hpos : PosFn k xsAt posf) (L : Array α) (proj : α → β) + (base : Nat → β) {i : Nat} (hi : i < k) (hL : L.size = i) : + readAtF posf L proj base (xsAt i) = base (xsAt i) := by + unfold readAtF + rw [(hpos _ i).mpr ⟨hi, rfl⟩] + simp [hL] + +/-- **Bounds.** `SCtx.rebound` read through the local bounds. -/ +theorem rebound_read {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (outAll : Array Nat) (u : Nat) : + bget (cx.rebound (outAll.foldl (fun acc t => acc.set! t false) cx.cand)) u = + readAtF (posOf posA) (reboundL cx posA outAll) id (bget cx.bounds0) u := by + obtain ⟨_, hb0, _, _, _, _, _, _, harea, _⟩ := localSearchOK_spec hr.ok + unfold SCtx.rebound reboundL + rw [array_foldl_eq] + refine (fold_local bget (fun s _ t => boundsStep cx.up.prep cx.up.w + (outAll.foldl (fun acc t => acc.set! t false) cx.cand) s t) + (fun g _ t => boundsValsG cx.up.prep cx.up.w + (outAll.foldl (fun acc t => acc.set! t false) cx.cand)[t]! (fun v => (g v).2.2.1) + (fun v => (g v).2.2.2) t) + (BSize cx.up.prep.dag.size) cx.area.size (cx.area[·]!) (posOf posA) hr.area ?_ cx.bounds0 + hb0 _ ?_).2 u + · intro s i hs hi + exact boundsStep_get _ _ _ s hs (harea i hi) + · intro L i _ _ + simp only [ms_read, maybeStoredAt] + have e1 : readAtF (posOf posA) L (·.2.2.1) (cx.bounds0.headLB[·]!) = + fun v => (readAtF (posOf posA) L id (bget cx.bounds0) v).2.2.1 := + funext fun v => readAtF_proj (posOf posA) L (·.2.2.1) (bget cx.bounds0) v + have e2 : readAtF (posOf posA) L (·.2.2.2) (cx.bounds0.contLB[·]!) = + fun v => (readAtF (posOf posA) L id (bget cx.bounds0) v).2.2.2 := + funext fun v => readAtF_proj (posOf posA) L (·.2.2.2) (bget cx.bounds0) v + rw [e1, e2] + +theorem storedGainWith_eq_G (p : Prep) (b : UBounds) (w t d h : Nat) : + storedGainWith p b w t d h = storedGainG p (b.inlineLB[·]!) (b.mergedLB[·]!) w t d h := by + unfold storedGainWith storedGainG + rfl + +theorem opaqueUnder_read {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (outAll : Array Nat) (t : Nat) : + cx.opaqueUnder (cx.rebound (outAll.foldl (fun acc t => acc.set! t false) cx.cand)) t = + opaqueUnderL cx posA (reboundL cx posA outAll) t := by + unfold SCtx.opaqueUnder opaqueUnderL + have h := rebound_read hr outAll t + unfold bget at h + have h1 := congrArg (·.1) h + have h2 := congrArg (·.2.1) h + simp only at h1 h2 + rw [h1, h2, readAtF_field (posOf posA) _ (fun e : Nat × Nat × Nat × Nat => e.1) + (bget cx.bounds0) (fun x => cx.bounds0.inlineLB[x]!) (fun _ => rfl), + readAtF_field (posOf posA) _ (fun e : Nat × Nat × Nat × Nat => e.2.1) + (bget cx.bounds0) (fun x => cx.bounds0.mergedLB[x]!) (fun _ => rfl)] + rfl + +theorem foldl_setOr_read (l : List Nat) (f : Nat → Bool) (a : Array Bool) (u : Nat) : + (l.foldl (fun acc t => acc.set! t (acc[t]! || f t)) a)[u]! = + (a[u]! || (decide (u < a.size) && l.contains u && f u)) := by + induction l generalizing a with + | nil => simp + | cons t l ih => + rw [List.foldl_cons, ih, getElem!_setBang] + simp only [Array.set!_eq_setIfInBounds, Array.size_setIfInBounds, List.contains_cons] + by_cases hut : u = t + · subst hut + by_cases h : u < a.size + · simp only [h, and_self, if_true, decide_true, Bool.true_and] + cases a[u]! <;> cases f u <;> simp + · simp [h] + · have hne : (u == t) = false := by simpa using hut + simp [hut, hne] + +/-- **Opaque terms.** `SCtx.opaqueArr` read through the local bounds. -/ +theorem opaqueArr_read {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (inAll outAll : Array Nat) (t : Nat) : + (cx.opaqueArr inAll outAll)[t]! = opqArrR cx posA (reboundL cx posA outAll) inAll t := by + unfold SCtx.opaqueArr opqArrR + rw [← Array.foldl_toList, foldl_setOr_read, Array.contains_toList, opaqueUnder_read hr] + +end LocalSearch + +/-! ### The component cost, the visible counts and the reach labels -/ + +namespace LocalSearch + +/-- The closure evaluation of `SCtx.phiE` read through the closure-local table. -/ +theorem phiFold_read {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (avail : Nat → Bool) (width : Array (Option Nat)) + (hW : cx.members.foldl (fun acc t => if avail t then acc.set! t (some cx.up.w) else acc) + cx.widthCs = width) : + ESize cx.up.prep.dag.size (cx.closure.foldl (evalStep cx.up.prep.dag cx.up.prep.family + cx.up.prep.spineLen cx.up.prep.tail width cx.allTrue) cx.baseEv) ∧ + ∀ u, eget (cx.closure.foldl (evalStep cx.up.prep.dag cx.up.prep.family cx.up.prep.spineLen + cx.up.prep.tail width cx.allTrue) cx.baseEv) u = + readAtF (posOf posC) (phiTable cx posC avail) id (eget cx.baseEv) u := by + obtain ⟨_, _, _, _, hev, _, _, _, _, hclo⟩ := localSearchOK_spec hr.ok + have hwid : widthOf width = phiWidth cx avail := by rw [← hW]; exact funext (phiWidth_eq cx avail) + rw [array_foldl_eq] + unfold phiTable + refine fold_local eget (fun s _ t => evalStep cx.up.prep.dag cx.up.prep.family + cx.up.prep.spineLen cx.up.prep.tail width cx.allTrue s t) + (fun g _ t => if cx.allTrue[t]! then + evalRowG cx.up.prep.dag cx.up.prep.family cx.up.prep.spineLen cx.up.prep.tail (widthOf width) + (fun v => (g v).1) (fun v => (g v).2.1) (fun v => (g v).2.2) t else g t) + (ESize cx.up.prep.dag.size) cx.closure.size (cx.closure[·]!) (posOf posC) hr.closure ?_ + cx.baseEv hev _ ?_ + · intro s i hs hi + exact evalStep_get _ _ _ _ _ _ s hs (hclo i hi) + · intro L i hL hi + by_cases ha : cx.allTrue[cx.closure[i]!]! = true + · simp only [ha, if_true] + rw [hwid, + readAtF_field_fun (posOf posC) L (fun e : Nat × Nat × Option Nat => e.1) (eget cx.baseEv) + (fun x => cx.baseEv.cost[x]!) (fun _ => rfl), + readAtF_field_fun (posOf posC) L (fun e : Nat × Nat × Option Nat => e.2.1) (eget cx.baseEv) + (fun x => cx.baseEv.sides[x]!) (fun _ => rfl), + readAtF_field_fun (posOf posC) L (fun e : Nat × Nat × Option Nat => e.2.2) (eget cx.baseEv) + (fun x => cx.baseEv.below[x]!) (fun _ => rfl)] + · simp only [ha, Bool.false_eq_true, if_false] + rw [readAtF_at_new hr.closure L id (eget cx.baseEv) hi hL] + rfl + +/-- **Component cost.** `SCtx.phiE` is the local evaluation's cost. -/ +theorem phiE_eq_L {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (avail : Nat → Bool) (stored : Array Nat) : + cx.phiE avail stored = phiEL cx posC avail stored := by + obtain ⟨_, _, _, _, hev, _, _, _, _, _⟩ := localSearchOK_spec hr.ok + unfold SCtx.phiE phiEL + simp only [evalHidden_eq] + generalize hW : cx.members.foldl (fun acc t => if avail t then acc.set! t (some cx.up.w) else acc) + cx.widthCs = width + obtain ⟨hsz, hrd⟩ := phiFold_read hr avail width hW + have hwid : widthOf width = phiWidth cx avail := by rw [← hW]; exact funext (phiWidth_eq cx avail) + generalize cx.closure.foldl (evalStep cx.up.prep.dag cx.up.prep.family cx.up.prep.spineLen + cx.up.prep.tail width cx.allTrue) cx.baseEv = ev at hsz hrd + obtain ⟨hc, hs, hb⟩ := hsz + obtain ⟨hc0, _, _⟩ := hev + have hC : (fun u => ev.cost[u]!) = + readAtF (posOf posC) (phiTable cx posC avail) (·.1) (cx.baseEv.cost[·]!) := by + funext u + rw [readAtF_field (posOf posC) _ (fun e : Nat × Nat × Option Nat => e.1) (eget cx.baseEv) + (fun x => cx.baseEv.cost[x]!) (fun _ => rfl), ← hrd u] + rfl + have hS : (fun u => ev.sides[u]!) = + readAtF (posOf posC) (phiTable cx posC avail) (·.2.1) (cx.baseEv.sides[·]!) := by + funext u + rw [readAtF_field (posOf posC) _ (fun e : Nat × Nat × Option Nat => e.2.1) (eget cx.baseEv) + (fun x => cx.baseEv.sides[x]!) (fun _ => rfl), ← hrd u] + rfl + have hB : (fun u => ev.below[u]!) = + readAtF (posOf posC) (phiTable cx posC avail) (·.2.2) (cx.baseEv.below[·]!) := by + funext u + rw [readAtF_field (posOf posC) _ (fun e : Nat × Nat × Option Nat => e.2.2) (eget cx.baseEv) + (fun x => cx.baseEv.below[x]!) (fun _ => rfl), ← hrd u] + rfl + have hEH : ∀ x, evalHidden cx.up.prep.dag cx.up.prep.family cx.up.prep.spineLen + cx.up.prep.tail width cx.allTrue ev x = + evalHiddenG cx.up.prep.dag cx.up.prep.family cx.up.prep.spineLen cx.up.prep.tail + (phiWidth cx avail) cx.allTrue[x]! (decide (x < cx.baseEv.cost.size)) + (readAtF (posOf posC) (phiTable cx posC avail) (·.1) (cx.baseEv.cost[·]!)) + (readAtF (posOf posC) (phiTable cx posC avail) (·.2.1) (cx.baseEv.sides[·]!)) + (readAtF (posOf posC) (phiTable cx posC avail) (·.2.2) (cx.baseEv.below[·]!)) x := by + intro x + rw [evalHidden_eq_G _ _ _ _ _ _ _ _ (by omega) (by omega), hwid, ← hC, ← hS, ← hB, hc, hc0] + simp only [hEH] + have hCr : ∀ r, ev.cost[r]! = + readAtF (posOf posC) (phiTable cx posC avail) (·.1) (cx.baseEv.cost[·]!) r := + fun r => congrFun hC r + simp only [hCr] + +theorem cutScanBest_eq (spineLen : Array Nat) (getS : Nat → Nat) (getB : Nat → Option Nat) + (widthG : Nat → Option Nat) (l s : Nat) : ∀ fuel cur best work, + cutScanBest spineLen getS getB widthG l s fuel cur best = + (cutScanG spineLen getS getB widthG l s fuel cur best work).1 + | 0, _, _, _ => rfl + | _ + 1, none, _, _ => rfl + | fuel + 1, some u, best, work => by + simp only [cutScanBest, cutScanG] + exact cutScanBest_eq spineLen getS getB widthG l s fuel _ _ _ + +theorem evalRowB_eq (dag : Dag) (family : Array Family) (spineLen tail : Array Nat) + (widthG : Nat → Option Nat) (getC getS : Nat → Nat) (getB : Nat → Option Nat) (t : Nat) : + evalRowB dag family spineLen tail widthG getC getS getB t = + evalRowG dag family spineLen tail widthG getC getS getB t := by + unfold evalRowB evalRowG + simp only [cutScanBest_eq _ _ _ _ _ _ _ _ _ 0] + +theorem readAtF_map {α β : Type} [Inhabited α] [Inhabited β] (posf : Nat → Option Nat) + (L : Array α) (proj : α → β) (base : Nat → β) (u : Nat) : + readAtF posf (L.map proj) id base u = readAtF posf L proj base u := by + unfold readAtF + cases posf u with + | none => rfl + | some j => + simp only [Array.size_map, id] + by_cases hj : j < L.size + · simp only [hj, if_true] + rw [getElem!_pos (L.map proj) j (by simpa using hj), getElem!_pos L j hj] + simp + · simp only [hj, if_false] + +theorem readAtF_map_fun {α β : Type} [Inhabited α] [Inhabited β] (posf : Nat → Option Nat) + (L : Array α) (proj : α → β) (base : Nat → β) : + readAtF posf (L.map proj) id base = readAtF posf L proj base := + funext (readAtF_map posf L proj base) + +/-- The member flags mark the area positions of the members satisfying +`avail`. -/ +theorem memberFlags_spec {cx : SCtx} {posA : Array Nat} + (hA : PosFn cx.area.size (cx.area[·]!) (posOf posA)) (avail : Nat → Bool) : + (memberFlags cx posA avail).size = cx.area.size ∧ + ∀ j, j < cx.area.size → ((memberFlags cx posA avail)[j]! = true ↔ + (cx.members.contains cx.area[j]! = true ∧ avail cx.area[j]! = true)) := by + unfold memberFlags + rw [← Array.foldl_toList] + have hc : ∀ x, cx.members.contains x = cx.members.toList.contains x := fun x => by + rw [Array.contains_toList] + simp only [hc] + generalize cx.members.toList = l + have key : ∀ (l : List Nat) (fl : Array Bool), fl.size = cx.area.size → + (l.foldl (fun fl m => match posOf posA m with + | some j => if avail m then fl.set! j true else fl + | none => fl) fl).size = cx.area.size ∧ + ∀ j, j < cx.area.size → ((l.foldl (fun fl m => match posOf posA m with + | some j => if avail m then fl.set! j true else fl + | none => fl) fl)[j]! = true ↔ + (fl[j]! = true ∨ (l.contains cx.area[j]! = true ∧ avail cx.area[j]! = true))) := by + intro l + induction l with + | nil => intro fl hfl; exact ⟨hfl, fun j _ => by simp⟩ + | cons m l ih => + intro fl hfl + have hstep : ∀ j, j < cx.area.size → + ((match posOf posA m with + | some j => if avail m then fl.set! j true else fl + | none => fl)[j]! = true ↔ + (fl[j]! = true ∨ (cx.area[j]! = m ∧ avail m = true))) := by + intro j hj + cases hp : posOf posA m with + | none => + simp only + have : cx.area[j]! ≠ m := fun h => by + have := (hA m j).mpr ⟨hj, h⟩ + rw [hp] at this; cases this + simp [this] + | some j' => + simp only + obtain ⟨hj', hm⟩ := (hA m j').mp hp + by_cases ha : avail m = true + · simp only [ha, if_true, and_true] + rw [getElem!_setBang] + by_cases hjj : j = j' + · subst hjj + have hm' : cx.area[j]! = m := hm + have hT : (j = j ∧ j < fl.size) := ⟨rfl, by rw [hfl]; exact hj'⟩ + simp only [hT, and_self, if_true, true_iff] + exact Or.inr hm' + · have : cx.area[j]! ≠ m := fun h => by + have := (hA m j).mpr ⟨hj, h⟩ + rw [hp] at this + exact hjj (Option.some.inj this).symm + simp [hjj, this] + · simp [ha] + have hsz : (match posOf posA m with + | some j => if avail m then fl.set! j true else fl + | none => fl).size = cx.area.size := by + cases posOf posA m with + | none => exact hfl + | some j' => + simp only + split + · rw [Array.set!_eq_setIfInBounds, Array.size_setIfInBounds, hfl] + · exact hfl + obtain ⟨h1, h2⟩ := ih _ hsz + refine ⟨h1, fun j hj => ?_⟩ + rw [List.foldl_cons, h2 j hj, hstep j hj] + constructor + · rintro ((h | ⟨h1, h2⟩) | ⟨h1, h2⟩) + · exact Or.inl h + · exact Or.inr ⟨by simp [h1], by rw [h1]; exact h2⟩ + · refine Or.inr ⟨?_, h2⟩ + simp only [List.contains_iff_mem] at h1 ⊢ + exact List.mem_cons_of_mem m h1 + · rintro (h | ⟨h1, h2⟩) + · exact Or.inl (Or.inl h) + · by_cases hxm : cx.area[j]! = m + · exact Or.inl (Or.inr ⟨hxm, by rw [← hxm]; exact h2⟩) + · refine Or.inr ⟨?_, h2⟩ + simp only [List.contains_iff_mem, List.mem_cons] at h1 ⊢ + rcases h1 with h1 | h1 + · exact absurd h1 hxm + · exact h1 + obtain ⟨h1, h2⟩ := key l (Array.replicate cx.area.size false) (by simp) + refine ⟨h1, fun j hj => ?_⟩ + rw [h2 j hj] + simp [getElem!_pos (Array.replicate cx.area.size false) j (by simpa using hj)] + +/-- Every member has an area position. -/ +def MembersIn (cx : SCtx) (posA : Array Nat) : Prop := + ∀ m, cx.members.contains m = true → (posOf posA m).isSome = true + +/-- **Widths.** The member flags give the widths of `SCtx.phiE`. -/ +theorem flagWidth_eq {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (hm : MembersIn cx posA) (avail : Nat → Bool) : + flagWidth cx posA (memberFlags cx posA avail) = phiWidth cx avail := by + funext u + obtain ⟨_, _, _, _, _, hw, _, _, harea, _⟩ := localSearchOK_spec hr.ok + obtain ⟨_, hfl⟩ := memberFlags_spec hr.area avail + unfold flagWidth phiWidth + cases hp : posOf posA u with + | none => + have hc : cx.members.contains u = false := by + cases hc : cx.members.contains u + · rfl + · have := hm u hc + rw [hp] at this + cases this + simp only [hc, Bool.and_false, Bool.false_and, Bool.false_eq_true, if_false] + | some j => + obtain ⟨hj, hu⟩ := (hr.area u j).mp hp + have hu' : cx.area[j]! = u := hu + have hlt : decide (u < cx.widthCs.size) = true := by + rw [decide_eq_true_eq, hw, ← hu']; exact harea j hj + have hfj := hfl j hj + rw [hu'] at hfj + simp only [hlt, Bool.true_and] + cases hf : (memberFlags cx posA avail)[j]! with + | true => + obtain ⟨h1, h2⟩ := hfj.mp hf + simp only [h1, h2, Bool.and_self, if_true] + | false => + have hn : ¬ (cx.members.contains u = true ∧ avail u = true) := fun h => by + rw [hfj.mpr h] at hf; cases hf + cases hc : cx.members.contains u with + | false => simp only [Bool.false_and, Bool.false_eq_true, if_false] + | true => + cases ha : avail u with + | false => simp only [Bool.and_false, Bool.false_eq_true, if_false] + | true => exact absurd ⟨hc, ha⟩ hn + +/-- A fold that pushes one row per step, kept as three tables. -/ +theorem fold3_eq (k : Nat) (xsAt : Nat → Nat) + (G : Array (Nat × Nat × Option Nat) → Nat → Nat → Nat × Nat × Option Nat) + (G3 : Array Nat → Array Nat → Array (Option Nat) → Nat → Nat × Nat × Option Nat) + (hG : ∀ L i, G3 (L.map (·.1)) (L.map (·.2.1)) (L.map (·.2.2)) (xsAt i) = G L i (xsAt i)) : + foldRange (fun (st : Array Nat × Array Nat × Array (Option Nat)) i => + match st with + | (Lc, Ls, Lb) => + match G3 Lc Ls Lb (xsAt i) with + | (c, s, b) => (Lc.push c, Ls.push s, Lb.push b)) + 0 k (Array.mkEmpty k, Array.mkEmpty k, Array.mkEmpty k) = + ((localFold k xsAt G).map (·.1), (localFold k xsAt G).map (·.2.1), + (localFold k xsAt G).map (·.2.2)) := by + unfold localFold + have key : ∀ m, + foldRange (fun (st : Array Nat × Array Nat × Array (Option Nat)) i => + match st with + | (Lc, Ls, Lb) => + match G3 Lc Ls Lb (xsAt i) with + | (c, s, b) => (Lc.push c, Ls.push s, Lb.push b)) + 0 m (Array.mkEmpty k, Array.mkEmpty k, Array.mkEmpty k) = + ((foldRange (fun L i => L.push (G L i (xsAt i))) 0 m (Array.mkEmpty k)).map (·.1), + (foldRange (fun L i => L.push (G L i (xsAt i))) 0 m (Array.mkEmpty k)).map (·.2.1), + (foldRange (fun L i => L.push (G L i (xsAt i))) 0 m (Array.mkEmpty k)).map (·.2.2)) := by + intro m + induction m with + | zero => simp [foldRange_zero] + | succ m ih => + rw [foldRange_succ, foldRange_succ, ih, Nat.zero_add] + simp only + rw [hG] + rcases G (foldRange (fun L i => L.push (G L i (xsAt i))) 0 m (Array.mkEmpty k)) m (xsAt m) + with ⟨c, s, b⟩ + simp [Array.map_push] + exact key k + +/-- `phiTable3` is `phiTable` split into its three columns. -/ +theorem phiTable3_eq {cx : SCtx} {posA posC : Array Nat} (avail : Nat → Bool) + (hW : flagWidth cx posA (memberFlags cx posA avail) = phiWidth cx avail) : + phiTable3 cx posA posC (memberFlags cx posA avail) = + ((phiTable cx posC avail).map (·.1), (phiTable cx posC avail).map (·.2.1), + (phiTable cx posC avail).map (·.2.2)) := by + unfold phiTable3 phiTable + dsimp only + refine fold3_eq _ _ _ _ (fun L i => ?_) + unfold phiRow3 + simp only [readAtF_map_fun, evalRowB_eq, hW] + +/-- **Component cost, compiled.** -/ +theorem phiEL2_eq {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (hm : MembersIn cx posA) (avail : Nat → Bool) (stored : Array Nat) : + phiEL cx posC avail stored = phiEL2 cx posA posC avail stored := by + have hW := flagWidth_eq hr hm avail + unfold phiEL phiEL2 + simp only [phiTable3_eq avail hW, readAtF_map_fun, hW] + +theorem phiE_eq_L2 {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (hm : MembersIn cx posA) (avail : Nat → Bool) (stored : Array Nat) : + cx.phiE avail stored = phiEL2 cx posA posC avail stored := + (phiE_eq_L hr avail stored).trans (phiEL2_eq hr hm avail stored) + +/-- **Visible counts.** `SCtx.revisible` read through the local counts. -/ +theorem revisible_read {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (outAll : Array Nat) (u : Nat) : + ((cx.revisible (outAll.foldl (fun acc t => acc.set! t false) cx.cand)).1[u]!, + (cx.revisible (outAll.foldl (fun acc t => acc.set! t false) cx.cand)).2[u]!) = + readAtF (posRev cx.area.size posA) (revisibleL cx posA outAll) id + (fun v => (cx.vis0.1[v]!, cx.vis0.2[v]!)) u := by + obtain ⟨_, _, hv1, hv2, _, _, _, _, harea, _⟩ := localSearchOK_spec hr.ok + have hrev : PosFn cx.area.size (fun i => cx.area[cx.area.size - 1 - i]!) + (posRev cx.area.size posA) := by + intro v j + unfold posRev + constructor + · intro h + cases hp : posOf posA v with + | none => rw [hp] at h; cases h + | some j0 => + rw [hp] at h + injection h with h + obtain ⟨hj0, hx⟩ := (hr.area v j0).mp hp + subst h + refine ⟨by omega, ?_⟩ + show cx.area[cx.area.size - 1 - (cx.area.size - 1 - j0)]! = v + rw [show cx.area.size - 1 - (cx.area.size - 1 - j0) = j0 by omega] + exact hx + · rintro ⟨hj, hx⟩ + rw [(hr.area v (cx.area.size - 1 - j)).mpr ⟨by omega, hx⟩] + simp only [Option.some.injEq] + omega + unfold SCtx.revisible revisibleL + rw [list_range_foldl] + refine (fold_local (S := Array Nat × Array Nat) (V := Nat × Nat) + (fun s v => (s.1[v]!, s.2[v]!)) + (fun s i _ => match s with + | (ds, hs) => + let j := cx.area.size - 1 - i + let y := cx.area[j]! + let r := cx.rootOcc[j]! + let dh := cx.inEdges[j]!.foldl (fun (dh : Nat × Nat) (e : Nat × Nat × Nat) => + let wq := if (outAll.foldl (fun acc t => acc.set! t false) cx.cand)[e.1]! then 1 + else min ds[e.1]! visibleCap + (dh.1 + e.2.1 * wq, dh.2 + e.2.2 * wq)) (r, r) + (ds.set! y dh.1, hs.set! y dh.2)) + (fun g i _ => + cx.inEdges[cx.area.size - 1 - i]!.foldl (fun (dh : Nat × Nat) (e : Nat × Nat × Nat) => + let wq := if (outAll.foldl (fun acc t => acc.set! t false) cx.cand)[e.1]! then 1 + else min (g e.1).1 visibleCap + (dh.1 + e.2.1 * wq, dh.2 + e.2.2 * wq)) + (cx.rootOcc[cx.area.size - 1 - i]!, cx.rootOcc[cx.area.size - 1 - i]!)) + (fun s => s.1.size = cx.up.prep.dag.size ∧ s.2.size = cx.up.prep.dag.size) + cx.area.size (fun i => cx.area[cx.area.size - 1 - i]!) (posRev cx.area.size posA) hrev ?_ + cx.vis0 ⟨hv1, hv2⟩ _ ?_).2 u + · intro s i hs hi + obtain ⟨ds, hs'⟩ := s + obtain ⟨h1, h2⟩ := hs + have hy := harea (cx.area.size - 1 - i) (by omega) + refine ⟨⟨by simp [h1], by simp [h2]⟩, fun v => ?_⟩ + simp only + rw [setBang_read (by omega) _ _ h1, setBang_read (by omega) _ _ h2] + by_cases hv : v = cx.area[cx.area.size - 1 - i]! + · simp only [hv, if_true] + · simp only [hv, if_false] + · intro L i hL hi + simp only [ms_read, maybeStoredAt] + simp only [readAtF_field (posRev cx.area.size posA) L (fun e : Nat × Nat => e.1) + (fun v => (cx.vis0.1[v]!, cx.vis0.2[v]!)) (fun x => cx.vis0.1[x]!) (fun _ => rfl)] + +/-- **Reach labels.** `reachLabelsOn` over the closure read through the local labels. -/ +theorem reachLabels_read {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (opq : Nat → Bool) (lab : Nat → Option Nat) (u : Nat) : + (reachLabelsOn cx.up.prep.dag cx.closure opq lab)[u]! = + readAtF (posOf posC) (reachLabelsL cx.up.prep.dag cx.closure posC opq lab) id + (fun _ => none) u := by + obtain ⟨_, _, _, _, _, _, _, _, _, hclo⟩ := localSearchOK_spec hr.ok + have hbase : (fun (v : Nat) => (Array.replicate cx.up.prep.dag.size + (none : Option (Option Nat)))[v]!) = fun _ => none := by + funext v + by_cases h : v < cx.up.prep.dag.size + · rw [getElem!_pos _ v (by simpa using h)]; simp + · rw [getElem!_neg _ v (by simpa using h)]; rfl + unfold reachLabelsOn reachLabelsL + rw [array_foldl_eq, ← hbase] + refine (fold_local (fun (A : Array (Option (Option Nat))) v => A[v]!) + (fun (A : Array (Option (Option Nat))) _ t => A.set! t ((cx.up.prep.dag.node t).children.foldl (fun v c => + labelJoin v (if opq c then (lab c).map some else A[c]!)) ((lab t).map some))) + (fun g _ t => (cx.up.prep.dag.node t).children.foldl (fun v c => + labelJoin v (if opq c then (lab c).map some else g c)) ((lab t).map some)) + (fun (A : Array (Option (Option Nat))) => A.size = cx.up.prep.dag.size) cx.closure.size (cx.closure[·]!) (posOf posC) + hr.closure ?_ _ (by simp) _ ?_).2 u + · intro A i hA hi + refine ⟨by simp [hA], fun v => ?_⟩ + rw [setBang_read (hclo i hi) _ _ hA] + · intro L i _ _ + rfl + +end LocalSearch + +/-! ### Reclassification and the separation check -/ + +namespace LocalSearch + +theorem reclassify_eq_L {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (outAll localIn und : Array Nat) : + (reclassifyL cx posA outAll localIn und).1 = (cx.reclassify outAll localIn und).1 ∧ + (reclassifyL cx posA outAll localIn und).2.1 = (cx.reclassify outAll localIn und).2.1 ∧ + ∀ t, opaqueUnderL cx posA (reclassifyL cx posA outAll localIn und).2.2 t = + cx.opaqueUnder (cx.reclassify outAll localIn und).2.2 t := by + have hgain : (und.map fun t => + (t, storedGainG cx.up.prep + (readAtF (posOf posA) (reboundL cx posA outAll) (·.1) (cx.bounds0.inlineLB[·]!)) + (readAtF (posOf posA) (reboundL cx posA outAll) (·.2.1) (cx.bounds0.mergedLB[·]!)) + cx.up.w t (readAtF (posRev cx.area.size posA) (revisibleL cx posA outAll) (·.1) + (cx.vis0.1[·]!) t) + (readAtF (posRev cx.area.size posA) (revisibleL cx posA outAll) (·.2) + (cx.vis0.2[·]!) t), + 1 ≤ readAtF (posRev cx.area.size posA) (revisibleL cx posA outAll) (·.1) + (cx.vis0.1[·]!) t && + readAtF (posRev cx.area.size posA) (revisibleL cx posA outAll) (·.2) + (cx.vis0.2[·]!) t ≤ + readAtF (posRev cx.area.size posA) (revisibleL cx posA outAll) (·.1) + (cx.vis0.1[·]!) t)) = + und.map fun t => + (t, storedGainWith cx.up.prep + (cx.rebound (outAll.foldl (fun acc t => acc.set! t false) cx.cand)) cx.up.w t + (cx.revisible (outAll.foldl (fun acc t => acc.set! t false) cx.cand)).1[t]! + (cx.revisible (outAll.foldl (fun acc t => acc.set! t false) cx.cand)).2[t]!, + 1 ≤ (cx.revisible (outAll.foldl (fun acc t => acc.set! t false) cx.cand)).1[t]! && + (cx.revisible (outAll.foldl (fun acc t => acc.set! t false) cx.cand)).2[t]! ≤ + (cx.revisible (outAll.foldl (fun acc t => acc.set! t false) cx.cand)).1[t]!) := by + congr 1 + funext t + have hv := revisible_read hr outAll t + have hv1 := congrArg (·.1) hv + have hv2 := congrArg (·.2) hv + simp only at hv1 hv2 + rw [storedGainWith_eq_G, hv1, hv2, + readAtF_field (posRev cx.area.size posA) _ (fun e : Nat × Nat => e.1) + (fun v => (cx.vis0.1[v]!, cx.vis0.2[v]!)) (fun x => cx.vis0.1[x]!) (fun _ => rfl), + readAtF_field (posRev cx.area.size posA) _ (fun e : Nat × Nat => e.2) + (fun v => (cx.vis0.1[v]!, cx.vis0.2[v]!)) (fun x => cx.vis0.2[x]!) (fun _ => rfl)] + have hI : (fun v => (cx.rebound (outAll.foldl (fun acc t => acc.set! t false) cx.cand)).inlineLB[v]!) = + readAtF (posOf posA) (reboundL cx posA outAll) (·.1) (cx.bounds0.inlineLB[·]!) := by + funext v + rw [readAtF_field (posOf posA) _ (fun e : Nat × Nat × Nat × Nat => e.1) (bget cx.bounds0) + (fun x => cx.bounds0.inlineLB[x]!) (fun _ => rfl), ← rebound_read hr outAll v] + rfl + have hM : (fun v => (cx.rebound (outAll.foldl (fun acc t => acc.set! t false) cx.cand)).mergedLB[v]!) = + readAtF (posOf posA) (reboundL cx posA outAll) (·.2.1) (cx.bounds0.mergedLB[·]!) := by + funext v + rw [readAtF_field (posOf posA) _ (fun e : Nat × Nat × Nat × Nat => e.2.1) (bget cx.bounds0) + (fun x => cx.bounds0.mergedLB[x]!) (fun _ => rfl), ← rebound_read hr outAll v] + rfl + rw [hI, hM] + unfold reclassifyL SCtx.reclassify + simp only + rw [hgain] + refine ⟨rfl, rfl, fun t => ?_⟩ + exact (opaqueUnder_read hr outAll t).symm + +theorem sepCheck_eq_L {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (g inRed outRed : Array Nat) : + cx.sepCheck g inRed outRed = sepCheckL cx posA posC g inRed outRed := by + unfold SCtx.sepCheck sepCheckL + simp only + have hO : (fun t => (cx.opaqueArr inRed outRed)[t]!) = + fun t => opqArrR cx posA (reboundL cx posA outRed) inRed t := + funext (opaqueArr_read hr inRed outRed) + have hL : (fun t => (sepLabels cx.up.prep.dag.size cx.members g inRed outRed)[t]!) = + sepLab cx.up.prep.dag.size cx.members g inRed outRed := + funext (sepLabels_read _ _ _ _ _) + rw [hO, hL] + simp only [reachLabels_read hr, markTable_read, opaqueArr_read hr, sepLabels_read] + +end LocalSearch + +/-! ### The search -/ + +namespace LocalSearch + +theorem search_eq_L {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (hm : MembersIn cx posA) (limits : Limits) : ∀ fuel, + (∀ g inAll outAll st, solvePL cx posA posC limits fuel g inAll outAll st = + cx.solveP limits fuel g inAll outAll st) ∧ + (∀ g inRed outRed st, solveBodyL cx posA posC limits fuel g inRed outRed st = + cx.solveBody limits fuel g inRed outRed st) ∧ + (∀ phi0 inCtx outAll nOutCtx localIn und tb st, + nodePL cx posA posC limits fuel phi0 inCtx outAll nOutCtx localIn und tb st = + cx.nodeP limits fuel phi0 inCtx outAll nOutCtx localIn und tb st) ∧ + (∀ inAll outAll grps comb st, splitPL cx posA posC limits fuel inAll outAll grps comb st = + cx.splitP limits fuel inAll outAll grps comb st) + | 0 => by + refine ⟨fun _ _ _ _ => ?_, fun _ _ _ _ => ?_, fun _ _ _ _ _ _ _ _ => ?_, + fun _ _ _ _ _ => ?_⟩ + · simp only [solvePL, SCtx.solveP] + · simp only [solveBodyL, SCtx.solveBody] + · simp only [nodePL, SCtx.nodeP] + · simp only [splitPL, SCtx.splitP] + | fuel + 1 => by + obtain ⟨ihP, ihB, ihN, ihS⟩ := search_eq_L hr hm limits fuel + refine ⟨fun g inAll outAll st => ?_, fun g inRed outRed st => ?_, + fun phi0 inCtx outAll nOutCtx localIn und tb st => ?_, + fun inAll outAll grps comb st => ?_⟩ + · simp only [solvePL, SCtx.solveP, opaqueArr_read hr, sepCheck_eq_L hr, ihB] <;> rfl + · simp only [solveBodyL, SCtx.solveBody, phiE_eq_L2 hr hm, ihN] <;> rfl + · obtain ⟨h1, h2, h3⟩ := reclassify_eq_L hr outAll localIn und + simp only [nodePL, SCtx.nodeP] + rcases hS : cx.reclassify outAll localIn und with ⟨li, op, b⟩ + rcases hF : reclassifyL cx posA outAll localIn und with ⟨li', op', b'⟩ + rw [hS, hF] at h1 h2 + rw [hS, hF] at h3 + simp only at h1 h2 h3 + subst h1 h2 + simp only [phiE_eq_L2 hr hm, h3, ihN, ihS] <;> rfl + · cases grps with + | nil => simp only [splitPL, SCtx.splitP] + | cons grp grps => simp only [splitPL, SCtx.splitP, ihP, ihS] + +/-- **Component search.** -/ +theorem searchComponentL_eq {cx : SCtx} {posA posC : Array Nat} (hr : Ready cx posA posC) + (limits : Limits) (states costEvals : Nat) : + searchComponentL cx posA posC limits states costEvals = + searchComponent cx limits states costEvals := by + unfold searchComponentL + split + · rename_i hall + have hm : MembersIn cx posA := fun m hc => by + rw [Array.all_eq_true'] at hall + exact hall m (Array.contains_iff_mem.mp hc) + unfold searchComponent + simp only [(search_eq_L hr hm limits _).1] <;> rfl + · rfl + +end LocalSearch + +/-! ### Position tables -/ + +namespace LocalSearch + +theorem strictInc_lt {a : Array Nat} (h : strictInc a = true) : + ∀ i j, i < j → j < a.size → a[i]! < a[j]! := by + unfold strictInc at h + simp only [List.all_eq_true, List.mem_range, decide_eq_true_eq] at h + intro i j hij hj + induction j with + | zero => omega + | succ j ih => + have hs := h j (by omega) hj + by_cases hij' : i = j + · subst hij'; exact hs + · exact Nat.lt_trans (ih (by omega) (by omega)) hs + +theorem strictInc_inj {a : Array Nat} (h : strictInc a = true) {i j : Nat} (hi : i < a.size) + (hj : j < a.size) (he : a[i]! = a[j]!) : i = j := by + rcases Nat.lt_trichotomy i j with hlt | heq | hgt + · have := strictInc_lt h i j hlt hj; omega + · exact heq + · have := strictInc_lt h j i hgt hi; omega + +/-- The entries `setPositions` writes (`xs` distinct, inside `pos`). -/ +theorem setPositions_read (pos xs : Array Nat) (hd : strictInc xs = true) + (hin : ∀ i, i < xs.size → xs[i]! < pos.size) : + (setPositions pos xs).size = pos.size ∧ + ∀ u, (setPositions pos xs)[u]! = + if h : ∃ j, j < xs.size ∧ xs[j]! = u then Classical.choose h + 1 else pos[u]! := by + unfold setPositions + have key : ∀ m, m ≤ xs.size → + (foldRange (fun pos j => pos.set! xs[j]! (j + 1)) 0 m pos).size = pos.size ∧ + ∀ u, (foldRange (fun pos j => pos.set! xs[j]! (j + 1)) 0 m pos)[u]! = + if h : ∃ j, j < m ∧ xs[j]! = u then Classical.choose h + 1 else pos[u]! := by + intro m + induction m with + | zero => + intro _ + refine ⟨rfl, fun u => ?_⟩ + have : ¬ ∃ j, j < 0 ∧ xs[j]! = u := by omega + simp only [foldRange_zero, this, dif_neg, not_false_eq_true] + | succ m ih => + intro hm + obtain ⟨hsz, hrd⟩ := ih (by omega) + rw [foldRange_succ, Nat.zero_add] + refine ⟨by rw [Array.set!_eq_setIfInBounds, Array.size_setIfInBounds, hsz], fun u => ?_⟩ + rw [getElem!_setBang, hrd u] + by_cases hu : u = xs[m]! + · have hex : ∃ j, j < m + 1 ∧ xs[j]! = u := ⟨m, by omega, hu.symm⟩ + have hlt : xs[m]! < pos.size := hin m (by omega) + simp only [hu, hsz, hlt, and_self, if_true] + rw [dif_pos (hu ▸ hex)] + have hc := Classical.choose_spec (hu ▸ hex) + have := strictInc_inj hd (i := Classical.choose (hu ▸ hex)) (j := m) (by omega) (by omega) + hc.2 + omega + · simp only [hu, false_and, if_false] + by_cases hex : ∃ j, j < m ∧ xs[j]! = u + · have hex' : ∃ j, j < m + 1 ∧ xs[j]! = u := by + obtain ⟨j, hj, hx⟩ := hex; exact ⟨j, by omega, hx⟩ + rw [dif_pos hex, dif_pos hex'] + have h1 := Classical.choose_spec hex + have h2 := Classical.choose_spec hex' + have : Classical.choose hex = Classical.choose hex' := + strictInc_inj hd (by omega) (by omega) (h1.2.trans h2.2.symm) + rw [this] + · have hex' : ¬ ∃ j, j < m + 1 ∧ xs[j]! = u := by + rintro ⟨j, hj, hx⟩ + by_cases hjm : j = m + · subst hjm; exact hu hx.symm + · exact hex ⟨j, by omega, hx⟩ + rw [dif_neg hex, dif_neg hex'] + exact key xs.size (Nat.le_refl _) + +theorem posOf_some (pos : Array Nat) (u j : Nat) : posOf pos u = some j ↔ pos[u]! = j + 1 := by + unfold posOf + by_cases h : pos[u]! = 0 + · simp [h] + · simp only [h, beq_iff_eq, if_false, Option.some.injEq] + omega + +/-- `setPositions` of an all-`0` table is a position table. -/ +theorem setPositions_posFn (xs : Array Nat) (n : Nat) (hd : strictInc xs = true) + (hin : ∀ i, i < xs.size → xs[i]! < n) : + PosFn xs.size (xs[·]!) (posOf (setPositions (Array.replicate n 0) xs)) := by + obtain ⟨_, hrd⟩ := setPositions_read (Array.replicate n 0) xs hd (by simpa using hin) + intro u j + rw [posOf_some, hrd u] + by_cases hex : ∃ j, j < xs.size ∧ xs[j]! = u + · rw [dif_pos hex] + have hc := Classical.choose_spec hex + constructor + · intro h + have : Classical.choose hex = j := by omega + subst this + exact hc + · rintro ⟨hj, hx⟩ + have := strictInc_inj hd hc.1 hj (hc.2.trans hx.symm) + omega + · rw [dif_neg hex] + have h0 : (Array.replicate n 0)[u]! = 0 := by + by_cases h : u < n + · rw [getElem!_pos _ u (by simpa using h)]; simp + · rw [getElem!_neg _ u (by simpa using h)]; rfl + rw [h0] + constructor + · intro h; omega + · intro h; exact absurd ⟨j, h⟩ hex + +/-- Clearing the entries of `xs` in a table that is `0` elsewhere gives the +all-`0` table. -/ +theorem clearPositions_zero (pos xs : Array Nat) (n : Nat) (hsz : pos.size = n) + (h0 : ∀ u, (∀ i, i < xs.size → xs[i]! ≠ u) → pos[u]! = 0) : + clearPositions pos xs = Array.replicate n 0 := by + unfold clearPositions + rw [← Array.foldl_toList] + have key : ∀ (l : List Nat) (a : Array Nat), a.size = n → + ((l.foldl (fun pos t => pos.set! t 0) a).size = n ∧ + ∀ u, (l.foldl (fun pos t => pos.set! t 0) a)[u]! = if u ∈ l then 0 else a[u]!) := by + intro l + induction l with + | nil => intro a ha; exact ⟨ha, fun u => by simp⟩ + | cons t l ih => + intro a ha + obtain ⟨h1, h2⟩ := ih (a.set! t 0) (by simp [ha]) + refine ⟨by rw [List.foldl_cons]; exact h1, fun u => ?_⟩ + rw [List.foldl_cons, h2 u, getElem!_setBang] + by_cases hu : u ∈ l + · simp [hu] + · by_cases hut : u = t + · subst hut + by_cases hlt : u < a.size + · simp [hu, hlt] + · simp [hu, hlt] + · simp [hu, hut] + obtain ⟨h1, h2⟩ := key xs.toList pos hsz + apply Array.ext + · rw [Array.size_replicate]; exact h1 + · intro i hi1 hi2 + have := h2 i + rw [getElem!_pos _ i hi1] at this + rw [this] + by_cases hm : i ∈ xs.toList + · simp [hm] + · simp only [hm, if_false, Array.getElem_replicate] + have hne : ∀ j, j < xs.size → xs[j]! ≠ i := by + intro j hj hx + apply hm + rw [Array.mem_toList_iff, Array.mem_iff_getElem] + exact ⟨j, hj, by rw [getElem!_pos xs j hj] at hx; exact hx⟩ + exact h0 i hne + +end LocalSearch + +/-! ### The closure walk -/ + +namespace LocalSearch + +theorem node_children_lt {dag : Dag} (h : childrenPrecede dag.nodes = true) {t : Nat} + (ht : t < dag.size) {c : Nat} (hc : c ∈ (dag.node t).children) : c < t := by + unfold childrenPrecede at h + rw [Array.all_eq_true] at h + have := h t (by simpa [Dag.size] using ht) + simp only [Array.getElem_zipIdx, Nat.zero_add] at this + rw [Array.all_eq_true] at this + have hn : dag.node t = dag.nodes[t] := by + unfold Dag.node; simp only [Dag.size] at ht; simp [ht] + rw [hn] at hc + obtain ⟨k, hk, rfl⟩ := Array.mem_iff_getElem.mp hc + have := this k hk + simp only [decide_eq_true_eq] at this + exact this + +theorem modify_read {α : Type} [Inhabited α] (a : Array α) (i j : Nat) (f : α → α) : + (a.modify i f)[j]! = if i = j ∧ i < a.size then f a[j]! else a[j]! := by + simp only [getElem!_def, Array.getElem?_modify] + by_cases hij : i = j + · subst hij + by_cases hi : i < a.size <;> simp [hi] + · simp [hij] + +/-- **Parents.** `q` is listed under `c` iff `c` is a child of `q`, both in +the DAG. -/ +theorem mem_parentsOf (dag : Dag) (c q : Nat) : + q ∈ (parentsOf dag)[c]! ↔ c < dag.size ∧ q < dag.size ∧ c ∈ (dag.node q).children := by + unfold parentsOf + have inner : ∀ (m : Nat) (l : List Nat) (P : Array (Array Nat)), P.size = dag.size → + (l.foldl (fun P c => P.modify c (·.push m)) P).size = dag.size ∧ + ∀ c q, q ∈ (l.foldl (fun P c => P.modify c (·.push m)) P)[c]! ↔ + q ∈ P[c]! ∨ (q = m ∧ c < dag.size ∧ c ∈ l) := by + intro m l + induction l with + | nil => intro P hP; exact ⟨hP, fun c q => by simp⟩ + | cons c0 l ih => + intro P hP + obtain ⟨h1, h2⟩ := ih (P.modify c0 (·.push m)) (by simp [hP]) + refine ⟨h1, fun c q => ?_⟩ + rw [List.foldl_cons, h2, modify_read] + by_cases hc : c0 = c + · subst hc + by_cases hlt : c0 < P.size + · simp only [hlt, and_self, if_true, Array.mem_push, List.mem_cons, true_or, and_true] + rw [hP] at hlt + simp only [hlt, true_and] + constructor + · rintro ((h | h) | ⟨h1, _, _⟩) <;> simp_all + · rintro (h | h) <;> simp_all + · have : ¬ c0 < dag.size := by omega + simp [hlt, this] + · simp only [hc, false_and, if_false, List.mem_cons] + constructor + · rintro (h | ⟨h1, h2, h3⟩) + · exact Or.inl h + · exact Or.inr ⟨h1, h2, Or.inr h3⟩ + · rintro (h | ⟨h1, h2, h3 | h3⟩) + · exact Or.inl h + · exact absurd h3.symm hc + · exact Or.inr ⟨h1, h2, h3⟩ + have key : ∀ m, m ≤ dag.size → + (foldRange (fun P q => (dag.node q).children.foldl (fun P c => P.modify c (·.push q)) P) + 0 m (Array.replicate dag.size #[])).size = dag.size ∧ + ∀ c q, q ∈ (foldRange (fun P q => (dag.node q).children.foldl + (fun P c => P.modify c (·.push q)) P) 0 m (Array.replicate dag.size #[]))[c]! ↔ + c < dag.size ∧ q < m ∧ c ∈ (dag.node q).children := by + intro m + induction m with + | zero => + intro _ + refine ⟨by simp [foldRange_zero], fun c q => ?_⟩ + rw [foldRange_zero] + constructor + · intro h + by_cases hc : c < dag.size + · rw [getElem!_pos _ c (by simpa using hc)] at h; simp at h + · rw [getElem!_neg _ c (by simpa using hc)] at h + exact absurd h (by simp [show (default : Array Nat) = #[] from rfl]) + · rintro ⟨_, h, _⟩; omega + | succ m ih => + intro hm + obtain ⟨hs, hr⟩ := ih (by omega) + rw [foldRange_succ, Nat.zero_add, ← Array.foldl_toList] + obtain ⟨h1, h2⟩ := inner m (dag.node m).children.toList _ hs + refine ⟨h1, fun c q => ?_⟩ + rw [h2, hr, Array.mem_toList_iff] + constructor + · rintro (⟨a1, a2, a3⟩ | ⟨a1, a2, a3⟩) + · exact ⟨a1, by omega, a3⟩ + · rw [a1]; exact ⟨a2, by omega, a3⟩ + · rintro ⟨a1, a2, a3⟩ + by_cases hqm : q = m + · rw [hqm] at a3; exact Or.inr ⟨hqm, a1, a3⟩ + · exact Or.inl ⟨a1, by omega, a3⟩ + obtain ⟨_, h⟩ := key dag.size (Nat.le_refl _) + rw [h] + +/-- Members (by `isMember`) and their ancestors. -/ +inductive Up (dag : Dag) (isMember : Nat → Bool) : Nat → Prop + | mem {t : Nat} : t < dag.size → isMember t = true → Up dag isMember t + | par {t c : Nat} : t < dag.size → c ∈ (dag.node t).children → Up dag isMember c → + Up dag isMember t + +theorem Up.lt {dag : Dag} {isMember : Nat → Bool} {t : Nat} (h : Up dag isMember t) : + t < dag.size := by + cases h with + | mem h _ => exact h + | par h _ _ => exact h + +/-- **Closure.** With children before their parents, `upClosure` lists the +members and their ancestors, ascending. -/ +theorem mem_upClosure {dag : Dag} (hcp : childrenPrecede dag.nodes = true) + (isMember : Nat → Bool) (t : Nat) : + t ∈ (upClosure dag isMember).toList ↔ Up dag isMember t := by + unfold upClosure + have key : ∀ m, m ≤ dag.size → + (foldRange (fun (acc : Array Bool) t => + acc.set! t (isMember t || (dag.node t).children.any (acc[·]!))) 0 m + (Array.replicate dag.size false)).size = dag.size ∧ + ∀ t, (foldRange (fun (acc : Array Bool) t => + acc.set! t (isMember t || (dag.node t).children.any (acc[·]!))) 0 m + (Array.replicate dag.size false))[t]! = true ↔ t < m ∧ Up dag isMember t := by + intro m + induction m with + | zero => + intro _ + refine ⟨by simp [foldRange_zero], fun t => ?_⟩ + rw [foldRange_zero] + constructor + · intro h + by_cases ht : t < dag.size + · rw [getElem!_pos _ t (by simpa using ht)] at h; simp at h + · rw [getElem!_neg _ t (by simpa using ht)] at h; exact absurd h (by decide) + · rintro ⟨h, _⟩; omega + | succ m ih => + intro hm + obtain ⟨hs, hr⟩ := ih (by omega) + rw [foldRange_succ, Nat.zero_add] + refine ⟨by rw [Array.set!_eq_setIfInBounds, Array.size_setIfInBounds, hs], fun t => ?_⟩ + rw [getElem!_setBang] + by_cases htm : t = m + · subst htm + simp only [hs, show t < dag.size by omega, and_self, if_true, Bool.or_eq_true, + Array.any_eq_true] + constructor + · rintro (h | ⟨k, hk, hc⟩) + · exact ⟨by omega, .mem (by omega) h⟩ + · have hcm := (hr _).mp hc + exact ⟨by omega, .par (by omega) (Array.getElem_mem hk) hcm.2⟩ + · rintro ⟨_, hu⟩ + cases hu with + | mem _ h => exact Or.inl h + | par _ hc hu' => + right + obtain ⟨k, hk, rfl⟩ := Array.mem_iff_getElem.mp hc + exact ⟨k, hk, (hr _).mpr ⟨node_children_lt hcp (by omega) hc, hu'⟩⟩ + · simp only [htm, false_and, if_false] + rw [hr t] + constructor + · rintro ⟨h1, h2⟩; exact ⟨by omega, h2⟩ + · rintro ⟨h1, h2⟩; exact ⟨by omega, h2⟩ + obtain ⟨hs, hr⟩ := key dag.size (Nat.le_refl _) + rw [Array.toList_filter, List.mem_filter, Array.mem_toList_iff, Array.mem_range, hr t] + constructor + · rintro ⟨_, _, h⟩; exact h + · intro h; exact ⟨h.lt, h.lt, h⟩ + +theorem upClosure_sorted (dag : Dag) (isMember : Nat → Bool) : + (upClosure dag isMember).toList.Pairwise (· < ·) := by + unfold upClosure + rw [Array.toList_filter, Array.toList_range] + exact List.pairwise_lt_range.filter _ + +end LocalSearch + +namespace LocalSearch + +/-- The closure walk's invariant over `(marks, found, stack)`. -/ +structure WalkInv (dag : Dag) (isMember : Nat → Bool) (P : Array (Array Nat)) (n : Nat) + (st : Array Nat × Array Nat × Array Nat) : Prop where + size : st.1.size = n + marks : ∀ t, st.1[t]! = if t ∈ st.2.1.toList then 1 else 0 + nodup : st.2.1.toList.Nodup + up : ∀ t ∈ st.2.1.toList, Up dag isMember t + stackIn : ∀ t ∈ st.2.2.toList, t ∈ st.2.1.toList + stackNodup : st.2.2.toList.Nodup + done : ∀ t ∈ st.2.1.toList, t ∉ st.2.2.toList → ∀ q ∈ (P[t]!).toList, q < n → + q ∈ st.2.1.toList + +theorem walkPush_spec {dag : Dag} {isMember : Nat → Bool} {P : Array (Array Nat)} {n : Nat} + (vis out stack : Array Nat) (except : Nat → Prop) + (hsz : vis.size = n) (hmk : ∀ t, vis[t]! = if t ∈ out.toList then 1 else 0) + (hnd : out.toList.Nodup) (hup : ∀ t ∈ out.toList, Up dag isMember t) + (hsi : ∀ t ∈ stack.toList, t ∈ out.toList) (hsn : stack.toList.Nodup) + (hdn : ∀ t ∈ out.toList, t ∉ stack.toList → ¬ except t → ∀ q ∈ (P[t]!).toList, q < n → + q ∈ out.toList) + (q : Nat) (hq : q < n → Up dag isMember q) : + let r := walkPush n (vis, out, stack) q + r.1.size = n ∧ (∀ t, r.1[t]! = if t ∈ r.2.1.toList then 1 else 0) ∧ r.2.1.toList.Nodup ∧ + (∀ t ∈ r.2.1.toList, Up dag isMember t) ∧ (∀ t ∈ r.2.2.toList, t ∈ r.2.1.toList) ∧ + r.2.2.toList.Nodup ∧ + (∀ t ∈ r.2.1.toList, t ∉ r.2.2.toList → ¬ except t → ∀ q ∈ (P[t]!).toList, q < n → + q ∈ r.2.1.toList) ∧ + (∀ t ∈ out.toList, t ∈ r.2.1.toList) ∧ (q < n → q ∈ r.2.1.toList) := by + intro r + unfold r walkPush + by_cases hnew : q < n ∧ vis[q]! = 0 + · have hc : (decide (q < n) && vis[q]! == 0) = true := by simp [hnew.1, hnew.2] + simp only [hc, if_true] + have hqo : q ∉ out.toList := by + intro h; have := hmk q; rw [if_pos h] at this; omega + refine ⟨by rw [Array.set!_eq_setIfInBounds, Array.size_setIfInBounds, hsz], fun t => ?_, + ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ + · rw [setBang_read (n := n) hnew.1 _ _ hsz, hmk t] + simp only [Array.toList_push, List.mem_append, List.mem_singleton] + by_cases htq : t = q + · simp [htq] + · simp [htq] + · rw [Array.toList_push, List.nodup_append] + refine ⟨hnd, by simp, fun a ha b hb => ?_⟩ + rw [List.mem_singleton] at hb + subst hb + exact fun h => hqo (h ▸ ha) + · intro t ht + rw [Array.toList_push, List.mem_append, List.mem_singleton] at ht + rcases ht with ht | rfl + · exact hup t ht + · exact hq hnew.1 + · intro t ht + rw [Array.toList_push, List.mem_append, List.mem_singleton] at ht ⊢ + rcases ht with ht | rfl + · exact Or.inl (hsi t ht) + · exact Or.inr rfl + · rw [Array.toList_push, List.nodup_append] + refine ⟨hsn, by simp, fun a ha b hb => ?_⟩ + rw [List.mem_singleton] at hb + subst hb + exact fun h => hqo (h ▸ hsi a ha) + · intro t ht hts hex q' hq' hq'n + rw [Array.toList_push, List.mem_append, List.mem_singleton] at ht hts ⊢ + rcases ht with ht | rfl + · exact Or.inl (hdn t ht (fun h => hts (Or.inl h)) hex q' hq' hq'n) + · exact absurd (Or.inr rfl) hts + · intro t ht + rw [Array.toList_push, List.mem_append] + exact Or.inl ht + · intro _ + rw [Array.toList_push, List.mem_append, List.mem_singleton] + exact Or.inr rfl + · have hc : (decide (q < n) && vis[q]! == 0) = false := by + simp only [Bool.and_eq_false_iff, decide_eq_false_iff_not, beq_eq_false_iff_ne, ne_eq] + by_cases h1 : q < n + · exact Or.inr (fun h2 => hnew ⟨h1, h2⟩) + · exact Or.inl h1 + simp only [hc, Bool.false_eq_true, if_false] + refine ⟨hsz, hmk, hnd, hup, hsi, hsn, hdn, fun t ht => ht, fun hqn => ?_⟩ + have h0 : vis[q]! ≠ 0 := fun h => hnew ⟨hqn, h⟩ + have := hmk q + by_cases hm : q ∈ out.toList + · exact hm + · rw [if_neg hm] at this; exact absurd this h0 + +end LocalSearch + +namespace LocalSearch + +theorem walkFold_spec {dag : Dag} {isMember : Nat → Bool} {P : Array (Array Nat)} {n : Nat} + (except : Nat → Prop) : ∀ (qs : List Nat) (vis out stack : Array Nat), + vis.size = n → (∀ t, vis[t]! = if t ∈ out.toList then 1 else 0) → out.toList.Nodup → + (∀ t ∈ out.toList, Up dag isMember t) → (∀ t ∈ stack.toList, t ∈ out.toList) → + stack.toList.Nodup → + (∀ t ∈ out.toList, t ∉ stack.toList → ¬ except t → ∀ q ∈ (P[t]!).toList, q < n → + q ∈ out.toList) → + (∀ q ∈ qs, q < n → Up dag isMember q) → + let r := qs.foldl (walkPush n) (vis, out, stack) + r.1.size = n ∧ (∀ t, r.1[t]! = if t ∈ r.2.1.toList then 1 else 0) ∧ r.2.1.toList.Nodup ∧ + (∀ t ∈ r.2.1.toList, Up dag isMember t) ∧ (∀ t ∈ r.2.2.toList, t ∈ r.2.1.toList) ∧ + r.2.2.toList.Nodup ∧ + (∀ t ∈ r.2.1.toList, t ∉ r.2.2.toList → ¬ except t → ∀ q ∈ (P[t]!).toList, q < n → + q ∈ r.2.1.toList) ∧ + (∀ t ∈ out.toList, t ∈ r.2.1.toList) ∧ (∀ q ∈ qs, q < n → q ∈ r.2.1.toList) + | [], vis, out, stack, h1, h2, h3, h4, h5, h6, h7, _ => + ⟨h1, h2, h3, h4, h5, h6, h7, fun _ h => h, fun _ h => absurd h (by simp)⟩ + | q :: qs, vis, out, stack, h1, h2, h3, h4, h5, h6, h7, hqs => by + intro r + obtain ⟨a1, a2, a3, a4, a5, a6, a7, a8, a9⟩ := + walkPush_spec (dag := dag) (isMember := isMember) (P := P) vis out stack except h1 h2 h3 + h4 h5 h6 h7 q (hqs q List.mem_cons_self) + unfold r + rw [List.foldl_cons] + generalize hw : walkPush n (vis, out, stack) q = w at a1 a2 a3 a4 a5 a6 a7 a8 a9 + obtain ⟨vis', out', stack'⟩ := w + obtain ⟨b1, b2, b3, b4, b5, b6, b7, b8, b9⟩ := walkFold_spec except qs vis' out' stack' a1 a2 + a3 a4 a5 a6 a7 (fun q' hq' => hqs q' (List.mem_cons_of_mem _ hq')) + refine ⟨b1, b2, b3, b4, b5, b6, b7, fun t ht => b8 t (a8 t ht), fun q' hq' hq'n => ?_⟩ + rcases List.mem_cons.mp hq' with rfl | hq' + · exact b8 _ (a9 hq'n) + · exact b9 q' hq' hq'n + +theorem walkLoop_spec {dag : Dag} {isMember : Nat → Bool} {n : Nat} (hn : n = dag.size) : + ∀ (fuel : Nat) (st : Array Nat × Array Nat × Array Nat), + WalkInv dag isMember (parentsOf dag) n st → + WalkInv dag isMember (parentsOf dag) n (walkLoop (parentsOf dag) n fuel st) ∧ + ∀ t ∈ st.2.1.toList, t ∈ (walkLoop (parentsOf dag) n fuel st).2.1.toList + | 0, st, h => ⟨h, fun _ ht => ht⟩ + | fuel + 1, (vis, out, stack), h => by + unfold walkLoop + cases hb : stack.back? with + | none => exact ⟨h, fun _ ht => ht⟩ + | some c => + simp only + obtain ⟨ys, rfl⟩ := Array.back?_eq_some_iff.mp hb + have hcin : c ∈ out.toList := h.stackIn c (by simp) + have hcup : Up dag isMember c := h.up c hcin + rw [Array.pop_push, ← Array.foldl_toList] + have hstk : ∀ t, t ∈ ys.toList → t ∈ (ys.push c).toList := by + intro t ht; simp [ht] + have hnd' : ys.toList.Nodup := by + have := h.stackNodup + rw [Array.toList_push, List.nodup_append] at this + exact this.1 + have hcys : c ∉ ys.toList := by + have := h.stackNodup + rw [Array.toList_push, List.nodup_append] at this + exact fun hc => this.2.2 c hc c (by simp) rfl + obtain ⟨a1, a2, a3, a4, a5, a6, a7, a8, a9⟩ := + walkFold_spec (dag := dag) (isMember := isMember) (P := parentsOf dag) (n := n) + (fun t => t = c) ((parentsOf dag)[c]!).toList vis out ys h.size h.marks h.nodup h.up + (fun t ht => h.stackIn t (hstk t ht)) hnd' + (fun t ht hts hne q hq hqn => h.done t ht (by + intro hts' + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at hts' + rcases hts' with hts' | rfl + · exact hts hts' + · exact hne rfl) q hq hqn) + (fun q hq hqn => by + rw [Array.mem_toList_iff, mem_parentsOf] at hq + exact .par (by omega) hq.2.2 hcup) + generalize hw : ((parentsOf dag)[c]!).toList.foldl (walkPush n) (vis, out, ys) = w + at a1 a2 a3 a4 a5 a6 a7 a8 a9 + have hinv : WalkInv dag isMember (parentsOf dag) n w := by + refine ⟨a1, a2, a3, a4, a5, a6, fun t ht hts q hq hqn => ?_⟩ + by_cases htc : t = c + · subst htc; exact a9 q (by simpa using hq) hqn + · exact a7 t ht hts htc q hq hqn + obtain ⟨b1, b2⟩ := walkLoop_spec hn fuel w hinv + exact ⟨b1, fun t ht => b2 t (a8 t ht)⟩ + +/-- **Closure walk.** From all-`0` marks, the walk keeps its invariant, and +when its stack is empty it has found exactly the members and their +ancestors. -/ +theorem upWalk_spec (dag : Dag) (members : Array Nat) : + let isMem := fun t => (markTable dag.size members)[t]! + let r := upWalk (parentsOf dag) members (Array.replicate dag.size 0) + WalkInv dag isMem (parentsOf dag) dag.size r ∧ + (r.2.2.toList = [] → ∀ t, t ∈ r.2.1.toList ↔ Up dag isMem t) := by + intro isMem r + have hm0 : ∀ t, (Array.replicate dag.size 0)[t]! = if t ∈ (#[] : Array Nat).toList then 1 else 0 := by + intro t + by_cases h : t < dag.size + · rw [getElem!_pos _ t (by simpa using h)]; simp + · rw [getElem!_neg _ t (by simpa using h)]; simp + obtain ⟨a1, a2, a3, a4, a5, a6, a7, a8, a9⟩ := + walkFold_spec (dag := dag) (isMember := isMem) (P := parentsOf dag) (n := dag.size) + (fun _ => False) members.toList (Array.replicate dag.size 0) #[] #[] (by simp) hm0 + (by simp) (by simp) (by simp) (by simp) (by simp) + (fun q hq hqn => .mem hqn (by + show (markTable dag.size members)[q]! = true + rw [markTable_read]; simp [hqn, Array.mem_toList_iff.mp hq])) + have hinv0 : WalkInv dag isMem (parentsOf dag) dag.size + (members.toList.foldl (walkPush dag.size) (Array.replicate dag.size 0, #[], #[])) := + ⟨a1, a2, a3, a4, a5, a6, fun t ht hts q hq hqn => a7 t ht hts (fun h => h) q hq hqn⟩ + unfold r upWalk + simp only [Array.size_replicate] + rw [← Array.foldl_toList] + obtain ⟨b1, b2⟩ := walkLoop_spec (isMember := isMem) rfl (dag.size + 1) _ hinv0 + refine ⟨b1, fun hempty t => ⟨fun ht => b1.up t ht, fun hup => ?_⟩⟩ + induction hup with + | mem hlt hm => + apply b2 + apply a9 _ _ hlt + have : (markTable dag.size members)[_]! = true := hm + rw [markTable_read] at this + simp only [Bool.and_eq_true, decide_eq_true_eq] at this + simpa using this.2 + | @par t c hlt hc hu ih => + exact b1.done c ih (by rw [hempty]; simp) t + (by rw [Array.mem_toList_iff, mem_parentsOf]; exact ⟨hu.lt, hlt, hc⟩) hlt + +end LocalSearch + +/-! ### The context -/ + +namespace LocalSearch + +theorem strictInc_of_sorted {a : Array Nat} (h : a.toList.Pairwise (· < ·)) : strictInc a = true := by + unfold strictInc + simp only [List.all_eq_true, List.mem_range, decide_eq_true_eq] + intro i _ hi + rw [List.pairwise_iff_getElem] at h + have := h i (i + 1) (by simpa using (show i < a.size by omega)) (by simpa using hi) (by omega) + rw [getElem!_pos a i (by omega), getElem!_pos a (i + 1) hi] + simpa using this + +theorem mem_of_getElem! {a : Array Nat} {i : Nat} (hi : i < a.size) : a[i]! ∈ a.toList := by + rw [getElem!_pos a i hi, Array.mem_toList_iff] + exact Array.getElem_mem hi + +theorem mergeSort_eq_of_mem {l : List Nat} {C : Array Nat} (hnd : l.Nodup) + (hmem : ∀ t, t ∈ l ↔ t ∈ C.toList) (hs : C.toList.Pairwise (· < ·)) : + (l.mergeSort fun a b => decide (a ≤ b)).toArray = C := by + apply Array.ext' + rw [List.toList_toArray] + have hp : List.Perm (l.mergeSort fun a b => decide (a ≤ b)) C.toList := by + refine (List.mergeSort_perm l _).trans ?_ + rw [List.perm_ext_iff_of_nodup hnd (hs.imp Nat.ne_of_lt)] + exact hmem + refine List.Perm.eq_of_pairwise (le := fun a b => a ≤ b) (fun a b _ _ h1 h2 => by omega) ?_ + (hs.imp Nat.le_of_lt) hp + have := List.pairwise_mergeSort (le := fun a b => decide (a ≤ b)) + (fun a b c h1 h2 => by simp only [decide_eq_true_eq] at *; omega) + (fun a b => by simp only [Bool.or_eq_true, decide_eq_true_eq]; omega) l + exact this.imp (fun h => by simpa using h) + +theorem setPositions_congr (a b xs : Array Nat) (hs : strictInc xs = true) + (hab : a.size = b.size) (hin : ∀ i, i < xs.size → xs[i]! < a.size) + (h : ∀ u, (∀ i, i < xs.size → xs[i]! ≠ u) → a[u]! = b[u]!) : + setPositions a xs = setPositions b xs := by + obtain ⟨ha1, ha2⟩ := setPositions_read a xs hs hin + obtain ⟨hb1, hb2⟩ := setPositions_read b xs hs (fun i hi => hab ▸ hin i hi) + apply Array.ext + · rw [ha1, hb1, hab] + · intro i hi1 hi2 + have e1 := ha2 i + have e2 := hb2 i + rw [getElem!_pos _ i hi1] at e1 + rw [getElem!_pos _ i hi2] at e2 + rw [e1, e2] + by_cases hex : ∃ j, j < xs.size ∧ xs[j]! = i + · rw [dif_pos hex, dif_pos hex] + · rw [dif_neg hex, dif_neg hex] + exact h i (fun j hj hx => hex ⟨j, hj, hx⟩) + +/-- **Context.** With children before their parents, `mkSCtxL` builds the +context of `mkSCtx` and the closure's position table. -/ +theorem mkSCtxL_eq (ex : Expanded) (f : GraphFacts) (up : UPrep) (cand : Array Bool) + (b0 : UBounds) (vis0 : Array Nat × Array Nat) (rootCount : Array Nat) (slack : Nat) + (theta : _root_.Int) (baseEv : DictEval) (widthCs : Array (Option Nat)) (allTrue : Array Bool) + (unc : Array Nat) (members : Array Nat) (hcp : childrenPrecede ex.dag.nodes = true) : + mkSCtxL ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc + (parentsOf ex.dag) (Array.replicate ex.dag.size 0) members = + (mkSCtx ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc members, + setPositions (Array.replicate ex.dag.size 0) + (upClosure ex.dag ((markTable ex.dag.size members)[·]!))) := by + obtain ⟨hinv, hdone⟩ := upWalk_spec ex.dag members + have hCs := upClosure_sorted ex.dag ((markTable ex.dag.size members)[·]!) + have hCmem := mem_upClosure hcp ((markTable ex.dag.size members)[·]!) + have hCinc := strictInc_of_sorted hCs + have hCin : ∀ i, i < (upClosure ex.dag ((markTable ex.dag.size members)[·]!)).size → + (upClosure ex.dag ((markTable ex.dag.size members)[·]!))[i]! < ex.dag.size := + fun i hi => ((hCmem _).mp (mem_of_getElem! hi)).lt + -- the closure and the marks of the walk + have hres : (if (upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0)).2.2.isEmpty then + (((upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0)).2.1.toList.mergeSort + fun a b => decide (a ≤ b)).toArray, + (upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0)).1) + else (upClosure ex.dag ((markTable ex.dag.size members)[·]!), + clearPositions (upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0)).1 + (upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0)).2.1)).1 = + upClosure ex.dag ((markTable ex.dag.size members)[·]!) ∧ + setPositions (if (upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0)).2.2.isEmpty then + (((upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0)).2.1.toList.mergeSort + fun a b => decide (a ≤ b)).toArray, + (upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0)).1) + else (upClosure ex.dag ((markTable ex.dag.size members)[·]!), + clearPositions (upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0)).1 + (upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0)).2.1)).2 + (upClosure ex.dag ((markTable ex.dag.size members)[·]!)) = + setPositions (Array.replicate ex.dag.size 0) + (upClosure ex.dag ((markTable ex.dag.size members)[·]!)) := by + generalize upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0) = r at hinv hdone + obtain ⟨vis, out, stack⟩ := r + by_cases he : stack.isEmpty = true + · simp only [he, if_true] + have hst : stack.toList = [] := by + rw [Array.isEmpty_iff] at he; subst he; rfl + have hfound := hdone hst + have hc : (out.toList.mergeSort fun a b => decide (a ≤ b)).toArray = + upClosure ex.dag ((markTable ex.dag.size members)[·]!) := + mergeSort_eq_of_mem hinv.nodup (fun t => (hfound t).trans (hCmem t).symm) hCs + refine ⟨hc, ?_⟩ + apply setPositions_congr _ _ _ hCinc (by rw [hinv.size]; simp) + (fun i hi => by rw [hinv.size]; exact hCin i hi) + intro u hu + rw [hinv.marks u] + have hnot : u ∉ out.toList := by + intro hm + have hmC := (hCmem u).mpr ((hfound u).mp hm) + rw [Array.mem_toList_iff, Array.mem_iff_getElem] at hmC + obtain ⟨i, hi, rfl⟩ := hmC + exact hu i hi (by rw [getElem!_pos _ i hi]) + rw [if_neg hnot] + by_cases hlt : u < ex.dag.size + · rw [getElem!_pos _ u (by simpa using hlt)]; simp + · rw [getElem!_neg _ u (by simpa using hlt)]; rfl + · simp only [he, Bool.false_eq_true, if_false] + refine ⟨trivial, ?_⟩ + rw [clearPositions_zero vis out ex.dag.size hinv.size (fun u hu => by + rw [hinv.marks u] + have hnot : u ∉ out.toList := by + intro hm + rw [Array.mem_toList_iff, Array.mem_iff_getElem] at hm + obtain ⟨i, hi, rfl⟩ := hm + exact hu i hi (by rw [getElem!_pos _ i hi]) + rw [if_neg hnot])] + obtain ⟨hcl, hpos⟩ := hres + unfold mkSCtxL mkSCtx + simp only + generalize upWalk (parentsOf ex.dag) members (Array.replicate ex.dag.size 0) = r at hcl hpos + obtain ⟨vis, out, stack⟩ := r + simp only at hcl hpos ⊢ + rw [hcl, hpos] + have hroots : (fun (r : Nat) => (setPositions (Array.replicate ex.dag.size 0) + (upClosure ex.dag ((markTable ex.dag.size members)[·]!)))[r]! != 0) = + fun (r : Nat) => (markTable ex.dag.size (upClosure ex.dag ((markTable ex.dag.size members)[·]!)))[r]! := by + funext r + have hpf := setPositions_posFn _ ex.dag.size hCinc hCin + rw [markTable_read] + by_cases hm : r ∈ (upClosure ex.dag ((markTable ex.dag.size members)[·]!)).toList + · have hlt := ((hCmem r).mp hm).lt + rw [Array.mem_toList_iff, Array.mem_iff_getElem] at hm + obtain ⟨i, hi, hx⟩ := hm + have := (hpf r i).mpr ⟨hi, by simp only; rw [getElem!_pos _ i hi]; exact hx⟩ + rw [posOf_some] at this + rw [this] + have : (upClosure ex.dag ((markTable ex.dag.size members)[·]!)).contains r = true := by + rw [Array.contains_iff_mem, Array.mem_iff_getElem]; exact ⟨i, hi, hx⟩ + have hlt' : (upClosure ex.dag ((markTable ex.dag.size members)[·]!))[i] < ex.dag.size := by + have := hCin i hi + rwa [getElem!_pos _ i hi] at this + simp [← hx, hlt'] + · have hnone : ∀ j, ¬ posOf (setPositions (Array.replicate ex.dag.size 0) + (upClosure ex.dag ((markTable ex.dag.size members)[·]!))) r = some j := by + intro j hj + obtain ⟨hj1, hj2⟩ := (hpf r j).mp hj + simp only at hj2 + exact hm (hj2 ▸ mem_of_getElem! hj1) + have h0 : (setPositions (Array.replicate ex.dag.size 0) + (upClosure ex.dag ((markTable ex.dag.size members)[·]!)))[r]! = 0 := by + cases hz : (setPositions (Array.replicate ex.dag.size 0) + (upClosure ex.dag ((markTable ex.dag.size members)[·]!)))[r]! with + | zero => rfl + | succ k => exact absurd ((posOf_some _ r k).mpr hz) (hnone k) + have : (upClosure ex.dag ((markTable ex.dag.size members)[·]!)).contains r = false := by + rw [Bool.eq_false_iff, ne_eq, Array.contains_iff_mem, ← Array.mem_toList_iff] + exact hm + simp only [h0, this, bne_self_eq_false, Bool.and_false] + rw [hroots] + +end LocalSearch + +/-! ### The loop -/ + +namespace LocalSearch + +theorem clear_set_zero (n : Nat) (xs : Array Nat) (hs : strictInc xs = true) + (hin : ∀ i, i < xs.size → xs[i]! < n) : + clearPositions (setPositions (Array.replicate n 0) xs) xs = Array.replicate n 0 := by + obtain ⟨h1, h2⟩ := setPositions_read (Array.replicate n 0) xs hs (by simpa using hin) + apply clearPositions_zero _ _ n (by rw [h1]; simp) + intro u hu + rw [h2 u, dif_neg (fun ⟨j, hj, hx⟩ => hu j hj hx)] + by_cases h : u < n + · rw [getElem!_pos _ u (by simpa using h)]; simp + · rw [getElem!_neg _ u (by simpa using h)]; rfl + +theorem localSearchOK_inc {cx : SCtx} (h : localSearchOK cx = true) : + strictInc cx.area = true ∧ strictInc cx.closure = true := by + unfold localSearchOK at h + simp only [Bool.and_eq_true] at h + exact ⟨h.1.1.1.2, h.1.2⟩ + +theorem foldlM_sim {ε α β γ : Type} (f : α → γ → Except ε α) (g : β → γ → Except ε β) + (e : α → β) (hstep : ∀ a x, g (e a) x = (f a x).map e) : + ∀ (l : List γ) (a : α), l.foldlM g (e a) = (l.foldlM f a).map e + | [], _ => rfl + | x :: l, a => by + rw [List.foldlM_cons, List.foldlM_cons, hstep] + cases f a x with + | error _ => rfl + | ok a' => exact foldlM_sim f g e hstep l a' + +/-- One step of the compiled loop from cleared position tables. -/ +theorem fastStep_eq (limits : Limits) (ex : Expanded) (f : GraphFacts) (up : UPrep) + (cand : Array Bool) (b0 : UBounds) (vis0 : Array Nat × Array Nat) (rootCount : Array Nat) + (slack : Nat) (theta : _root_.Int) (baseEv : DictEval) (widthCs : Array (Option Nat)) + (allTrue : Array Bool) (unc : Array Nat) (opaq : Array Bool) + (hss : limits.uniformSubsetSearch = false) (hcp : childrenPrecede ex.dag.nodes = true) + (a : Array CompResult × Nat × Nat) (members : Array Nat) : + fastStep limits ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc + (parentsOf ex.dag) + (a, Array.replicate up.prep.dag.size 0, Array.replicate ex.dag.size 0) members = + (specStep limits ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc opaq + a members).map + (fun a => (a, Array.replicate up.prep.dag.size 0, Array.replicate ex.dag.size 0)) := by + obtain ⟨results, states, costEvals⟩ := a + unfold fastStep specStep + simp only [hss, Bool.false_eq_true, if_false] + rw [mkSCtxL_eq ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc members hcp] + simp only + have hCs := upClosure_sorted ex.dag ((markTable ex.dag.size members)[·]!) + have hCmem := mem_upClosure hcp ((markTable ex.dag.size members)[·]!) + have hCinc := strictInc_of_sorted hCs + have hCin : ∀ i, i < (upClosure ex.dag ((markTable ex.dag.size members)[·]!)).size → + (upClosure ex.dag ((markTable ex.dag.size members)[·]!))[i]! < ex.dag.size := + fun i hi => ((hCmem _).mp (mem_of_getElem! hi)).lt + have hzC : clearPositions (setPositions (Array.replicate ex.dag.size 0) + (upClosure ex.dag ((markTable ex.dag.size members)[·]!))) + (upClosure ex.dag ((markTable ex.dag.size members)[·]!)) = + Array.replicate ex.dag.size 0 := clear_set_zero _ _ hCinc hCin + generalize hcx : mkSCtx ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc + members = cx + have hcl : cx.closure = upClosure ex.dag ((markTable ex.dag.size members)[·]!) := by + rw [← hcx]; unfold mkSCtx; rfl + have hup : cx.up = up := by rw [← hcx]; unfold mkSCtx; rfl + rw [hcl, hzC] + by_cases hok : localSearchOK cx = true + · rw [if_pos hok] + obtain ⟨_, _, _, _, _, _, _, _, harea, _⟩ := localSearchOK_spec hok + have hainc := (localSearchOK_inc hok).1 + have hain : ∀ i, i < cx.area.size → cx.area[i]! < up.prep.dag.size := by + intro i hi; rw [← hup]; exact harea i hi + have hzA : clearPositions (setPositions (Array.replicate up.prep.dag.size 0) cx.area) + cx.area = Array.replicate up.prep.dag.size 0 := clear_set_zero _ _ hainc hain + have hr : Ready cx (setPositions (Array.replicate up.prep.dag.size 0) cx.area) + (setPositions (Array.replicate ex.dag.size 0) + (upClosure ex.dag ((markTable ex.dag.size members)[·]!))) := + ⟨hok, setPositions_posFn _ _ hainc hain, + by rw [hcl]; exact setPositions_posFn _ _ hCinc hCin⟩ + rw [searchComponentL_eq hr, hzA] + cases searchComponent cx limits states costEvals with + | error _ => rfl + | ok v => rfl + · rw [if_neg hok] + cases searchComponent cx limits states costEvals with + | error _ => rfl + | ok v => rfl + +end LocalSearch + +open LocalSearch in +/-- **The compiled component loop.** `searchComponentsWithFast` (the closure +walk, the area- and closure-local search, two shared position tables) computes +`searchComponentsWith` for every input. -/ +@[csimp] theorem searchComponentsWith_eq_fast : + @searchComponentsWith = @searchComponentsWithFast := by + funext limits ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc opaq comps + unfold searchComponentsWithFast + by_cases hg : (limits.uniformSubsetSearch || !childrenPrecede ex.dag.nodes) = true + · rw [if_pos hg] + · rw [if_neg hg] + simp only [Bool.or_eq_true, Bool.not_eq_true', not_or, Bool.not_eq_false] at hg + obtain ⟨hss, hcp⟩ := hg + unfold searchComponentsWith + rw [← Array.foldlM_toList, ← Array.foldlM_toList] + have key := foldlM_sim + (specStep limits ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc opaq) + (fastStep limits ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc + (parentsOf ex.dag)) + (fun a => (a, Array.replicate up.prep.dag.size 0, Array.replicate ex.dag.size 0)) + (fastStep_eq limits ex f up cand b0 vis0 rootCount slack theta baseEv widthCs allTrue unc opaq + (by simpa using hss) hcp) comps.toList ((#[] : Array CompResult), 0, 0) + rw [key] + cases List.foldlM (specStep limits ex f up cand b0 vis0 rootCount slack theta baseEv widthCs + allTrue unc opaq) ((#[] : Array CompResult), 0, 0) comps.toList <;> rfl + +end Ix.Sharing.Exact + +end diff --git a/Ix/Tc/Driver.lean b/Ix/Tc/Driver.lean index 9cb37894b..c5b995c04 100644 --- a/Ix/Tc/Driver.lean +++ b/Ix/Tc/Driver.lean @@ -17,7 +17,7 @@ without consulting metadata sections. For each entry: whose `primary` is the first member's projection address and whose `targets` list every member projection plus one CPrj per constructor. -Dispatch is on the leading Tag4 byte (`LazyConstant.peekTag`), avoiding body +Dispatch is on the leading TagN header byte (`LazyConstant.peekTag`), avoiding body parses for the ~95% of constants that are standalones or projections. Keys are visited in ascending byte-lexicographic address order (Rust `keys.sort_unstable()` parity). diff --git a/Ix/Tc/Ingress.lean b/Ix/Tc/Ingress.lean index b7c7b11e8..3988f0e31 100644 --- a/Ix/Tc/Ingress.lean +++ b/Ix/Tc/Ingress.lean @@ -6,7 +6,7 @@ public import Ix.Ixon /-! Mirror: crates/kernel/src/ingress.rs (the Ixon → kernel, anonymous-mode half) -This is the **erased typing** boundary. V3 contracts are retained in the +This is the **erased typing** boundary. Ixon contracts are retained in the addressed source but erased for Lean kernel typing. Resource promises require `Ix.Resource.Validate`; successful ordinary typechecking alone establishes none of those promises. diff --git a/Ix/Tc/Primitive.lean b/Ix/Tc/Primitive.lean index e100cebe6..d2f5b0cd1 100644 --- a/Ix/Tc/Primitive.lean +++ b/Ix/Tc/Primitive.lean @@ -135,33 +135,33 @@ def canonical : PrimAddrs where nat := h "35e1cc809f6f076521a43f85068d5592220407c0532b6a08952f40d8523d04bc" natZero := h "eeb2e6268ff6d0e6b2e9764d9940b81bb64b9f8f4b1358d294ff9817e6941a46" natSucc := h "42d6ed31536f0958176f1dc973383808ac8583223746ebca78dbe389b65321a6" - natAdd := h "724db797e1817545a08371432fd1fa6428a37dcf9c1671df7e464849db0a81ac" - natPred := h "76afa254a8bbf2ac4327d7b94be0c63bd708836b5f7384ce990388adb0a1d3cf" - natSub := h "9de2d2c60e7d421a2fdfb8706e91e0e6d8576c3bd46ec00405c65875cb9b5a26" - natMul := h "566a3c2249bc2076543d9bc561a841f6fd35ffb5bdbbc5c991a9c64feccbd5d4" - natPow := h "5ba43ac3e5d29fe5ce81f18a18178a2705c37ee674b9b6ee50e9466a86593b15" - natGcd := h "76007dcf8b285cdbd6f779012290fe2e6afd221ce8821082a7e2ef81e8d815cf" - natMod := h "e6ffe78713d4b974a82d0187538f1a0cf5c4b260f0fd99264fab263b1af847f9" - natDiv := h "c075ed976f1702f364fb0bb34aa8bbc166adace573f2ce914b43dc4f4aab6219" - natBitwise := h "aaf7df6a1f024f580fde236cba16235f071d1b796cc279faf43178d22b5ae36d" - natBeq := h "ffd3f02a19fda649aa5608ed818db382e160231b76d5b09176d7dd1a8d5b1ec5" - natBle := h "68a3643ec69816aec107302ddbfa054cebcd3ec173cd5f7e6d883638631afe65" - natLand := h "c61fad46a102dbff5922312d4fbe6e704ec3c62c6c6f64b3d481b78c77cf315d" - natLor := h "cb7dccc020a530fed7c622b100ee52c1078b5018159ba4682f817e3776789ee8" - natXor := h "d8a6b05a1a4e5cadc69c53792e8e130314745e76e32bb30a9ce0272fa079e8a6" - natShiftLeft := h "5c15f98e2bd9c257bcdfac62b0043a2e3e2bbdff8b210f104b5c3739e862ac0c" - natShiftRight := h "3f92725324b09fa75c6fcd16da863671428ff33b7db667eb760e1cd503a2bcad" + natAdd := h "3e8aadcc611c4d8677cadf00c78506561d33738ee3d571f7a4196e260580c9b8" + natPred := h "3244687301d779ec757274761d903def3eb3135177327b709bcbd854ef496f79" + natSub := h "03b3a041285b0fe202d90b227d405c4cec252df18ba7616acd6dae2792e672bb" + natMul := h "373b7d74f6b40da11b7ed79603a45ec7011a8831b720b57d2efe92e82a3d57f0" + natPow := h "5baaf05c969d2cf377312111be51bb64c600c13fa164ee722e92243b0f771bab" + natGcd := h "aba94bfb41351d4db36172c379a512f04219ef21dc5454d71590967d4e8f913f" + natMod := h "11abbf986481c53a21c8cb21ee2581ae6238aedbec15f972959d086bef1a1985" + natDiv := h "824d1c53d8c1c3cf0a27f24639ec2be1ecc13d4a01c993171595edccf6949737" + natBitwise := h "6eff55f72c856bd08aa02896fb78d93c28e11aae2be05c318b9d1f9fab8d7a53" + natBeq := h "d3d8ff924af9dc4b5cd869760615b3e7ee80916bb617259d45890c69f4128337" + natBle := h "9e445b9d5f8252772347872e909b5db4e7eca7086cedf4fec6de840f6b7b5f92" + natLand := h "d98bed1e14cda0eea470a5a49ff7926c80eb4bc7bfbdd0c3e14d4baa5c2dd0d7" + natLor := h "88ff34dd42e57766beefc229d8b62dabba9cef6aadcc85c88ad67323d02bbf21" + natXor := h "1b0acdd4080abe5bc4acb5f06527cb62ad92792eb429c2b3bcb6f471d7945085" + natShiftLeft := h "05bb657e8b9d5dc224e7ef3d53e54153ce3ac26da8d1f1b1d61069a3726566cd" + natShiftRight := h "25019ff485fcf5709597cd1e07fcc3ce796776ef3f715a6d187eb5831c63b4be" boolType := h "e6eba3c8b4d19f6a1076b39fa89aec61dccbb960f83d9a62e6acf35a69c9a0a4" boolTrue := h "a29a636176cf1135d077eb074798f9007c78e7801383e9cff363bae5edf05762" boolFalse := h "dda12bcb330727f6dfb816bc9752aabd0520e6515b79fc8a5a9e713866f4c63e" - string := h "9d6ae43429ec02a9338bbcd0db0ac193d75ebd46f884bfcbd2c42bf7faea150d" - stringMk := h "272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2" - charType := h "4c59bc4eac82d31ebed59bb206909dbded65b92fd56de2518fcdadb0a42c11a0" - charMk := h "82e09601422cae23b0b6df9922abb9f0b014e20047a00a7ab96871dd7da3e5ac" - charOfNat := h "caf51b039d71cfce7063e106064f9435f5337bbc42567c8c78b5f66c7f087920" - stringOfList := h "272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2" - stringToByteArray := h "79862acfbc2e37b7b6122143f0a6a51114c34fa483ff14146483de18835d4209" - byteArrayEmpty := h "bf58e6cb3aa0f746850629041635cd30c0ad66262b6617660f2290241f08b08b" + string := h "221625a00ee2d6b96297e34d7e05bf7e4fd38d8d99d3e1d64a7cd2e06ca0752d" + stringMk := h "45dcb3c5e5ada3bc0ca52d62a66f7f9dda3507df71061a5c200adea0cf241014" + charType := h "065fc8b41393f525c1e541b9d4bc97c20c13bf23a7209a2093b6f4527330114a" + charMk := h "60cc6cfe4577b99a30113d09e9921f2253fac15fe3d5ad976b9dc3626edc6822" + charOfNat := h "cff875914f3f8b4f0014d1eaa223c6b9da7201239bc5976e140b69d99cd1f357" + stringOfList := h "45dcb3c5e5ada3bc0ca52d62a66f7f9dda3507df71061a5c200adea0cf241014" + stringToByteArray := h "de013024c598e5f0c3dcd067f506e1d2e32749573522acb539b61400627cf897" + byteArrayEmpty := h "4da661917a58152f5ca974d2256d98efa9d722c4f16382e9cdf016df4c574368" list := h "4fb6b41c30532e6ab4acb4eefe01da1314ee7f2129af8989fd63f7ec277aaf01" listNil := h "3994bc51e3686f30a1d483d69d0a835a7b484d892393c084f87a5849de54f302" listCons := h "b3a7d80249fd823100ee03626232d1412a0e8335275d5df53b92943887b650f7" @@ -174,57 +174,57 @@ def canonical : PrimAddrs where reduceBool := h "bacc4c814a4572ddfd969a1857adfe18239eb6bd8b1627ee79744a6a9b23b030" reduceNat := h "b6327d9a1bbb461a447f0c971e622dd9a35132bd7de75bf69e20794d7a0e8595" eagerReduce := h "ff00000000000000000000000000000000000000000000000000000000000003" - systemPlatformNumBits := h "6f620654d341990a301387b80ef75b1e0b6130ddf19164025b6dc37bf3c3dc18" - systemPlatformGetNumBits := h "00c266834f9039931b4be2fac5584cd176a0ae7ee4cb4064ddb5e04dd12b6cbb" - subtypeVal := h "ea65f517457fae9b705299da08b0d3c8cf9a476f16470cca5cae5ea7bd238230" - natDecLe := h "f0f15ed079822f06e82e36664bf61e797e5b1e7b0b4155152762c513274bfee1" - natDecEq := h "8a5d5eee414a2fa5956b74e8323a20508d774ed1b5603f55e774ad896bd3e6e7" - natDecLt := h "7c4977196e95be2a759fc9c6d1533db8da49592f06419b155d888333c8dd8931" - decidableRec := h "16cfddda9c274660f391b10eefe066275afffae1ccd49c6daf43afb8a80aea85" + systemPlatformNumBits := h "57a31c1e34cf3993b20939dd29ba27263f24fbbeede2f6a6d089b8051fe32c3c" + systemPlatformGetNumBits := h "236e46bde1f59309c2cc685a7379bc5294a9817e597915ddcc4b3d933284cd70" + subtypeVal := h "d1bfec8df908c887e4f489adc2eec77a53e8ff28b5bd9a4c21a56da6381eed8f" + natDecLe := h "7bb659876671e03d0731c456e894ce9e6f7de8250ab4ae70113dc08e24532127" + natDecEq := h "f1de7103802ebc5309041bdaadea4a65652d54af37e66aaaf41787b1d8919557" + natDecLt := h "af586b07546e1fca9ab0780d1c236af8d360c4c6bb32bb0cd03ec9ca63d3da96" + decidableRec := h "3ea7e18fcbb7c498b2a45237bda659c0edc97b3d54a4ad0d11bc2ebec80cfa17" decidableIsTrue := h "363d071182be414e1a58599b83f5e19f9b873723054f4287ba69705aafef27da" decidableIsFalse := h "8cc0e1360c1b29108dab3d6172e7fce8a9aa9640daa4bbe99ba1305d9623624b" - natLeOfBleEqTrue := h "ad25bfd207bae832c73d5ce614bead22ef9862e110f8d17a5064ffb7603eee3d" - natNotLeOfNotBleEqTrue := h "e3658f50dc5123efff213588dee3d4c6063f5edb18950850ac0490c937819009" - natEqOfBeqEqTrue := h "9c91e79de732226ba2e73cbdd330851baec40668eb40c6f32aa2f8dac5a04b51" - natNeOfBeqEqFalse := h "a07db532747e65ee77a7ba015069bdbaf1f709ce0d60b83c94f40d0e5e57595a" - fin := h "3d79797bc572d8f33eb7cff5aa13f8dc73bcf21026bf05d03888c9aa0369dcef" - boolNoConfusion := h "de7b523cc4470e15328a01d935988861dadf9bd012240400464dea8c79a9dfe2" + natLeOfBleEqTrue := h "5c99dc61889e4a1e06ff6f24d184dc6553028cc62b89fa61bc23115b6a762068" + natNotLeOfNotBleEqTrue := h "93c0ea70c5c33f7bcecd405dfdee5c5471f74aee61f8bb610b2552d7ffe28183" + natEqOfBeqEqTrue := h "c44c528578dab3903088d064cc9b679d2c0eb3fe73da3c1ce1cc9d1b8f2cadd3" + natNeOfBeqEqFalse := h "6a7739ca74fd0033ddcb1c4d98cde41920f173d3b8a6fade75a49b7496ec8cad" + fin := h "1e1a2bbb1920ed4a1281a3deca646ad313ca9c7bf7eabdc3655987797ccc0c55" + boolNoConfusion := h "55b3bf142fb5a8078ad3b7515f90ab239c32ae0443dfe383b67dae6f4ba17fc5" int := h "c60c95e3cdbf4ed010d999b3277f4e1fd3695e8c30260876102905d7b36241a2" intOfNat := h "0a99f49cc73ab9f42783092e7120613225670bab89b9d63533d1adefc876182f" intNegSucc := h "f7130d5864e1ba77b0f6a7338f92159c35bd5147e0febcf1ebed456e513538cc" - intAdd := h "9db0177e4e8b6a0e7323069509c2457de9598a7e38e72ffe19ad34617256e10d" - intSub := h "85621387ef3027028d835287f3cc1461ef041def1fd91e28e87f669cc04a5eea" - intMul := h "b05459623d23299d3a849eb7fb75badbc1547a1cd9ee560c15067fbd985c6cea" - intNeg := h "6701d765ff10bfa3a6c347df15194e0db862ee25b54f25a59f7cf21951a3997e" - intEmod := h "e29cfa7921bb57f4782b021c977596a4fae04e94f7b07955fe2814fc48de90e7" - intEdiv := h "9c952d45a3bd43161529fcfb5e276beab0cf4fd64a01ba9bc2c7cda376cb8f54" - intBmod := h "0b1564dea6ffcd204ebcd1aa69d29ee6f3acccd87bd146ff674556ac9cc8ccb3" - intBdiv := h "6d35dc43660f6c509a13f2824c027ed99ab070a08f058ff0a5f46a759250797d" - intNatAbs := h "261ae54edb66e900784a64350bc01e8b3fe1332a47caeab58e0361dffc7ea008" - intPow := h "87266415982bbdec50c61dec5b73cc0ccd5c997445997a9724a1cc5c2e39d3a4" - intDecEq := h "fc8c44cc970cfc183ccd10a2d1cdeb2c849307760e91f5cd29a2b02f706d83da" - intDecLe := h "fcdf1860ad4cd672239392e60e7b49e024af0475739c3a40195a914eaec42c04" - intDecLt := h "1d54806ab1ebc791e1db96e88d0407cef3523927d60ba669689b92a8eeb36445" + intAdd := h "b666925b10473fbe1a7630ec496fe07d799c5248667db1e2302fca5fe4c50cb6" + intSub := h "7c60043d6016e2f0ef5d764e1ab7923968d43d5c388186ddf6c83c28f024017a" + intMul := h "9dff949e4d0282393213042a36a69af4b71a58709096eaa3de5130bae0af84f3" + intNeg := h "19c87649f9a17809f248beff7bc37f569f548e24a98d8a7cddd5b82eb808e5a6" + intEmod := h "13c97e84fb8ac3ee8120e923d61fca6f7e6bb9241ec3aa5d359ba5dce542aa11" + intEdiv := h "53e404f5dd3c53693bc3b5bfae582b0496ec3c05af0cee0a46c38ab662c57fdf" + intBmod := h "d0380dc9b63afeeb3235a77adeb355a8b52b0730971595093741ec2c6d57cd49" + intBdiv := h "209aca62cc1f9dd2c0a928cd84d72bb41570aa97c1fd833e5fffc567c1c6401f" + intNatAbs := h "01e7c724508897e01e5d0b8f72e2cfa2607cea5ff0d352d008d0e7512aab2f46" + intPow := h "a28958d747e87b5a60e4fa07ef7ed8d949f69adcbc44afe2958482d3ee9b3365" + intDecEq := h "35a9ed7202e3c43857cdc4063eac123fe7b77f0631154ac540dba2c997bdf224" + intDecLe := h "1710034a517f249f5c8265e8e2783be60619f0c8e85f4eab625e85983abd722e" + intDecLt := h "5318877ae61e1da37980d80c11e3e47a36d850c3e43e99716122f1e6eff01e9f" punit := h "2dfc16af01b82b3b91c2ff704409d76236a83f956c0c6e6659a64fe21d76695b" pprod := h "90ca5bcf995d68d7dfcb3c7cfe466986dc4beaa402b262ca395b3e53c36f6cad" pprodMk := h "ce30fc0f4135e679cf3b16d0d667bd9df4e7a69dbb8177a29e5c75b48c4cec10" - natRec := h "d1053449c217e5cc6fc29b2cb59cfd5ead385d392d00ada2221d4000dda7def3" - natCasesOn := h "c575abb02efd158091356aa793c809c0570f8a24a8a777f206a95b9ce0b88855" - bitVec := h "7f0f5feda1828072123f242a46a40549e85934f7395e4f93f65dda4e4809f325" - bitVecToNat := h "c110d614b441c6cca69ecd7c1c2c76f3bc21fd40c4001e6a1a7d1cf481e23cdd" - bitVecOfNat := h "29b9f24086b1b1f88211358866139fdb7dcdfc97b5f6c77fc495bf8c77639982" - bitVecUlt := h "9301d850bde246940b7b3e81e786f7f12bae8e5cea6b3f4040060b3a7f59557c" - decidableDecide := h "20e8906280b4dcd74a7a78e06d580e6f00eebba9fc40789262e95cacb6f0d699" - ltLt := h "4802b183f4d6dcccacba57721824a7bb67daeb2725da17239271c135952caa61" - ofNatOfNat := h "a99dedbb1676866aed829c3d4bba86a37e98ec62a35834389c32937e4e2b1a4a" + natRec := h "c8322e03d558f85a8edc7fe68524013880ad0bbcb7dc890136d247154b230992" + natCasesOn := h "937374ed09b8b62f36ef75f06f1ee46dd487c7a9f3e74db919bde48bb76b2cc6" + bitVec := h "90022ae4c5d52ad28acd80051dd41f27f51c9c4afbab1bb391773c19ef0dc1e9" + bitVecToNat := h "fade2dbfb1d7f77c30c247d52df128bf516eedce01f817d363ce88da13cfac2b" + bitVecOfNat := h "67160b97679306d2820445383a6d740e6fe9839c2545ea48680ff2a77b0be986" + bitVecUlt := h "2f9c9c369045036d9a35ff7b38285dca3b976426c81a8f366fce1161b090d60d" + decidableDecide := h "11157bc3898f06e3e6f2ca83411efd0d43b8846b57d2f6088e18f3447ddc3b28" + ltLt := h "061c2658c76a68d90978859824993bbbe15dbf9b9968619325420e7c839b05c7" + ofNatOfNat := h "cb84bffa6d7092a309630214af29d9ec4e35cd5e0003eb9cdf75ee484e24925b" unit := h "9232498667f765f437dedaac828e555f6cc67a20e6db28f614fdf3c262710feb" - punitSizeOf1 := h "e85bf516c76cadd8ce1fdab3cc94ed685e47be3c7a8b52f53fe2b3502e6f70c7" - sizeOfSizeOf := h "402b71bcccf0be0315f1bda6bdbb20e559e31704617d3eaccb05d5c5fe03b53d" - stringBack := h "32104b03348d11acb2437fda24966dc58cc8c8bcca96582614e644d319a42c62" - stringLegacyBack := h "37ef5fee765dc2e5c7425c180cd42007db7d29ae0d5c091789f462f2805b0e09" - stringUtf8ByteSize := h "52b0226ea14c94b1f9334c9957f5589399a86bcdae111f2847c9b0c2fb0a2261" - stringAppend := h "132f1175cc3cac5a3e3d74e8797f9ba67f2e467b8004a3f28bb5dfd16a3647b1" - stringDecEq := h "19134fdc188e8377d0173857e15d3b5065ed76da981397107e5c404db3f3b718" + punitSizeOf1 := h "523699b6e827b74a950d4718bdf5b13c193e3c7c371aaad4d635667be74b05fa" + sizeOfSizeOf := h "ea81aee4a7d154faa8211a2594406dfdc7442020c0f29d2d0f79b4e62314da51" + stringBack := h "b052e814120ea6299aecf4e9bb2b656d67c1f9537e8f0e9f16479c98a04fde93" + stringLegacyBack := h "10af1decd5d2cd085adff8ae7fb44cfc5d22a89bbc40b81b809d3d556fda3e8f" + stringUtf8ByteSize := h "4c086826cc679df3b6aa57a29f3d093a8a92d0de4edecef46a908d8398733dc0" + stringAppend := h "0eae69f3f8b198d1ffac67b9e88d39526b1b039ff519cd87eec106f63974860c" + stringDecEq := h "da7bb331e098f9bf5cdabcb9609a7e953dffc609ad9d90871a14c016c52a3011" /-- The synthetic kernel-only marker address used by the *original* (LEON-addressed) environment's `PrimAddrs::new_orig()`. Only the marker is diff --git a/Ix/Tc/Verify/Driver/BooleanAcceptance.lean b/Ix/Tc/Verify/Driver/BooleanAcceptance.lean index 7c773fe85..5fdb7b1e6 100644 --- a/Ix/Tc/Verify/Driver/BooleanAcceptance.lean +++ b/Ix/Tc/Verify/Driver/BooleanAcceptance.lean @@ -9,7 +9,7 @@ E3-S production-driver adapter. The runtime checker call remains a required gate, but semantic authority for these two coordinated blocks comes from the fixed family transition and existing-recursor certificates. In particular, the proof supplies a topological semantic schedule independently of runtime -cache order. The v3 address order enumerates the family before its recursor. +cache order. The Ixon address order enumerates the family before its recursor. The staged baseline below has the constructively generated Boolean Theory environment and an empty trust predicate. Its `VEnv.WF` field is derived @@ -419,7 +419,7 @@ theorem subjects_disjoint_assumptions : simp [noAssumptions] at haddr /-- The family is admitted first because every recursor reference collapses -into that family block. This schedule agrees with the v3 address order. -/ +into that family block. This schedule agrees with the Ixon address order. -/ def wellFounded : WellFoundedBlocks dependencyGraph (expectedAnonWork recursorIxonEnv) sourceWF.subjects where diff --git a/README.md b/README.md index aa13843c9..8cac0b8ce 100644 --- a/README.md +++ b/README.md @@ -215,7 +215,10 @@ not this stable overview. **Lean tests:** `lake test` -- `lake test -- ` runs one or multiple primary test suites. Primary suites: `ffi`, `byte-array`, `ixon`, `claim`, `commit`, `canon`, `keccak`, `sharing`, `graph-unit`, `condense-unit` +- `lake test -- ` runs one or multiple primary test suites. Primary suites: `ffi`, `meta-env`, `catalog`, `import-ixe`, `truthmines-spec`, `ixon`, `ixon-syntax`, `claim`, `merkle`, `assumption-tree`, `commit`, `canon`, `keccak`, `exact-sharing`, `exact-sharing-ffi`, `source-contract`, `graph-unit`, `condense-unit`, `bench-measures`, `aux-gen-unit`, `ground-unit`, `aiur-cross`, `aiur-cost`, `prim-addrs`, `primitive-address-parity`, `decompile-unit`, `tc-unit` + - `exact-sharing` tests the canonical sharing construction of Ixon v4; `exact-sharing-ffi` checks that Lean and Rust produce identical bytes + - Primary runners run with the primary suites and can be selected by name in the same way: `aiur-rust-syntax`, `ixvm-tagn`, `aiur-prove`, `aiur-hashes`, `rbtree-map`, `multi-stark`, `recursive-verifier`, `ix-aggr`, `ixes-manifest`; `ixvm-tagn` holds the IxVM circuit's TagN codec to the Lean codec +- `lake exe ixon-v4-tests` runs the Ixon v4 format suite (golden bytes, FFI, VM, text grammar, resource admission, claims, and the fixtures in `Tests/Fixtures/ixon-v4/`); `lake exe ixon-v4-primitives` regenerates the primitive closure and checks `primitives.tsv` against it; both keep their scratch files in `$IX_IXON_V4_DIR` (default `/tmp`) - `lake test -- --ignored` runs all expensive test suites and runners - Most tests require at least 32 GB RAM - The `compile` and `decompile` tests require 128 GB RAM diff --git a/Tests/AggrSemantics.lean b/Tests/AggrSemantics.lean index 40c571f68..55d51ff52 100644 --- a/Tests/AggrSemantics.lean +++ b/Tests/AggrSemantics.lean @@ -115,8 +115,11 @@ private def stage2FixturePinnedAndFenced : IO Bool := do IO.eprintln "Stage 2 fixture bytes or historical root drifted" return false match Aggr.decodeAggregateWrapperAt address bytes with - | .error "claim: unsupported object format" => pure () - | _ => + | .error e => + unless e.startsWith "claim: unsupported object format" do + IO.eprintln s!"Stage 2 fixture did not reject at its format boundary: {e}" + return false + | .ok _ => IO.eprintln "Stage 2 fixture did not reject at its format boundary" return false let ixExe : System.FilePath := ".lake" / "build" / "bin" / "ix" diff --git a/Tests/Cli.lean b/Tests/Cli.lean index ad711c26b..9f632f5d5 100644 --- a/Tests/Cli.lean +++ b/Tests/Cli.lean @@ -109,7 +109,58 @@ private def Tests.Cli.testCompileContracts : IO Unit := do let result ← compile "cliEscape" flags if result.exitCode == 0 || (← output.pathExists) then throw <| IO.userError "CLI emitted an artifact for an escaping local input" - IO.println "v3 CLI: source/import contracts preserved; local escape rejected in every output mode" + IO.println "CLI: source/import contracts preserved; local escape rejected in every output mode" + finally + IO.FS.removeDirAll dir + +/-- `ix compile --sharing-limits`: a malformed override is rejected before + compiling (nothing written), a valid one (Lean and Rust keys mixed) + compiles, and a limit no constant fits in fails the compile naming the + limit (so an override that never reached the compiler would be caught). + An invalid `IX_SHARING_LIMITS` set directly fails the compile once. -/ +private def Tests.Cli.testCompileSharingLimits : IO Unit := do + let ix ← IO.FS.realPath ".lake/build/bin/ix" + let dir ← IO.FS.createTempDir + let source := dir / "SharingLimits.lean" + let output := dir / "sharing-limits.ixe" + let occurrences (out : IO.Process.Output) (s : String) : Nat := + (out.stdout.splitOn s).length - 1 + ((out.stderr.splitOn s).length - 1) + try + IO.FS.writeFile source + "def limitsMarker : Nat := 7\ntheorem limitsProof : limitsMarker = 7 := rfl\n" + let args := #["compile", source.toString, "--no-build", "--consts", "limitsProof", + "--out", output.toString] + let run := fun (spec : String) => IO.Process.output { + cmd := ix.toString, args := args ++ #["--sharing-limits", spec] } + let bad ← run "bogus=1" + if bad.exitCode == 0 || (← output.pathExists) then + throw <| IO.userError s!"compile accepted --sharing-limits bogus=1:\n{bad.stdout}\n{bad.stderr}" + unless (bad.stderr.splitOn "unknown sharing limit bogus").length > 1 do + throw <| IO.userError s!"--sharing-limits bogus=1: unexpected error:\n{bad.stderr}" + -- Every serialized constant is longer than one byte: the override must + -- reach the compiler and fail it, naming the limit to raise. + let tight ← run "output_bytes=1" + if tight.exitCode == 0 || (← output.pathExists) then + throw <| IO.userError s!"compile ignored --sharing-limits output_bytes=1:\n\ + {tight.stdout}\n{tight.stderr}" + unless occurrences tight "--sharing-limits output_bytes=N" > 0 do + throw <| IO.userError s!"--sharing-limits output_bytes=1: unexpected error:\n\ + {tight.stdout}\n{tight.stderr}" + -- An invalid override set directly in the environment (no flag, so no + -- Lean pre-check) fails the compile once, before any block. + let direct ← IO.Process.output { + cmd := ix.toString, args, env := #[("IX_SHARING_LIMITS", some "bogus=1")] } + if direct.exitCode == 0 || (← output.pathExists) then + throw <| IO.userError s!"compile accepted IX_SHARING_LIMITS=bogus=1:\n\ + {direct.stdout}\n{direct.stderr}" + unless occurrences direct "IX_SHARING_LIMITS: unknown sharing limit bogus" == 1 do + throw <| IO.userError s!"IX_SHARING_LIMITS=bogus=1: expected one error:\n\ + {direct.stdout}\n{direct.stderr}" + let good ← run "states=2^44, depth=2^22, work=max" + unless good.exitCode == 0 && (← output.pathExists) do + throw <| IO.userError s!"compile --sharing-limits failed:\n{good.stdout}\n{good.stderr}" + IO.println "compile --sharing-limits: malformed override rejected, tight limit enforced, \ + invalid IX_SHARING_LIMITS rejected once, valid override compiled" finally IO.FS.removeDirAll dir @@ -117,6 +168,7 @@ public def Tests.Cli.suite : IO UInt32 := do Tests.Cli.run "lake" (#["exe", "ix", "--help"]) none Tests.Cli.testCompileNoBuild Tests.Cli.testCompileContracts + Tests.Cli.testCompileSharingLimits --Tests.Cli.run "ix" (#["store", "ix_test/IxTest.lean"]) none --Tests.Cli.run "ix" (#["prove", "ix_test/IxTest.lean", "one"]) none return 0 diff --git a/Tests/FFI/Ix.lean b/Tests/FFI/Ix.lean index b1da48b33..10c05e385 100644 --- a/Tests/FFI/Ix.lean +++ b/Tests/FFI/Ix.lean @@ -275,7 +275,8 @@ def decompileErrorTests : TestSeq := test "DecompileError.blobNotFound" (roundtripDecompileError (.blobNotFound addr) == .blobNotFound addr) ++ test "DecompileError.badBlobFormat" (roundtripDecompileError (.badBlobFormat addr "UTF-8") == .badBlobFormat addr "UTF-8") ++ test "DecompileError.badConstantFormat" (roundtripDecompileError (.badConstantFormat "bad") == .badConstantFormat "bad") ++ - test "DecompileError.serializeError" (roundtripDecompileError (.serializeError se) == .serializeError se) + test "DecompileError.serializeError" (roundtripDecompileError (.serializeError se) == .serializeError se) ++ + test "DecompileError.invalidMetaShareIndex" (roundtripDecompileError (.invalidMetaShareIndex 9 2 4 3 "meta") == .invalidMetaShareIndex 9 2 4 3 "meta") def compileErrorTests : TestSeq := let addr := Address.blake3 (ByteArray.mk #[4, 5, 6]) @@ -286,7 +287,8 @@ def compileErrorTests : TestSeq := test "CompileError.unsupportedExpr" (roundtripCompileError (.unsupportedExpr "mvar") == .unsupportedExpr "mvar") ++ test "CompileError.unknownUnivParam" (roundtripCompileError (.unknownUnivParam "Nat" "u") == .unknownUnivParam "Nat" "u") ++ test "CompileError.serializeError" (roundtripCompileError (.serializeError se) == .serializeError se) ++ - test "CompileError.resourceLimit" (roundtripCompileError (.resourceLimit "memory reserve") == .resourceLimit "memory reserve") + test "CompileError.resourceLimit" (roundtripCompileError (.resourceLimit "memory reserve") == .resourceLimit "memory reserve") ++ + test "CompileError.sharingConstruction" (roundtripCompileError (.sharingConstruction "internal") == .sharingConstruction "internal") /-! ## Test Suite -/ diff --git a/Tests/Fixtures/ixon-v3/claims.tsv b/Tests/Fixtures/ixon-v3/claims.tsv deleted file mode 100644 index 4c3aa7f28..000000000 --- a/Tests/Fixtures/ixon-v3/claims.tsv +++ /dev/null @@ -1,8 +0,0 @@ -# Ixon v3 claims: name, BLAKE3, canonical bytes -eval bdb4aba0a94573eb1b00e78bb3a21bed8d412342edc9ff92ee822ab672924000 e3030117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d55301633a6413b154ef0ada30dbc102c8d497e392c1ecd7f2071b4653be5400cad1b8 -check c3db3161d1a2861f4d6d2cd6b19259ca80fde1a678b876cd8c8ede6c5b19dec3 e4030117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f00 -check_env 6b805be3f0317c7c63bd7e1015420fbc2af23453f09460ffc0fa7eec894e9421 e5030117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f01633a6413b154ef0ada30dbc102c8d497e392c1ecd7f2071b4653be5400cad1b8 -reveal 48ac6a16791489b9217f891ece07fbd550d8ece67d550949442b0a98077436b3 e6030017762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f0200 -contains 6dc0d713f870034fd1da263812086f0f62caf4a6757ceb2b5af0c5243e992791 e7030017762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d553 -catalog 2bb645df227f0b03ee9496cc3635e7a00e031a1698d5fd2c77f2294409c55112 e808030117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d55301633a6413b154ef0ada30dbc102c8d497e392c1ecd7f2071b4653be5400cad1b8 -resource c7170cd2fc32f02ebd6a86618f1c54a073ca4469c85fcb3111c1c1196f3769f3 e809030217762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d553 diff --git a/Tests/Fixtures/ixon-v3/expressions.txt b/Tests/Fixtures/ixon-v3/expressions.txt deleted file mode 100644 index e9a764cc3..000000000 --- a/Tests/Fixtures/ixon-v3/expressions.txt +++ /dev/null @@ -1,12 +0,0 @@ -# Independently specified Ixon v3 bytes: relative locality, no lifetime parameters. -app 7313121110 -lam 8307000700070010 -lam_local_unique 81090010 -lam_affine_local 810e0010 -all 922900170010 -ordinary_let a100006110 -local_unique_let a00a001110 -borrow a20e0041021110 -borrow_nondep a30f001110 -reference 2000 -recursion 32020001 diff --git a/Tests/Fixtures/ixon-v3/handoff/accepted.claim b/Tests/Fixtures/ixon-v3/handoff/accepted.claim deleted file mode 100644 index 6ecbba2f9..000000000 --- a/Tests/Fixtures/ixon-v3/handoff/accepted.claim +++ /dev/null @@ -1 +0,0 @@ - q:秪DZ Lyidç7)wǢ*ƫ \ No newline at end of file diff --git a/Tests/Fixtures/ixon-v3/handoff/manifest.json b/Tests/Fixtures/ixon-v3/handoff/manifest.json deleted file mode 100644 index 59e77394b..000000000 --- a/Tests/Fixtures/ixon-v3/handoff/manifest.json +++ /dev/null @@ -1,16 +0,0 @@ -{"validator": "ixon-v3/resource-v1", - "subject": "f0e971f93ae7a7aa0fbf87df16a2445afdbb8d89dc0c20934cb9ae7901958269", - "schema": "ixon-v3-handoff-1", - "profile": "64abccc3a713372977c3f3857febbdccc7a20fb08c2a86f0bbbec6ab0e880794", - "objectFormat": "ixon-v3", - "ixvmResourceProof": false, - "files": - {"rejected-local-escape.ixe": - "b9a28e222a6deaf7fae2ca386e5f2dda91b464cf2d7e9e713b2c42bdfc6a3019", - "profile.bin": - "64abccc3a713372977c3f3857febbdccc7a20fb08c2a86f0bbbec6ab0e880794", - "accepted.ixe": - "b6d12995849c9dfdf2956653e41256a3567b1b9359148a34e1044ad4a7efff89", - "accepted.claim": - "0c770089a4c33228e1e46d8c040b8698c32fa785b5bde552664f677b45409a48"}, - "claim": "0c770089a4c33228e1e46d8c040b8698c32fa785b5bde552664f677b45409a48"} diff --git a/Tests/Fixtures/ixon-v3/handoff/profile.bin b/Tests/Fixtures/ixon-v3/handoff/profile.bin deleted file mode 100644 index 213d5e6e3..000000000 Binary files a/Tests/Fixtures/ixon-v3/handoff/profile.bin and /dev/null differ diff --git a/Tests/Fixtures/ixon-v3/primitives.tsv b/Tests/Fixtures/ixon-v3/primitives.tsv deleted file mode 100644 index 4337a99f4..000000000 --- a/Tests/Fixtures/ixon-v3/primitives.tsv +++ /dev/null @@ -1,94 +0,0 @@ -# Ixon v3 canonical primitive addresses -Nat 35e1cc809f6f076521a43f85068d5592220407c0532b6a08952f40d8523d04bc -Nat.zero eeb2e6268ff6d0e6b2e9764d9940b81bb64b9f8f4b1358d294ff9817e6941a46 -Nat.succ 42d6ed31536f0958176f1dc973383808ac8583223746ebca78dbe389b65321a6 -Nat.add 724db797e1817545a08371432fd1fa6428a37dcf9c1671df7e464849db0a81ac -Nat.pred 76afa254a8bbf2ac4327d7b94be0c63bd708836b5f7384ce990388adb0a1d3cf -Nat.sub 9de2d2c60e7d421a2fdfb8706e91e0e6d8576c3bd46ec00405c65875cb9b5a26 -Nat.mul 566a3c2249bc2076543d9bc561a841f6fd35ffb5bdbbc5c991a9c64feccbd5d4 -Nat.pow 5ba43ac3e5d29fe5ce81f18a18178a2705c37ee674b9b6ee50e9466a86593b15 -Nat.gcd 76007dcf8b285cdbd6f779012290fe2e6afd221ce8821082a7e2ef81e8d815cf -Nat.mod e6ffe78713d4b974a82d0187538f1a0cf5c4b260f0fd99264fab263b1af847f9 -Nat.div c075ed976f1702f364fb0bb34aa8bbc166adace573f2ce914b43dc4f4aab6219 -Nat.bitwise aaf7df6a1f024f580fde236cba16235f071d1b796cc279faf43178d22b5ae36d -Nat.beq ffd3f02a19fda649aa5608ed818db382e160231b76d5b09176d7dd1a8d5b1ec5 -Nat.ble 68a3643ec69816aec107302ddbfa054cebcd3ec173cd5f7e6d883638631afe65 -Nat.land c61fad46a102dbff5922312d4fbe6e704ec3c62c6c6f64b3d481b78c77cf315d -Nat.lor cb7dccc020a530fed7c622b100ee52c1078b5018159ba4682f817e3776789ee8 -Nat.xor d8a6b05a1a4e5cadc69c53792e8e130314745e76e32bb30a9ce0272fa079e8a6 -Nat.shiftLeft 5c15f98e2bd9c257bcdfac62b0043a2e3e2bbdff8b210f104b5c3739e862ac0c -Nat.shiftRight 3f92725324b09fa75c6fcd16da863671428ff33b7db667eb760e1cd503a2bcad -Bool e6eba3c8b4d19f6a1076b39fa89aec61dccbb960f83d9a62e6acf35a69c9a0a4 -Bool.true a29a636176cf1135d077eb074798f9007c78e7801383e9cff363bae5edf05762 -Bool.false dda12bcb330727f6dfb816bc9752aabd0520e6515b79fc8a5a9e713866f4c63e -String 9d6ae43429ec02a9338bbcd0db0ac193d75ebd46f884bfcbd2c42bf7faea150d -String.mk 272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2 -Char 4c59bc4eac82d31ebed59bb206909dbded65b92fd56de2518fcdadb0a42c11a0 -Char.mk 82e09601422cae23b0b6df9922abb9f0b014e20047a00a7ab96871dd7da3e5ac -Char.ofNat caf51b039d71cfce7063e106064f9435f5337bbc42567c8c78b5f66c7f087920 -String.ofList 272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2 -List 4fb6b41c30532e6ab4acb4eefe01da1314ee7f2129af8989fd63f7ec277aaf01 -List.nil 3994bc51e3686f30a1d483d69d0a835a7b484d892393c084f87a5849de54f302 -List.cons b3a7d80249fd823100ee03626232d1412a0e8335275d5df53b92943887b650f7 -Eq c37d6290e00fb865fb5db7bce18fd69e6d1674ad573724b85466ea9f7578a207 -Eq.refl d494dc601386ba8e8f0b711fe62a2d60ab60c6488c8cf6ce97796ebc3ad5fefb -Quot 45040b3126855169dad919a970a9c72cee5875658aedb3bd1f89fcdf8c88edfa -Quot.mk 811600dfa59f3612cb03c0f0475af152399defff9226c6e19fd648041a6899a9 -Quot.lift 86b365e75bb4230f04c6e4f3a7ca6988adf574616d79a3d7477ad65cac102110 -Quot.ind 1745491c0d651de0bea589d5fffbc9bc4d7fbe897c1d805b1f7f59ca9696a6ef -Lean.reduceBool bacc4c814a4572ddfd969a1857adfe18239eb6bd8b1627ee79744a6a9b23b030 -Lean.reduceNat b6327d9a1bbb461a447f0c971e622dd9a35132bd7de75bf69e20794d7a0e8595 -eagerReduce 173299c76efa82e689210a09e49ad09c14ee1108f2da8d355ef9333b1583a1d5 -System.Platform.numBits 6f620654d341990a301387b80ef75b1e0b6130ddf19164025b6dc37bf3c3dc18 -System.Platform.getNumBits 00c266834f9039931b4be2fac5584cd176a0ae7ee4cb4064ddb5e04dd12b6cbb -Subtype.val ea65f517457fae9b705299da08b0d3c8cf9a476f16470cca5cae5ea7bd238230 -String.toByteArray 79862acfbc2e37b7b6122143f0a6a51114c34fa483ff14146483de18835d4209 -ByteArray.empty bf58e6cb3aa0f746850629041635cd30c0ad66262b6617660f2290241f08b08b -Nat.decLe f0f15ed079822f06e82e36664bf61e797e5b1e7b0b4155152762c513274bfee1 -Nat.decEq 8a5d5eee414a2fa5956b74e8323a20508d774ed1b5603f55e774ad896bd3e6e7 -Nat.decLt 7c4977196e95be2a759fc9c6d1533db8da49592f06419b155d888333c8dd8931 -Decidable.rec 16cfddda9c274660f391b10eefe066275afffae1ccd49c6daf43afb8a80aea85 -Decidable.isTrue 363d071182be414e1a58599b83f5e19f9b873723054f4287ba69705aafef27da -Decidable.isFalse 8cc0e1360c1b29108dab3d6172e7fce8a9aa9640daa4bbe99ba1305d9623624b -Nat.le_of_ble_eq_true ad25bfd207bae832c73d5ce614bead22ef9862e110f8d17a5064ffb7603eee3d -Nat.not_le_of_not_ble_eq_true e3658f50dc5123efff213588dee3d4c6063f5edb18950850ac0490c937819009 -Nat.eq_of_beq_eq_true 9c91e79de732226ba2e73cbdd330851baec40668eb40c6f32aa2f8dac5a04b51 -Nat.ne_of_beq_eq_false a07db532747e65ee77a7ba015069bdbaf1f709ce0d60b83c94f40d0e5e57595a -Fin 3d79797bc572d8f33eb7cff5aa13f8dc73bcf21026bf05d03888c9aa0369dcef -Bool.noConfusion de7b523cc4470e15328a01d935988861dadf9bd012240400464dea8c79a9dfe2 -Int c60c95e3cdbf4ed010d999b3277f4e1fd3695e8c30260876102905d7b36241a2 -Int.ofNat 0a99f49cc73ab9f42783092e7120613225670bab89b9d63533d1adefc876182f -Int.negSucc f7130d5864e1ba77b0f6a7338f92159c35bd5147e0febcf1ebed456e513538cc -Int.add 9db0177e4e8b6a0e7323069509c2457de9598a7e38e72ffe19ad34617256e10d -Int.sub 85621387ef3027028d835287f3cc1461ef041def1fd91e28e87f669cc04a5eea -Int.mul b05459623d23299d3a849eb7fb75badbc1547a1cd9ee560c15067fbd985c6cea -Int.neg 6701d765ff10bfa3a6c347df15194e0db862ee25b54f25a59f7cf21951a3997e -Int.emod e29cfa7921bb57f4782b021c977596a4fae04e94f7b07955fe2814fc48de90e7 -Int.ediv 9c952d45a3bd43161529fcfb5e276beab0cf4fd64a01ba9bc2c7cda376cb8f54 -Int.bmod 0b1564dea6ffcd204ebcd1aa69d29ee6f3acccd87bd146ff674556ac9cc8ccb3 -Int.bdiv 6d35dc43660f6c509a13f2824c027ed99ab070a08f058ff0a5f46a759250797d -Int.natAbs 261ae54edb66e900784a64350bc01e8b3fe1332a47caeab58e0361dffc7ea008 -Int.pow 87266415982bbdec50c61dec5b73cc0ccd5c997445997a9724a1cc5c2e39d3a4 -Int.decEq fc8c44cc970cfc183ccd10a2d1cdeb2c849307760e91f5cd29a2b02f706d83da -Int.decLe fcdf1860ad4cd672239392e60e7b49e024af0475739c3a40195a914eaec42c04 -Int.decLt 1d54806ab1ebc791e1db96e88d0407cef3523927d60ba669689b92a8eeb36445 -PUnit 2dfc16af01b82b3b91c2ff704409d76236a83f956c0c6e6659a64fe21d76695b -PProd 90ca5bcf995d68d7dfcb3c7cfe466986dc4beaa402b262ca395b3e53c36f6cad -PProd.mk ce30fc0f4135e679cf3b16d0d667bd9df4e7a69dbb8177a29e5c75b48c4cec10 -Nat.rec d1053449c217e5cc6fc29b2cb59cfd5ead385d392d00ada2221d4000dda7def3 -Nat.casesOn c575abb02efd158091356aa793c809c0570f8a24a8a777f206a95b9ce0b88855 -BitVec 7f0f5feda1828072123f242a46a40549e85934f7395e4f93f65dda4e4809f325 -BitVec.toNat c110d614b441c6cca69ecd7c1c2c76f3bc21fd40c4001e6a1a7d1cf481e23cdd -BitVec.ofNat 29b9f24086b1b1f88211358866139fdb7dcdfc97b5f6c77fc495bf8c77639982 -BitVec.ult 9301d850bde246940b7b3e81e786f7f12bae8e5cea6b3f4040060b3a7f59557c -Decidable.decide 20e8906280b4dcd74a7a78e06d580e6f00eebba9fc40789262e95cacb6f0d699 -LT.lt 4802b183f4d6dcccacba57721824a7bb67daeb2725da17239271c135952caa61 -OfNat.ofNat a99dedbb1676866aed829c3d4bba86a37e98ec62a35834389c32937e4e2b1a4a -Unit 9232498667f765f437dedaac828e555f6cc67a20e6db28f614fdf3c262710feb -PUnit._sizeOf_1 e85bf516c76cadd8ce1fdab3cc94ed685e47be3c7a8b52f53fe2b3502e6f70c7 -SizeOf.sizeOf 402b71bcccf0be0315f1bda6bdbb20e559e31704617d3eaccb05d5c5fe03b53d -String.back 32104b03348d11acb2437fda24966dc58cc8c8bcca96582614e644d319a42c62 -String.Legacy.back 37ef5fee765dc2e5c7425c180cd42007db7d29ae0d5c091789f462f2805b0e09 -String.utf8ByteSize 52b0226ea14c94b1f9334c9957f5589399a86bcdae111f2847c9b0c2fb0a2261 -String.append 132f1175cc3cac5a3e3d74e8797f9ba67f2e467b8004a3f28bb5dfd16a3647b1 -String.decEq 19134fdc188e8377d0173857e15d3b5065ed76da981397107e5c404db3f3b718 diff --git a/Tests/Fixtures/ixon-v3/addressed.tsv b/Tests/Fixtures/ixon-v4/addressed.tsv similarity index 80% rename from Tests/Fixtures/ixon-v3/addressed.tsv rename to Tests/Fixtures/ixon-v4/addressed.tsv index 29263dc56..6c82c7bd9 100644 --- a/Tests/Fixtures/ixon-v3/addressed.tsv +++ b/Tests/Fixtures/ixon-v4/addressed.tsv @@ -2,4 +2,4 @@ unit cfec05d1d7f2512f6577c2f61a840523804c36d4043c252ab4ba2508ede75171 c1010000000000010000000000300000000100 identity 2bfe346531f29ca79736cba6b86eec46c2451fd6f6c8c8ed70580541bc131dca d00100913d20002000810d2000b0011001e35ab17358fae7a81efb3d94a164fd3f85ab8b0c888aaa071cfe0d60ffbc1cac00 identity_unique bf78ce4d73d6a6ddc46f6324a1d8d86ebcca4e1a6e4ceb9c423b06b188f25e57 d0010091012000200081012000b0011001e35ab17358fae7a81efb3d94a164fd3f85ab8b0c888aaa071cfe0d60ffbc1cac00 -profile e00a234193f2bc4d95f8f3078ade98a0a4edc843b2e87108b462f77eb1a2a704 69786f6e2d76332f7265736f757263652d76312f70726f66696c65000001e35ab17358fae7a81efb3d94a164fd3f85ab8b0c888aaa071cfe0d60ffbc1cac0001e35ab17358fae7a81efb3d94a164fd3f85ab8b0c888aaa071cfe0d60ffbc1cac0081000182a08601 +profile 15755ccacc59fbe01fa64bcdde415ad3d08d986b345775adc50116929aa6d789 69786f6e2d76342f7265736f757263652d76312f70726f66696c65000001e35ab17358fae7a81efb3d94a164fd3f85ab8b0c888aaa071cfe0d60ffbc1cac0001e35ab17358fae7a81efb3d94a164fd3f85ab8b0c888aaa071cfe0d60ffbc1cac008080c1204600 diff --git a/Tests/Fixtures/ixon-v4/claims.tsv b/Tests/Fixtures/ixon-v4/claims.tsv new file mode 100644 index 000000000..64fc517f9 --- /dev/null +++ b/Tests/Fixtures/ixon-v4/claims.tsv @@ -0,0 +1,8 @@ +# Ixon v4 claims: name, BLAKE3, canonical bytes +eval 2dc9141173ab8bc6a2fa78eaf83310778fd068f53905dcf8b5ff658487c78d1f e3040117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d55301633a6413b154ef0ada30dbc102c8d497e392c1ecd7f2071b4653be5400cad1b8 +check 195939e34c35e40802284f608651133ba44b0cc4faf5ba87a34f03a7bb1739cc e4040117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f00 +check_env 410237ff10beb31c7b51feb45c9fa27d35d0f95524724b16b0d9c56e64de6b77 e5040117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f01633a6413b154ef0ada30dbc102c8d497e392c1ecd7f2071b4653be5400cad1b8 +reveal afdae8fa907905113d02ca5b1dd7689383bb2f8c7f1166986ae35cf50210cd30 e6040017762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f0200 +contains 192ab5ad4cef4276e7bc97e6526edcc29bf411f5b37ac2e7b02ea9cfe74f007c e7040017762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d553 +catalog eb77e21049dd96137a688b7ecfbf25b30a8d62d5fc400d9d73c6e1e77ca2df48 e800040117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d55301633a6413b154ef0ada30dbc102c8d497e392c1ecd7f2071b4653be5400cad1b8 +resource 6ec341265ae218b90814c5e9072979a81d409ae85373ea3addba17a3681508dd e801040217762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d553 diff --git a/Tests/Fixtures/ixon-v4/expressions.txt b/Tests/Fixtures/ixon-v4/expressions.txt new file mode 100644 index 000000000..8c1d36751 --- /dev/null +++ b/Tests/Fixtures/ixon-v4/expressions.txt @@ -0,0 +1,61 @@ +# Independently specified Ixon v4 bytes: relative locality, no lifetime parameters. +app 7313121110 +lam 8307000700070010 +lam_local_unique 81090010 +lam_affine_local 810e0010 +all 922900170010 +ordinary_let a100006110 +local_unique_let a00a001110 +borrow a20e0041021110 +borrow_nondep a30f001110 +reference 2000 +recursion 32020001 +# Multi-byte TagN in context: the last and first value of every rung, derived +# by hand from the TagN rung table, not by the codec under test. A header byte +# [flag : f bits][payload : r = 8 - f bits] is followed by 0, 1, 2, 3, 4 or 8 +# little-endian bytes. With lead = 2^(r-1) and m = 2^(r-2): +# rung 1, [0, R1): payload = value R1 = lead +# rung 2, [R1, R2): payload = lead + (value - R1) / 256, then one byte +# (value - R1) mod 256 R2 = R1 + 2^(r-2+8) +# rungs 3, 4, 5, 6: payload = lead + m + c for c = 0, 1, 2, 3, then +# value - R2, R3, R4, R5 in 2, 3, 4, 8 bytes +# R3 = R2 + 2^16, R4 = R3 + 2^24, R5 = R4 + 2^32 +# f = 4 (expression headers; Var is flag 1, so the header is 0x10 + payload): +# lead 8, m 4; R1..R5 = 8, 1032, 66568, 16843784, 4311811080 = 0x1_0101_0408. +# var 1031: 1023 = 3 * 256 + 255, payload 8 + 3 = 0xB -> 1B FF +# var 66567 - 1032 = 65535 -> 1C FF FF; var 16843783 - 66568 = 2^24 - 1 +# var 4311811079 - 16843784 = 2^32 - 1 +# var 2^64 - 1: 0xFFFFFFFF_FFFFFFFF - 0x1_0101_0408 = 0xFFFFFFFE_FEFEFBF7, +# little-endian F7 FB FE FE FE FF FF FF +# f = 0 (the Ref index after the header 20, a Ref with no universes): +# lead 128, m 64; R1..R5 = 128, 16512, 82048, 16859264, 4311826560 = 0x1_0101_4080. +# ref 16511: 16383 = 63 * 256 + 255, payload 128 + 63 = 0xBF -> BF FF +# ref 2^64 - 1: 0xFFFFFFFF_FFFFFFFF - 0x1_0101_4080 = 0xFFFFFFFE_FEFEBF7F, +# little-endian 7F BF FE FE FE FF FF FF +# Counts and other flags: an App of 8 arguments (78 00: count 8 is rung 2 of +# f = 4, flag 7), a Ref with 8 universes (28 00), Share(1032) (rung 3, flag 0xB). +tagn4_rung1_last 17 +tagn4_rung2_first 1800 +tagn4_rung2_last 1bff +tagn4_rung3_first 1c0000 +tagn4_rung3_last 1cffff +tagn4_rung4_first 1d000000 +tagn4_rung4_last 1dffffff +tagn4_rung5_first 1e00000000 +tagn4_rung5_last 1effffffff +tagn4_rung6_first 1f0000000000000000 +tagn4_rung6_last 1ff7fbfefefeffffff +tagn0_rung1_last 207f +tagn0_rung2_first 208000 +tagn0_rung2_last 20bfff +tagn0_rung3_first 20c00000 +tagn0_rung3_last 20c0ffff +tagn0_rung4_first 20c1000000 +tagn0_rung4_last 20c1ffffff +tagn0_rung5_first 20c200000000 +tagn0_rung5_last 20c2ffffffff +tagn0_rung6_first 20c30000000000000000 +tagn0_rung6_last 20c37fbffefefeffffff +app_telescope_8 780018001716151413121110 +ref_univs_8 2800000001020304050607 +share_rung3 bc0000 diff --git a/Tests/Fixtures/ixon-v4/handoff/accepted.claim b/Tests/Fixtures/ixon-v4/handoff/accepted.claim new file mode 100644 index 000000000..4fcb8820f --- /dev/null +++ b/Tests/Fixtures/ixon-v4/handoff/accepted.claim @@ -0,0 +1,2 @@ +q:秪DZ LyiaI2%PyC5^?P0 +7 \ No newline at end of file diff --git a/Tests/Fixtures/ixon-v3/handoff/accepted.ixe b/Tests/Fixtures/ixon-v4/handoff/accepted.ixe similarity index 81% rename from Tests/Fixtures/ixon-v3/handoff/accepted.ixe rename to Tests/Fixtures/ixon-v4/handoff/accepted.ixe index 07c83f03c..0914c4e9a 100644 Binary files a/Tests/Fixtures/ixon-v3/handoff/accepted.ixe and b/Tests/Fixtures/ixon-v4/handoff/accepted.ixe differ diff --git a/Tests/Fixtures/ixon-v4/handoff/manifest.json b/Tests/Fixtures/ixon-v4/handoff/manifest.json new file mode 100644 index 000000000..da7a02306 --- /dev/null +++ b/Tests/Fixtures/ixon-v4/handoff/manifest.json @@ -0,0 +1,16 @@ +{"validator": "ixon-v4/resource-v1", + "subject": "f0e971f93ae7a7aa0fbf87df16a2445afdbb8d89dc0c20934cb9ae7901958269", + "schema": "ixon-v4-handoff-1", + "profile": "b961b849d232f7250205507943cbc8351fc5c0a7beec0380025e3f50cf300a37", + "objectFormat": "ixon-v4", + "ixvmResourceProof": false, + "files": + {"rejected-local-escape.ixe": + "3018ef01f3ef7e176e170ba1dc259f6b799abcf71e8a4610c6073d12551caef5", + "profile.bin": + "b961b849d232f7250205507943cbc8351fc5c0a7beec0380025e3f50cf300a37", + "accepted.ixe": + "d32aec965df8d16ccc6818ed56e6e0a92ee823d1ab59eaaefe32d5109392fd46", + "accepted.claim": + "5b8c3e8ff2b39edc96a83f878d2298d95eec6b5cb6d276fad41e4be284d3c1d4"}, + "claim": "5b8c3e8ff2b39edc96a83f878d2298d95eec6b5cb6d276fad41e4be284d3c1d4"} diff --git a/Tests/Fixtures/ixon-v4/handoff/profile.bin b/Tests/Fixtures/ixon-v4/handoff/profile.bin new file mode 100644 index 000000000..1056a2683 Binary files /dev/null and b/Tests/Fixtures/ixon-v4/handoff/profile.bin differ diff --git a/Tests/Fixtures/ixon-v3/handoff/rejected-local-escape.ixe b/Tests/Fixtures/ixon-v4/handoff/rejected-local-escape.ixe similarity index 81% rename from Tests/Fixtures/ixon-v3/handoff/rejected-local-escape.ixe rename to Tests/Fixtures/ixon-v4/handoff/rejected-local-escape.ixe index e073192ef..dd04a91f6 100644 Binary files a/Tests/Fixtures/ixon-v3/handoff/rejected-local-escape.ixe and b/Tests/Fixtures/ixon-v4/handoff/rejected-local-escape.ixe differ diff --git a/Tests/Fixtures/ixon-v4/primitives.tsv b/Tests/Fixtures/ixon-v4/primitives.tsv new file mode 100644 index 000000000..88cb2bd9a --- /dev/null +++ b/Tests/Fixtures/ixon-v4/primitives.tsv @@ -0,0 +1,94 @@ +# Ixon v4 canonical primitive addresses +Nat 35e1cc809f6f076521a43f85068d5592220407c0532b6a08952f40d8523d04bc +Nat.zero eeb2e6268ff6d0e6b2e9764d9940b81bb64b9f8f4b1358d294ff9817e6941a46 +Nat.succ 42d6ed31536f0958176f1dc973383808ac8583223746ebca78dbe389b65321a6 +Nat.add 3e8aadcc611c4d8677cadf00c78506561d33738ee3d571f7a4196e260580c9b8 +Nat.pred 3244687301d779ec757274761d903def3eb3135177327b709bcbd854ef496f79 +Nat.sub 03b3a041285b0fe202d90b227d405c4cec252df18ba7616acd6dae2792e672bb +Nat.mul 373b7d74f6b40da11b7ed79603a45ec7011a8831b720b57d2efe92e82a3d57f0 +Nat.pow 5baaf05c969d2cf377312111be51bb64c600c13fa164ee722e92243b0f771bab +Nat.gcd aba94bfb41351d4db36172c379a512f04219ef21dc5454d71590967d4e8f913f +Nat.mod 11abbf986481c53a21c8cb21ee2581ae6238aedbec15f972959d086bef1a1985 +Nat.div 824d1c53d8c1c3cf0a27f24639ec2be1ecc13d4a01c993171595edccf6949737 +Nat.bitwise 6eff55f72c856bd08aa02896fb78d93c28e11aae2be05c318b9d1f9fab8d7a53 +Nat.beq d3d8ff924af9dc4b5cd869760615b3e7ee80916bb617259d45890c69f4128337 +Nat.ble 9e445b9d5f8252772347872e909b5db4e7eca7086cedf4fec6de840f6b7b5f92 +Nat.land d98bed1e14cda0eea470a5a49ff7926c80eb4bc7bfbdd0c3e14d4baa5c2dd0d7 +Nat.lor 88ff34dd42e57766beefc229d8b62dabba9cef6aadcc85c88ad67323d02bbf21 +Nat.xor 1b0acdd4080abe5bc4acb5f06527cb62ad92792eb429c2b3bcb6f471d7945085 +Nat.shiftLeft 05bb657e8b9d5dc224e7ef3d53e54153ce3ac26da8d1f1b1d61069a3726566cd +Nat.shiftRight 25019ff485fcf5709597cd1e07fcc3ce796776ef3f715a6d187eb5831c63b4be +Bool e6eba3c8b4d19f6a1076b39fa89aec61dccbb960f83d9a62e6acf35a69c9a0a4 +Bool.true a29a636176cf1135d077eb074798f9007c78e7801383e9cff363bae5edf05762 +Bool.false dda12bcb330727f6dfb816bc9752aabd0520e6515b79fc8a5a9e713866f4c63e +String 221625a00ee2d6b96297e34d7e05bf7e4fd38d8d99d3e1d64a7cd2e06ca0752d +String.mk 45dcb3c5e5ada3bc0ca52d62a66f7f9dda3507df71061a5c200adea0cf241014 +Char 065fc8b41393f525c1e541b9d4bc97c20c13bf23a7209a2093b6f4527330114a +Char.mk 60cc6cfe4577b99a30113d09e9921f2253fac15fe3d5ad976b9dc3626edc6822 +Char.ofNat cff875914f3f8b4f0014d1eaa223c6b9da7201239bc5976e140b69d99cd1f357 +String.ofList 45dcb3c5e5ada3bc0ca52d62a66f7f9dda3507df71061a5c200adea0cf241014 +List 4fb6b41c30532e6ab4acb4eefe01da1314ee7f2129af8989fd63f7ec277aaf01 +List.nil 3994bc51e3686f30a1d483d69d0a835a7b484d892393c084f87a5849de54f302 +List.cons b3a7d80249fd823100ee03626232d1412a0e8335275d5df53b92943887b650f7 +Eq c37d6290e00fb865fb5db7bce18fd69e6d1674ad573724b85466ea9f7578a207 +Eq.refl d494dc601386ba8e8f0b711fe62a2d60ab60c6488c8cf6ce97796ebc3ad5fefb +Quot 45040b3126855169dad919a970a9c72cee5875658aedb3bd1f89fcdf8c88edfa +Quot.mk 811600dfa59f3612cb03c0f0475af152399defff9226c6e19fd648041a6899a9 +Quot.lift 86b365e75bb4230f04c6e4f3a7ca6988adf574616d79a3d7477ad65cac102110 +Quot.ind 1745491c0d651de0bea589d5fffbc9bc4d7fbe897c1d805b1f7f59ca9696a6ef +Lean.reduceBool bacc4c814a4572ddfd969a1857adfe18239eb6bd8b1627ee79744a6a9b23b030 +Lean.reduceNat b6327d9a1bbb461a447f0c971e622dd9a35132bd7de75bf69e20794d7a0e8595 +eagerReduce 173299c76efa82e689210a09e49ad09c14ee1108f2da8d355ef9333b1583a1d5 +System.Platform.numBits 57a31c1e34cf3993b20939dd29ba27263f24fbbeede2f6a6d089b8051fe32c3c +System.Platform.getNumBits 236e46bde1f59309c2cc685a7379bc5294a9817e597915ddcc4b3d933284cd70 +Subtype.val d1bfec8df908c887e4f489adc2eec77a53e8ff28b5bd9a4c21a56da6381eed8f +String.toByteArray de013024c598e5f0c3dcd067f506e1d2e32749573522acb539b61400627cf897 +ByteArray.empty 4da661917a58152f5ca974d2256d98efa9d722c4f16382e9cdf016df4c574368 +Nat.decLe 7bb659876671e03d0731c456e894ce9e6f7de8250ab4ae70113dc08e24532127 +Nat.decEq f1de7103802ebc5309041bdaadea4a65652d54af37e66aaaf41787b1d8919557 +Nat.decLt af586b07546e1fca9ab0780d1c236af8d360c4c6bb32bb0cd03ec9ca63d3da96 +Decidable.rec 3ea7e18fcbb7c498b2a45237bda659c0edc97b3d54a4ad0d11bc2ebec80cfa17 +Decidable.isTrue 363d071182be414e1a58599b83f5e19f9b873723054f4287ba69705aafef27da +Decidable.isFalse 8cc0e1360c1b29108dab3d6172e7fce8a9aa9640daa4bbe99ba1305d9623624b +Nat.le_of_ble_eq_true 5c99dc61889e4a1e06ff6f24d184dc6553028cc62b89fa61bc23115b6a762068 +Nat.not_le_of_not_ble_eq_true 93c0ea70c5c33f7bcecd405dfdee5c5471f74aee61f8bb610b2552d7ffe28183 +Nat.eq_of_beq_eq_true c44c528578dab3903088d064cc9b679d2c0eb3fe73da3c1ce1cc9d1b8f2cadd3 +Nat.ne_of_beq_eq_false 6a7739ca74fd0033ddcb1c4d98cde41920f173d3b8a6fade75a49b7496ec8cad +Fin 1e1a2bbb1920ed4a1281a3deca646ad313ca9c7bf7eabdc3655987797ccc0c55 +Bool.noConfusion 55b3bf142fb5a8078ad3b7515f90ab239c32ae0443dfe383b67dae6f4ba17fc5 +Int c60c95e3cdbf4ed010d999b3277f4e1fd3695e8c30260876102905d7b36241a2 +Int.ofNat 0a99f49cc73ab9f42783092e7120613225670bab89b9d63533d1adefc876182f +Int.negSucc f7130d5864e1ba77b0f6a7338f92159c35bd5147e0febcf1ebed456e513538cc +Int.add b666925b10473fbe1a7630ec496fe07d799c5248667db1e2302fca5fe4c50cb6 +Int.sub 7c60043d6016e2f0ef5d764e1ab7923968d43d5c388186ddf6c83c28f024017a +Int.mul 9dff949e4d0282393213042a36a69af4b71a58709096eaa3de5130bae0af84f3 +Int.neg 19c87649f9a17809f248beff7bc37f569f548e24a98d8a7cddd5b82eb808e5a6 +Int.emod 13c97e84fb8ac3ee8120e923d61fca6f7e6bb9241ec3aa5d359ba5dce542aa11 +Int.ediv 53e404f5dd3c53693bc3b5bfae582b0496ec3c05af0cee0a46c38ab662c57fdf +Int.bmod d0380dc9b63afeeb3235a77adeb355a8b52b0730971595093741ec2c6d57cd49 +Int.bdiv 209aca62cc1f9dd2c0a928cd84d72bb41570aa97c1fd833e5fffc567c1c6401f +Int.natAbs 01e7c724508897e01e5d0b8f72e2cfa2607cea5ff0d352d008d0e7512aab2f46 +Int.pow a28958d747e87b5a60e4fa07ef7ed8d949f69adcbc44afe2958482d3ee9b3365 +Int.decEq 35a9ed7202e3c43857cdc4063eac123fe7b77f0631154ac540dba2c997bdf224 +Int.decLe 1710034a517f249f5c8265e8e2783be60619f0c8e85f4eab625e85983abd722e +Int.decLt 5318877ae61e1da37980d80c11e3e47a36d850c3e43e99716122f1e6eff01e9f +PUnit 2dfc16af01b82b3b91c2ff704409d76236a83f956c0c6e6659a64fe21d76695b +PProd 90ca5bcf995d68d7dfcb3c7cfe466986dc4beaa402b262ca395b3e53c36f6cad +PProd.mk ce30fc0f4135e679cf3b16d0d667bd9df4e7a69dbb8177a29e5c75b48c4cec10 +Nat.rec c8322e03d558f85a8edc7fe68524013880ad0bbcb7dc890136d247154b230992 +Nat.casesOn 937374ed09b8b62f36ef75f06f1ee46dd487c7a9f3e74db919bde48bb76b2cc6 +BitVec 90022ae4c5d52ad28acd80051dd41f27f51c9c4afbab1bb391773c19ef0dc1e9 +BitVec.toNat fade2dbfb1d7f77c30c247d52df128bf516eedce01f817d363ce88da13cfac2b +BitVec.ofNat 67160b97679306d2820445383a6d740e6fe9839c2545ea48680ff2a77b0be986 +BitVec.ult 2f9c9c369045036d9a35ff7b38285dca3b976426c81a8f366fce1161b090d60d +Decidable.decide 11157bc3898f06e3e6f2ca83411efd0d43b8846b57d2f6088e18f3447ddc3b28 +LT.lt 061c2658c76a68d90978859824993bbbe15dbf9b9968619325420e7c839b05c7 +OfNat.ofNat cb84bffa6d7092a309630214af29d9ec4e35cd5e0003eb9cdf75ee484e24925b +Unit 9232498667f765f437dedaac828e555f6cc67a20e6db28f614fdf3c262710feb +PUnit._sizeOf_1 523699b6e827b74a950d4718bdf5b13c193e3c7c371aaad4d635667be74b05fa +SizeOf.sizeOf ea81aee4a7d154faa8211a2594406dfdc7442020c0f29d2d0f79b4e62314da51 +String.back b052e814120ea6299aecf4e9bb2b656d67c1f9537e8f0e9f16479c98a04fde93 +String.Legacy.back 10af1decd5d2cd085adff8ae7fb44cfc5d22a89bbc40b81b809d3d556fda3e8f +String.utf8ByteSize 4c086826cc679df3b6aa57a29f3d093a8a92d0de4edecef46a908d8398733dc0 +String.append 0eae69f3f8b198d1ffac67b9e88d39526b1b039ff519cd87eec106f63974860c +String.decEq da7bb331e098f9bf5cdabcb9609a7e953dffc609ad9d90871a14c016c52a3011 diff --git a/Tests/Fixtures/ixon-v3/resource.tsv b/Tests/Fixtures/ixon-v4/resource.tsv similarity index 98% rename from Tests/Fixtures/ixon-v3/resource.tsv rename to Tests/Fixtures/ixon-v4/resource.tsv index f38465e09..49eea1d3d 100755 --- a/Tests/Fixtures/ixon-v3/resource.tsv +++ b/Tests/Fixtures/ixon-v4/resource.tsv @@ -1,7 +1,6 @@ -# name expected type (ixon-v3 hex) body (ixon-v3 hex) +# name expected type (ixon-v4 hex) body (ixon-v4 hex) ordinary identity ok 911720002000 8107200010 linear identity ok 911520002000 8105200010 -linear unique transfer ok 910120002000 8101200010 unused erased ok 911420002000 8104200060 erased argument has zero demand ok 911420002000 8104200071200410 unused affine ok 911620002000 8106200060 @@ -12,6 +11,10 @@ many permits repeated demand ok 911720002000 8107200071200510 linear ordinary let ok 911520002000 81052000a00520001010 erased let initializer ok 911520002000 81052000a00420001011 duplicate affine through let usage 911620002000 81062000a00620001011 +fresh inner linear binder under many demand ok 911720002000 81072000712005a00520001010 +type formation has zero runtime demand ok 91140000 81040010 +type use cannot discharge linear runtime obligation usage 91150000 81050010 +linear unique transfer ok 910120002000 8101200010 shared cannot become unique ownership 910520002000 8105200010 unique cannot transfer twice despite many moved 910320002000 81032000a001200010a00120001110 permanent sharing relinquishes unique ownership 910320002000 81032000a00620001011 @@ -30,38 +33,35 @@ borrow cannot manufacture unique view borrow 911320002000 81032000a20b20001060 moved owner cannot be borrowed moved 910320002000 81032000a001200010a20f20001111 projected loan suspends whole owner loan 910120072007 81012007a20f200040071011 projected loan ends before owner transfer ok 910120072007 81012007a0062000a20f20004007107120011011 -unregistered projection has no optimistic rule unsupported 911320002000 81032000400010 +discarding borrow before narrowing fresh result ok 913320002000 81032000a20f20001071200110 +erased owner cannot be restored through a borrow unsupported 911020002000 81002000a20f20001071200110 +erased view cannot be restored through a reborrow unsupported 911320002000 81032000a20c200010a20f20001071200110 shared closure cannot hide affine capture capture 921620001720002000 8206200007200011 unique closure retains finite capture ok 920520001720002000 8205200007200011 local closure may retain local input ok 923f20003720002000 820f200007200011 closure cannot hide local escape unrestricted 921f20003720002000 820f200007200011 aggregate cannot hide local escape unrestricted 911d20002007 810d200071200810 aggregate retains caller locality ok 913d20002007 810d200071200810 +shared aggregate cannot expose reusable unique closure capture 921520071720002000 81052007410710 +unique aggregate transfers unique closure field ok 920120071720002000 81012007410710 +shared field retains its reusable function contract ok 921520071720002000 81052007420710 +projected borrow cannot launder unique closure capture 911720072000 81072007a20f91172000200041071060 +capturing owner transfers it even when closure only borrows ok 920120001720002000 82012000072000a20f20001171200110 +reborrowing closure captures the view without moving its root ok 910120002000 81012000a0062000a20f200010a00d91172000200081072000a20f2000117120011071106011 linear use in both alternatives ok 911520002000 81052000732006601010 linear missing in one alternative usage 911520002000 81052000732006601060 affine use in one alternative ok 911620002000 81062000732006601060 unique move in each alternative ok 910120002000 8101200073200a601010 alternative move prevents later use moved 910320002000 81032000a002200073200a60106011 partial selection is not an ordinary function unsupported 911720002000 8107200071200610 +selection cannot bypass its rule through a callback unsupported 941720001520001620001620002000 810720002006 +branch analysis follows a shared application head ok 911520002000 8105200073b1601010 +unregistered projection has no optimistic rule unsupported 911320002000 81032000400010 sharing checked in live binder context ok 911520002000 81052000b0 sharing cannot cache away erased restriction usage 911420002000 81042000b0 lambda and interface input must agree binder 911520002000 8107200010 -fresh inner linear binder under many demand ok 911720002000 81072000712005a00520001010 -discarding borrow before narrowing fresh result ok 913320002000 81032000a20f20001071200110 -type formation has zero runtime demand ok 91140000 81040010 -type use cannot discharge linear runtime obligation usage 91150000 81050010 -selection cannot bypass its rule through a callback unsupported 941720001520001620001620002000 810720002006 -shared aggregate cannot expose reusable unique closure capture 921520071720002000 81052007410710 -unique aggregate transfers unique closure field ok 920120071720002000 81012007410710 -shared field retains its reusable function contract ok 921520071720002000 81052007420710 -projected borrow cannot launder unique closure capture 911720072000 81072007a20f91172000200041071060 -capturing owner transfers it even when closure only borrows ok 920120001720002000 82012000072000a20f20001171200110 -branch analysis follows a shared application head ok 911520002000 8105200073b1601010 -erased owner cannot be restored through a borrow unsupported 911020002000 81002000a20f20001071200110 -erased view cannot be restored through a reborrow unsupported 911320002000 81032000a20c200010a20f20001071200110 erased higher order argument still checks its contracts type 91149115200020002000 81049115200020007181049117200020006010 erased higher order argument with matching interface ok 91149117200020002000 81049117200020007181049117200020006010 -reborrowing closure captures the view without moving its root ok 910120002000 81012000a0062000a20f200010a00d91172000200081072000a20f2000117120011071106011 higher order local callback and argument ok 923f911d200020001d20002000 820f911d200020000d2000711110 recursive contract retains resource across alternatives ok 921720003d20002000 820720000d2000732009601072200b1110 higher order contract mismatch type 9217911d20002000179117200020002000 8207911d20002000072000a0059117200020001160 diff --git a/Tests/Fixtures/ixon-v3/text.tsv b/Tests/Fixtures/ixon-v4/text.tsv similarity index 100% rename from Tests/Fixtures/ixon-v3/text.tsv rename to Tests/Fixtures/ixon-v4/text.tsv diff --git a/Tests/Gen/Ix.lean b/Tests/Gen/Ix.lean index a08220884..7fe60a3e2 100644 --- a/Tests/Gen/Ix.lean +++ b/Tests/Gen/Ix.lean @@ -641,7 +641,9 @@ def genDecompileError : Gen Ix.DecompileM.DecompileError := do (1, pure (.blobNotFound addr)), (1, do let expected ← genIxString; pure (.badBlobFormat addr expected)), (1, pure (.badConstantFormat s)), - (1, pure (.serializeError se)) + (1, pure (.serializeError se)), + (1, do let entry ← Gen.choose Nat 0 100; let q ← Gen.choose Nat 0 100 + pure (.invalidMetaShareIndex idx.toUInt64 entry.toUInt64 len q s)) ] (pure default) instance : Shrinkable Ix.DecompileM.DecompileError where @@ -666,7 +668,8 @@ def genCompileError : Gen Ix.CompileM.CompileError := do (1, pure (.unsupportedExpr s)), (1, do let s2 ← genIxString; pure (.unknownUnivParam s s2)), (1, pure (.serializeError se)), - (1, pure (.resourceLimit s)) + (1, pure (.resourceLimit s)), + (1, pure (.sharingConstruction s)) ] (pure default) instance : Shrinkable Ix.CompileM.CompileError where diff --git a/Tests/Ix/Catalog.lean b/Tests/Ix/Catalog.lean index 575f0a857..e1d1764c0 100644 --- a/Tests/Ix/Catalog.lean +++ b/Tests/Ix/Catalog.lean @@ -233,7 +233,7 @@ def unitTests : TestSeq := ++ test "bad magic rejected" (deFails (setByte 0 0xFF) "magic") ++ test "unknown flags rejected" (deFails (setByte 12 0xFF) "flags") ++ test "legacy manifest rejected" (deFails (setByte 8 1) "version") - ++ test "legacy object format rejected" (deFails (setByte 16 2) "format") + ++ test "version 3 object format rejected" (deFails (setByte 16 3) "format") ++ test "resource validator cannot label catalog" (deFails (setByte 17 2) "validator") ++ test "members_root drift rejected" (deFails (setByte (8 + 4 + 4 + 2) 0xFF) "members_root") diff --git a/Tests/Ix/Claim.lean b/Tests/Ix/Claim.lean index 8ac1cf6db..727c5da49 100644 --- a/Tests/Ix/Claim.lean +++ b/Tests/Ix/Claim.lean @@ -68,8 +68,9 @@ def claimUnits : TestSeq := /-! ## Byte-level encoding tests - All claim variants are at Tag4 sizes 3..=7 (single-byte tags - `0xE3`..`0xE7`). Each claim has an opt byte (`0x00` for `none`, + Claim variants 3..=7 are single-byte TagN (`f = 4`) headers + `0xE3`..`0xE7`, followed by the scope bytes (object format 4, then the + validator). Each claim has an opt byte (`0x00` for `none`, `0x01`+32-byte address for `some`). -/ @@ -86,6 +87,8 @@ def claimEncodingTests : TestSeq := (.defn (some .defn) (some .safe) (some 3) (some addr2) (some addr3))) -- Two scope bytes follow each claim tag. Eval = 68 bytes; with asm = 100 test "Eval tag byte is 0xE3" (evalBytes.data[0]! == 0xE3) + ++ test "Eval scope is object format 4, erased-lean-v1" + (evalBytes.data[1]! == 4 && evalBytes.data[2]! == 1) ++ test "Eval no-asm size is 68" (evalBytes.size == 68) ++ test "Eval with-asm size is 100" (evalWithAsm.size == 100) -- Check: tag + scope + 32 + option = 36 bytes; with asm = 68 @@ -107,8 +110,8 @@ def claimEncodingTests : TestSeq := /-! ## Catalog claim: wire pin + Rust digest parity - The catalog claim is the first multi-byte claim tag (`0xE8 0x08` — - claim variants 0–7 are full). Its exact wire form is a + The catalog claim is the first multi-byte claim tag (`0xE8 0x00`: + TagN rung 2, since claim variants 0–7 fill rung 1). Its exact wire form is a cross-serializer commitment: `catalog_claim_wire_bytes_pinned` in `crates/ixon/src/proof.rs` asserts the SAME digest hex over the same fixture, so the two serializers cannot drift on the large-tag path @@ -121,7 +124,7 @@ private def catAsm : Address := Address.blake3 "assumptions".toUTF8 /-- Must equal the Rust pin in `proof.rs::catalog_claim_wire_bytes_pinned`. -/ private def catalogDigestPin : String := - "1ae7fec8efde892b6b540888df70d53977a264bbc84be300d4335ce04c916072" + "8c4fa4fa2e88fc73c72fbb624696485ec252c6685247541b40a59b221f83dbf4" def catalogClaimTests : TestSeq := let someBytes := Claim.ser (.catalog catMembers catContent (some catAsm)) @@ -132,8 +135,10 @@ def catalogClaimTests : TestSeq := let proofRoundtrips : Bool := match Ixon.Proof.de proofBytes with | .ok p => p.claim == proof.claim && p.proof == proof.proof | .error _ => false - test "Catalog tag is 2 bytes 0xE8 0x08" - (someBytes.data[0]! == 0xE8 && someBytes.data[1]! == 0x08) + test "Catalog tag is 2 bytes 0xE8 0x00 (TagN 4 0xE 8)" + (someBytes.data[0]! == 0xE8 && someBytes.data[1]! == 0x00) + ++ test "Catalog scope is object format 4, erased-lean-v1" + (someBytes.data[2]! == 4 && someBytes.data[3]! == 1) ++ test "Catalog no-asm size is 69" (noneBytes.size == 4 + 64 + 1) ++ test "Catalog with-asm size is 101" (someBytes.size == 4 + 64 + 33) ++ test "Catalog digest parity with Rust pin" diff --git a/Tests/Ix/ClaimsV3.lean b/Tests/Ix/ClaimsV4.lean similarity index 63% rename from Tests/Ix/ClaimsV3.lean rename to Tests/Ix/ClaimsV4.lean index d98f8d2ae..910e6cf21 100644 --- a/Tests/Ix/ClaimsV3.lean +++ b/Tests/Ix/ClaimsV4.lean @@ -6,7 +6,7 @@ public import Tests.Ix.Claim public section -namespace Tests.ClaimsV3 +namespace Tests.ClaimsV4 def fixtures : Array (String × Ix.Claim) := let a := Address.blake3 "a".toUTF8 @@ -18,29 +18,40 @@ def fixtures : Array (String × Ix.Claim) := ("resource", .resource a b) ] def fixtureText : String := Id.run do - let mut text := "# Ixon v3 claims: name, BLAKE3, canonical bytes\n" + let mut text := s!"# Ixon v{Ixon.Env.VERSION} claims: name, BLAKE3, canonical bytes\n" for (name, claim) in fixtures do text := text ++ s!"{name}\t{Ix.Claim.commit claim}\t{hexOfBytes (Ix.Claim.ser claim)}\n" return text def run : IO Unit := do - let expected ← IO.FS.readFile "Tests/Fixtures/ixon-v3/claims.tsv" - unless expected == fixtureText do throw <| IO.userError "v3 claim fixture bytes differ" + let expected ← IO.FS.readFile "Tests/Fixtures/ixon-v4/claims.tsv" + unless expected == fixtureText do + throw <| IO.userError "claim fixture differs from its producer; regenerate it with \ + `lake exe ixon-v4-tests --export-fixtures`" for (_, claim) in fixtures do let bytes := Ix.Claim.ser claim - unless (Ix.Claim.de bytes).toOption == some claim do throw <| IO.userError "v3 claim roundtrip" + unless (Ix.Claim.de bytes).toOption == some claim do throw <| IO.userError "claim roundtrip" for n in [:bytes.size] do unless (Ix.Claim.de (bytes.extract 0 n)).toOption.isNone do - throw <| IO.userError "truncated v3 claim accepted" - unless (Ix.Claim.de (bytes.push 0)).toOption.isNone do throw <| IO.userError "trailing v3 claim accepted" + throw <| IO.userError "truncated claim accepted" + unless (Ix.Claim.de (bytes.push 0)).toOption.isNone do throw <| IO.userError "trailing claim accepted" let header := if Ix.Claim.variantOf claim >= 8 then 2 else 1 - unless (Ix.Claim.de (bytes.set! header 2)).toOption.isNone do throw <| IO.userError "legacy claim version accepted" + match Ix.Claim.de (bytes.set! header 3) with + | .ok _ => throw <| IO.userError "version 3 object format accepted" + | .error e => + unless e.startsWith "claim: unsupported object format 3, expected 4" do + throw <| IO.userError s!"version 3 object format: unexpected error {e}" unless (Ix.Claim.de (bytes.set! (header + 1) 255)).toOption.isNone do throw <| IO.userError "wrong validator accepted" let proof : Ixon.Proof := { claim, proof := ⟨#[1, 2, 3]⟩ } let proofBytes := Ixon.Proof.ser proof let decoded ← IO.ofExcept (Ixon.Proof.de proofBytes) - unless decoded.claim == claim && decoded.proof == proof.proof do throw <| IO.userError "v3 proof roundtrip" + unless decoded.claim == claim && decoded.proof == proof.proof do throw <| IO.userError "proof roundtrip" unless (Ixon.Proof.de (proofBytes.push 0)).toOption.isNone do throw <| IO.userError "trailing proof bytes accepted" + -- Every proof variant is below 8 (a one-byte header), so the proof's + -- object-format byte is byte 1. + unless proofBytes[1]! == Ixon.Env.OBJECT_FORMAT do throw <| IO.userError "proof scope offset" + unless (Ixon.Proof.de (proofBytes.set! 1 3)).toOption.isNone do + throw <| IO.userError "proof with version 3 object format accepted" let (base, unit) := Tests.ResourceAddressed.unitEnv let (env, _) := Tests.ResourceAddressed.store base (Tests.ResourceAddressed.identity unit) let profile : Ix.Resource.Profile := {} @@ -52,10 +63,10 @@ def run : IO Unit := do (Ix.Resource.checkClaim base profile claim) false Tests.ResourceAddressed.check "resource claim binds limits" (Ix.Resource.checkClaim env { profile with limits := { steps := 100001 } } claim) false - let result ← LSpec.lspecIO (.ofList [("v3 claims", Tests.Claim.suite)]) [] + let result ← LSpec.lspecIO (.ofList [("claims", Tests.Claim.suite)]) [] unless result == 0 do throw <| IO.userError "existing claim tests failed" - IO.println "V3 claims: fixtures, strict envelopes, proof wrappers, subjects, and profiles passed" + IO.println s!"Ixon v{Ixon.Env.VERSION} claims: fixtures, strict envelopes, proof wrappers, subjects, and profiles passed" -end Tests.ClaimsV3 +end Tests.ClaimsV4 end diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean index aca0a2a9b..a997cd2d0 100644 --- a/Tests/Ix/Compile.lean +++ b/Tests/Ix/Compile.lean @@ -13,7 +13,6 @@ public import Ix.CompileM public import Ix.CompileDriver public import Ix.CondenseM public import Ix.GraphM -public import Ix.Sharing public import Lean public import LSpec public import Tests.Ix.Fixtures diff --git a/Tests/Ix/Decompile.lean b/Tests/Ix/Decompile.lean index 2add8cc0a..6e964abf4 100644 --- a/Tests/Ix/Decompile.lean +++ b/Tests/Ix/Decompile.lean @@ -14,6 +14,7 @@ public import Ix.CompileM public import Ix.DecompileM public import Ix.DecompileDriver public import Ix.DecompileRoundtrip +public import Ix.ImportIxe public import Lean public import LSpec public import Tests.Ix.Fixtures @@ -195,15 +196,356 @@ private def extAppendTeeth : Bool := Id.run do | .invalidRefIndex .. | .invalidUnivIndex .. => true | _ => false +end ExtensionAppend + +/-! ## Metadata `share`: the extended index space (pure unit) + +`share i` inside `metaSharing[j]` denotes primary entry `i` (`i < p`) or +`metaSharing[i - p]` (`p ≤ i < p + j`); anything else is +`invalidMetaShareIndex`. No compiler emits such a share today, so these +hand-built fixtures are the only thing pinning the reader rule (Rust +mirror: `meta_share_*` tests in `crates/compile/src/decompile.rs`). + +Every fixture has one primary entry (`p = 1`), `prim0 = (#1 #2)`, and a +primary root `head #99` whose `callSite` metadata reads one collapsed +argument from `metaSharing` before the kept `#99`. -/ + +section MetaShare + +open Ix.DecompileM Ixon + +private def nHead : Ix.Name := Ix.Name.mkStr Ix.Name.mkAnon "MS.head" +private def nHead2 : Ix.Name := Ix.Name.mkStr Ix.Name.mkAnon "MS.head2" +private def nAx : Ix.Name := Ix.Name.mkStr Ix.Name.mkAnon "MS.ax" + +private def msEnv : DecompileEnv := Id.run do + let base : Ixon.Env := {} + let names := [nHead, nHead2, nAx].foldl (init := base.names) + Ixon.RawEnv.addNameComponents + return { ixonEnv := { base with names } } + +/-- Primary entry 0. -/ +private def prim0 : Ixon.Expr := .app (.var 1) (.var 2) +/-- `metaSharing[0]`, shared: `share 0` is primary entry 0. -/ +private def sharedM0 : Ixon.Expr := .app (.share 0) (.var 3) +/-- `metaSharing[1]`, shared: `share 1 = p + 0` is `metaSharing[0]`. -/ +private def sharedM1 : Ixon.Expr := .app (.share 1) (.share 0) +/-- The unshared originals of the two entries. -/ +private def plainM0 : Ixon.Expr := .app prim0 (.var 3) +private def plainM1 : Ixon.Expr := .app plainM0 prim0 + +/-- Expected decompilations: `prim0`, `plainM0`, `plainM1`. -/ +private def ixPrim0 : Ix.Expr := Ix.Expr.mkApp (Ix.Expr.mkBVar 1) (Ix.Expr.mkBVar 2) +private def ixM0 : Ix.Expr := Ix.Expr.mkApp ixPrim0 (Ix.Expr.mkBVar 3) +private def ixM1 : Ix.Expr := Ix.Expr.mkApp ixM0 ixPrim0 + +/-- The primary root: `head #99` (the callSite head is named by metadata). -/ +private def msRoot : Ixon.Expr := .app (.ref 0 #[]) (.var 99) + +/-- Arena: `0` leaf (the kept argument), `1` the call site, whose source + spine is `head #99`. -/ +private def msArena (k : UInt64) (origHead : Option (UInt64 × UInt64) := none) : + ExprMetaArena := ⟨#[ + .leaf, + .callSite nHead.getHash #[.collapsed k UInt64.MAX, .kept 0 0] #[0] origHead ]⟩ + +private def msCtx (metaSharing : Array Ixon.Expr) (arena : ExprMetaArena) + (root : Ixon.Expr := msRoot) : BlockCtx := + mkBlockCtx ⟨.axio ⟨false, 0, root⟩, #[prim0], #[], #[]⟩ #[] #[] arena + { metaSharing } + +private def msRun (ctx : BlockCtx) (root : Ixon.Expr := msRoot) (rootIdx : UInt64 := 1) : + Except DecompileError Ix.Expr := + (DecompileM.run msEnv ctx {} (decompileExpr root rootIdx)).map (·.1) + +/-- `head x #99`. -/ +private def spine (x : Ix.Expr) : Ix.Expr := + Ix.Expr.mkApp (Ix.Expr.mkApp (Ix.Expr.mkConst nHead #[]) x) (Ix.Expr.mkBVar 99) + +private def isMetaShareErr {α : Type} (idx entry p q : Nat) : Except DecompileError α → Bool + | .error (.invalidMetaShareIndex i j p' q' _) => + i.toNat == idx && j.toNat == entry && p' == p && q' == q + | _ => false + +private def okEq (r : Except DecompileError Ix.Expr) (expected : Ix.Expr) : Bool := + match r with + | .ok e => e == expected + | .error _ => false + +/-- `share i`, `i < p`: the primary entry. -/ +private def msPrimary : Bool := + okEq (msRun (msCtx #[sharedM0] (msArena 0))) (spine ixM0) + +/-- `p ≤ i < p + j`: an earlier metadata entry, and through it a primary + entry. -/ +private def msEarlierMeta : Bool := + okEq (msRun (msCtx #[sharedM0, sharedM1] (msArena 1))) (spine ixM1) + +/-- Round trip: the shared table decompiles exactly like the unshared + original. -/ +private def msRoundTrip : Bool := + let shared := msRun (msCtx #[sharedM0, sharedM1] (msArena 1)) + let plain := msRun (msCtx #[plainM0, plainM1] (msArena 1)) + match shared, plain with + | .ok s, .ok u => s == u && s == spine ixM1 + | _, _ => false + +/-- `origHead` reads its entry in that entry's metadata scope too: + source spine ` #99`. -/ +private def msOrigHead : Bool := + okEq (msRun (msCtx #[sharedM0, sharedM1] (msArena 0 (some (1, UInt64.MAX))))) + (Ix.Expr.mkApp (Ix.Expr.mkApp ixM1 ixM0) (Ix.Expr.mkBVar 99)) + +/-- Forward reference (`metaSharing[0]` → `metaSharing[1]`): rejected, both + lazily and by the table check. -/ +private def msForward : Bool := + let table := #[.app (.share 2) (.var 3), .var 4] + isMetaShareErr 2 0 1 2 (msRun (msCtx table (msArena 0))) + && isMetaShareErr 2 0 1 2 (validateMetaSharing 1 table) + +/-- Self reference (`share p` in `metaSharing[0]`): rejected, not a loop. -/ +private def msSelf : Bool := + let table := #[.app (.share 1) (.var 3)] + isMetaShareErr 1 0 1 1 (msRun (msCtx table (msArena 0))) + && isMetaShareErr 1 0 1 1 (validateMetaSharing 1 table) + +/-- `i ≥ p + q`: out of range. -/ +private def msOutOfRange : Bool := + let table := #[.var 0, .app (.share 5) (.var 3)] + let r := msRun (msCtx table (msArena 1)) + isMetaShareErr 5 1 1 2 r + && isMetaShareErr 5 1 1 2 (validateMetaSharing 1 table) + && (match r with + | .error e => (toString e).contains "out of range" + | .ok _ => false) + +/-- A primary `share i` with `i ≥ p` stays invalid although `metaSharing` + has entries: metadata never changes how primary bytes decode. -/ +private def msPrimaryUnchanged : Bool := + let root : Ixon.Expr := .app (.ref 0 #[]) (.share 1) + match msRun (msCtx #[sharedM0] (msArena 0) root) root with + | .error (.invalidShareIndex 1 1 _) => true + | _ => false + +/-- The expression cache is keyed by scope: `sub = (share 1) #7` is valid in + `metaSharing[1]` (decoded first, as the collapsed argument of the call + site in function position) and must still be rejected when the primary + root applies the call site to the same `sub` at the same arena index + (no call-site scan covers that occurrence). -/ +private def msCacheScope : Bool := + let sub : Ixon.Expr := .app (.share 1) (.var 7) + let root : Ixon.Expr := .app msRoot sub + let arena : ExprMetaArena := ⟨#[ + .leaf, + .callSite nHead.getHash #[.collapsed 1 UInt64.MAX, .kept 0 0] #[0] none, + .app 1 UInt64.MAX ]⟩ + match msRun (msCtx #[sharedM0, sub] arena root) root (rootIdx := 2) with + | .error (.invalidShareIndex 1 1 _) => true + | _ => false + +/-- A call site nested in a metadata expression: its canonical spine runs + through a metadata share into `metaSharing[0]` and an argument there is + a primary share. Source: `head (head2 (#1 #2) #9) #99`. -/ +private def msNestedCallSite : Bool := + let m0 : Ixon.Expr := .app (.ref 0 #[]) (.share 0) + let m1 : Ixon.Expr := .app (.share 1) (.var 9) + let arena : ExprMetaArena := ⟨#[ + .leaf, + .callSite nHead2.getHash #[.kept 0 UInt64.MAX, .kept 1 UInt64.MAX] + #[UInt64.MAX, UInt64.MAX] none, + .callSite nHead.getHash #[.collapsed 1 1, .kept 0 0] #[0] none ]⟩ + let inner := Ix.Expr.mkApp + (Ix.Expr.mkApp (Ix.Expr.mkConst nHead2 #[]) ixPrim0) (Ix.Expr.mkBVar 9) + okEq (msRun (msCtx #[m0, m1] arena) (rootIdx := 2)) (spine inner) + +/-- An eta call site in a metadata expression: the synthesized wrapper is + stripped across a metadata share (`metaSharing[1] = λ. share 1`, the + inner lambda being `metaSharing[0]`). Source: `head (head2 #1) #99` + (the kept `#3` is lowered by the two synthesized binders). -/ +private def msEtaCallSite : Bool := + let m0 : Ixon.Expr := .lam .many (.var 5) + (.app (.app (.ref 0 #[]) (.var 3)) (.var 0)) + let m1 : Ixon.Expr := .lam .many (.var 6) (.share 1) + let arena : ExprMetaArena := ⟨#[ + .leaf, + .etaCallSite 2 nHead2.getHash #[.kept 0 UInt64.MAX] + #[UInt64.MAX, UInt64.MAX] UInt64.MAX, + .callSite nHead.getHash #[.collapsed 1 1, .kept 0 0] #[0] none ]⟩ + let inner := Ix.Expr.mkApp (Ix.Expr.mkConst nHead2 #[]) (Ix.Expr.mkBVar 1) + okEq (msRun (msCtx #[m0, m1] arena) (rootIdx := 2)) (spine inner) + +/-- Whole-constant path (`decompileAxiom` → `withFreshBlock`): the table + check rejects a malformed entry that no call site reads, and a valid + shared table decompiles to the unshared original. -/ +private def msAxiom (metaSharing : Array Ixon.Expr) : + Except DecompileError Ix.ConstantInfo := + let ax : Ixon.Axiom := ⟨false, 0, msRoot⟩ + let cnst : Ixon.Constant := ⟨.axio ax, #[prim0], #[], #[]⟩ + let cm : ConstantMeta := + { info := .axio nAx.getHash #[] (msArena 1) 1, metaSharing } + (DecompileM.run msEnv default {} (decompileAxiom ax cnst cm)).map (·.1) + +private def msAxiomOk : Bool := + match msAxiom #[sharedM0, sharedM1] with + | .ok (.axiomInfo v) => v.cnst.type == spine ixM1 && v.cnst.name == nAx + | _ => false + +private def msAxiomUnreadEntryRejected : Bool := + -- Entry 2 is never read (the call site reads entry 1) but references + -- itself (`share 3 = p + 2`). The error names the constant. + let r := msAxiom #[sharedM0, sharedM1, .app (.share 3) (.var 0)] + isMetaShareErr 3 2 1 3 r && match r with + | .error (.invalidMetaShareIndex _ _ _ _ c) => c == nAx.pretty + | _ => false + +/-- Regression: metadata without shares behaves as before. -/ +private def msNoShares : Bool := + okEq (msRun (msCtx #[plainM0] (msArena 0))) (spine ixM0) + && (validateMetaSharing 0 #[plainM0, plainM1] matches .ok ()) + +/-- The table check visits each shared node once: the chain + `e(k+1) = app e(k) e(k)` of depth 64 (2^64 nodes as a tree) validates, and + the first violation inside it is still its leftmost leaf. -/ +private def msSharedChain : Bool := + let chain := (List.range 64).foldl (fun e _ => Ixon.Expr.app e e) + (Ixon.Expr.app (.share 0) (.var 0)) + (validateMetaSharing 1 #[chain, chain] matches .ok ()) && + isMetaShareErr 0 0 0 1 (validateMetaSharing 0 #[chain]) + +/-! ### Lean/Rust parity through the `.ixe` decompile FFI + +The same serialized env is decompiled by the Lean decompiler and by the +Rust one (`rs_decompile_env_consts`, i.e. `decompile_env` plus +materialization): both must accept a valid shared table with the same +result, and both must reject the malformed ones with the same +`invalidMetaShareIndex` fields. -/ + +/-- `MS.head : Sort 0` and `MS.ax : head #99`, the latter + carrying `metaSharing`. -/ +private def msParityEnv (metaSharing : Array Ixon.Expr) : Ixon.Env := Id.run do + let headC : Ixon.Constant := ⟨.axio ⟨false, 0, .sort 0⟩, #[], #[], #[.zero]⟩ + let headAddr := Address.blake3 (Ixon.serConstant headC) + let axC : Ixon.Constant := + ⟨.axio ⟨false, 0, msRoot⟩, #[prim0], #[headAddr], #[]⟩ + let axAddr := Address.blake3 (Ixon.serConstant axC) + let mut env : Ixon.Env := {} + env := env.storeConst headAddr headC + env := env.storeConst axAddr axC + env := { env with + names := [nHead, nAx].foldl (init := env.names) Ixon.RawEnv.addNameComponents } + env := env.registerName nHead + { addr := headAddr, constMeta := { info := .axio nHead.getHash #[] ⟨#[.leaf]⟩ 0 } } + env := env.registerName nAx + { addr := axAddr, + constMeta := { info := .axio nAx.getHash #[] (msArena 1) 1, metaSharing } } + return env + +/-- Lean side, from the serialized bytes: `MS.ax`'s decompiled type or the + decompile error. -/ +private def msParityLean (bytes : ByteArray) : + Except String (Except DecompileError Ix.Expr) := do + let env ← Ixon.deEnv bytes + let some named := env.named.get? nAx | throw "MS.ax not in the decoded env" + let some cnst := env.getConst? named.addr | throw "MS.ax constant missing" + let .axio ax := cnst.info | throw "MS.ax is not an axiom" + return (DecompileM.run { ixonEnv := env } default {} + (decompileAxiom ax cnst named.constMeta)).map fun (ci, _) => ci.getCnst.type + +/-- `MS.ax`'s type as Rust materializes it: `MS.head ((#1 #2 #3) (#1 #2)) #99`. -/ +private def msParityLeanExpr : Lean.Expr := + let b := Lean.mkBVar + let prim := Lean.mkApp (b 1) (b 2) + .app (.app (.const (Lean.Name.mkSimple "MS.head") []) + (.app (.app prim (b 3)) prim)) (b 99) + +/-- Run both decompilers on `msParityEnv metaSharing`. `expect` is `none` + for acceptance, or the `(idx, entry, p, q)` of the expected rejection. -/ +private def msParityCase (label : String) (metaSharing : Array Ixon.Expr) + (expect : Option (Nat × Nat × Nat × Nat)) : IO (Option String) := do + let bytes ← match Ixon.serEnv (msParityEnv metaSharing) with + | .ok b => pure b + | .error e => return some s!"{label}: serEnv failed: {e}" + let dir ← IO.FS.createTempDir + let path := (dir / "meta-share.ixe").toString + try + IO.FS.writeBinFile path bytes + let lean ← match msParityLean bytes with + | .ok r => pure r + | .error e => return some s!"{label}: Lean env: {e}" + let rust : Except String (Array (Lean.Name × Lean.ConstantInfo)) ← + tryCatch (Except.ok <$> Ix.ImportIxe.materializeIxe path) + fun e => pure (Except.error (toString e)) + match expect, lean, rust with + | none, .ok ty, .ok consts => + let rustTy := consts.findSome? fun (n, ci) => + if n == Lean.Name.mkSimple "MS.ax" then some ci.type else none + if ty != spine ixM1 then return some s!"{label}: Lean type differs" + if rustTy != some msParityLeanExpr then + return some s!"{label}: Rust type differs: {rustTy}" + return none + | some (i, j, p, q), .error le, .error re => + if !isMetaShareErr i j p q (Except.error le : Except DecompileError Unit) then + return some s!"{label}: Lean rejected with {le}" + let want := s!"InvalidMetaShareIndex \{ idx: {i}, entry: {j}, \ + primary_len: {p}, meta_len: {q}" + if !re.contains want then + return some s!"{label}: Rust rejected with {re}" + return none + | _, l, r => + let ls := match l with | .ok _ => "accepted" | .error e => toString e + let rs := match r with | .ok _ => "accepted" | .error e => e + return some s!"{label}: Lean {ls}; Rust {rs}" + finally + IO.FS.removeDirAll dir + +private def msParity : TestSeq := + .individualIO "metadata share: Lean/Rust decompile parity" none (do + let cases : List (String × Array Ixon.Expr × Option (Nat × Nat × Nat × Nat)) := [ + ("valid", #[sharedM0, sharedM1], none), + ("forward", #[sharedM0, .app (.share 3) (.var 3), .var 4], some (3, 1, 1, 3)), + ("unread self", #[sharedM0, sharedM1, .app (.share 3) (.var 0)], + some (3, 2, 1, 3)), + ("out of range", #[sharedM0, .app (.share 7) (.var 3)], some (7, 1, 1, 2)) ] + let mut failures : Array String := #[] + for (label, table, expect) in cases do + if let some msg ← msParityCase label table expect then + failures := failures.push msg + if failures.isEmpty then + return (true, 0, 0, none) + else + return (false, 0, 0, some ("; ".intercalate failures.toList))) .done + +end MetaShare + public def unitSuite : List TestSeq := [ test "extension append: virtual ref/univ indices resolve" extAppendResolves ++ test "extension append: absent metadata leaves indices OOB" - extAppendTeeth + extAppendTeeth, + test "metadata share: i < p is the primary entry" msPrimary + ++ test "metadata share: p ≤ i < p + j is an earlier metadata entry" + msEarlierMeta + ++ test "metadata share: round trip equals the unshared original" + msRoundTrip + ++ test "metadata share: origHead reads its entry's scope" msOrigHead + ++ test "metadata share: forward reference rejected" msForward + ++ test "metadata share: self reference rejected" msSelf + ++ test "metadata share: i ≥ p + q rejected" msOutOfRange + ++ test "metadata share: primary share ≥ p still rejected" + msPrimaryUnchanged + ++ test "metadata share: expression cache keyed by scope" msCacheScope + ++ test "metadata share: nested call site crosses scopes" + msNestedCallSite + ++ test "metadata share: eta wrapper stripped across a metadata share" + msEtaCallSite + ++ test "metadata share: whole constant decompiles" msAxiomOk + ++ test "metadata share: unread malformed entry rejected" + msAxiomUnreadEntryRejected + ++ test "metadata share: tables without shares unchanged" msNoShares + ++ test "metadata share: shared subterms are checked once" msSharedChain, + msParity ] -end ExtensionAppend - /-! ## Test Suite -/ public def decompileSuiteIO : List TestSeq := [ diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index f8244e2d8..75f81739b 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -437,91 +437,92 @@ private def nameOfString (str : String) : Lean.Name := 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 v3 contract decoding, canonicality checks, and scoped claim headers. -/ + include v4 TagN and contract decoding, canonicality checks, and scoped + claim headers. -/ private def kernelCheckEntries : List (String × Nat) := [ - ("HEq", 108_709_966), - ("HEq.rec", 113_236_098), - ("Eq.rec", 112_511_051), - ("Nat", 108_737_543), - ("Nat.add", 151_345_745), - ("Nat.add_comm", 306_709_751), - ("Nat.decEq", 361_930_901), - ("Nat.decLe", 806_129_598), - ("Nat.sub_le_of_le_add", 1_959_633_938), - ("Nat.shiftRight_succ", 1_452_962_791), - ("Trans.mk", 116_338_778), - ("Array.append_assoc", 9_208_079_911), - ("Vector.append", 9_416_215_911), - ("IxVMPrim.nat_add_lit", 194_438_257), - ("IxVMPrim.nat_sub_lit", 209_623_070), - ("IxVMPrim.nat_mul_lit", 185_471_640), - ("IxVMPrim.nat_mul_big", 184_142_350), - ("IxVMPrim.nat_div_lit", 1_417_621_519), - ("IxVMPrim.nat_mod_lit", 1_445_373_618), - ("IxVMPrim.nat_succ_lit", 124_283_405), - ("IxVMPrim.nat_pred_lit", 146_400_901), - ("IxVMPrim.nat_gcd_lit", 2_240_145_588), - ("IxVMPrim.nat_land_lit", 3_678_004_112), - ("IxVMPrim.nat_lor_lit", 3_679_971_737), - ("IxVMPrim.nat_xor_lit", 3_699_295_321), - ("IxVMPrim.nat_shl_lit", 215_855_503), - ("IxVMPrim.nat_shr_lit", 1_432_684_687), - ("IxVMPrim.nat_pow_big", 378_009_461), - ("IxVMPrim.nat_beq_lit", 182_506_749), - ("IxVMPrim.nat_ble_lit", 177_737_756), - ("IxVMPrim.nat_cases_big", 146_797_787), - ("IxVMPrim.nat_dec_le", 824_543_384), - ("IxVMPrim.nat_dec_lt", 835_285_662), - ("IxVMPrim.nat_dec_eq", 402_191_857), - ("IxVMPrim.str_size_lit", 2_567_549_446), - ("IxVMPrim.bv_to_nat_lit", 2_137_494_651), - ("IxVMInd.Even", 187_656_907), - ("IxVMInd.Odd", 187_663_677), - ("IxVMInd.Even.rec", 208_366_019), - ("IxVMInd.Odd.rec", 208_368_470), - ("IxVMInd.IdxTeleN.rec", 142_867_720), - ("IxVMInd.IdxTeleB.rec", 142_865_483), - ("IxVMInd.SoloA.rec", 137_030_499), - ("IxVMInd.SoloB.rec", 137_029_398), - ("IxVMInd.UnsafeSquash", 110_674_375), - ("IxVMInd.Tree", 110_489_966), - ("IxVMInd.Tree.rec", 122_415_231), - ("IxVMInd.DedupM", 113_961_433), - ("IxVMInd.DedupM.rec", 130_007_924), - ("IxVMInd.DepthM", 112_336_135), - ("IxVMInd.DepthM.rec", 125_201_176), - ("String.Internal.append", 2_537_274_919), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_766_156_517), - ("Lean.Syntax.rec", 2_600_755_728), - ("IxVMInd.AuxTie", 308_318_782), - ("IxVMInd.AuxTie.rec", 357_596_633), - ("IxVMInd.HiddenIdx", 109_727_236), - ("IxVMInd.HiddenIdx.rec", 113_322_147), - ("IxVMInd.thmMajorUse", 506_324_641), - ("IxVMInd.partialKRec", 130_741_376), - ("IxVMInd.deepRebase", 202_659_801), - ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 3_525_586_469), - ("Lean.Widget.TaggedText.rec", 2_569_638_885), - ("Lean.Doc.Part.rec", 2_615_547_875), - ("Lean.Doc.Block.rec", 2_867_098_516), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 111_875_801), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 115_852_858), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 114_883_212), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 114_883_212), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 114_883_212), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 112_174_702), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 125_551_297), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 125_549_212), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 114_883_212), - ("strOfListFoldSize", 2_855_990_318), - ("strOfListFoldSizeAscii", 2_856_655_185), - ("IxVMPrim.lazy_ble_offset", 216_177_244), - ("IxVMPrim.lazy_unit_cast", 545_160_715), - ("IxVMPrim.sizeof_unit", 141_471_367), - ("IxVMPerf.let_continuations", 149_630_173), - ("IxVMPerf.mul_row", 424_661_888), - ("IxVMPerf.context_tower", 513_602_982), - ("IxVMPerf.mul_wide", 247_733_335), + ("HEq", 108_698_183), + ("HEq.rec", 112_906_099), + ("Eq.rec", 112_305_029), + ("Nat", 108_730_176), + ("Nat.add", 150_020_629), + ("Nat.add_comm", 295_312_785), + ("Nat.decEq", 348_642_490), + ("Nat.decLe", 761_020_256), + ("Nat.sub_le_of_le_add", 1_808_361_693), + ("Nat.shiftRight_succ", 1_366_388_481), + ("Trans.mk", 116_194_291), + ("Array.append_assoc", 8_271_244_910), + ("Vector.append", 8_463_566_986), + ("IxVMPrim.nat_add_lit", 191_123_094), + ("IxVMPrim.nat_sub_lit", 206_401_042), + ("IxVMPrim.nat_mul_lit", 182_766_302), + ("IxVMPrim.nat_mul_big", 181_612_598), + ("IxVMPrim.nat_div_lit", 1_331_996_302), + ("IxVMPrim.nat_mod_lit", 1_357_681_631), + ("IxVMPrim.nat_succ_lit", 124_064_179), + ("IxVMPrim.nat_pred_lit", 145_426_875), + ("IxVMPrim.nat_gcd_lit", 2_082_584_316), + ("IxVMPrim.nat_land_lit", 3_398_695_890), + ("IxVMPrim.nat_lor_lit", 3_400_417_670), + ("IxVMPrim.nat_xor_lit", 3_419_508_852), + ("IxVMPrim.nat_shl_lit", 212_078_257), + ("IxVMPrim.nat_shr_lit", 1_345_954_472), + ("IxVMPrim.nat_pow_big", 372_254_505), + ("IxVMPrim.nat_beq_lit", 180_547_863), + ("IxVMPrim.nat_ble_lit", 175_462_141), + ("IxVMPrim.nat_cases_big", 145_027_143), + ("IxVMPrim.nat_dec_le", 778_244_764), + ("IxVMPrim.nat_dec_lt", 789_751_664), + ("IxVMPrim.nat_dec_eq", 387_384_729), + ("IxVMPrim.str_size_lit", 2_404_789_933), + ("IxVMPrim.bv_to_nat_lit", 1_994_913_874), + ("IxVMInd.Even", 185_074_012), + ("IxVMInd.Odd", 185_078_955), + ("IxVMInd.Even.rec", 202_844_500), + ("IxVMInd.Odd.rec", 202_840_837), + ("IxVMInd.IdxTeleN.rec", 140_808_215), + ("IxVMInd.IdxTeleB.rec", 140_805_989), + ("IxVMInd.SoloA.rec", 135_669_724), + ("IxVMInd.SoloB.rec", 135_670_824), + ("IxVMInd.UnsafeSquash", 110_649_171), + ("IxVMInd.Tree", 110_463_448), + ("IxVMInd.Tree.rec", 121_246_273), + ("IxVMInd.DedupM", 113_909_843), + ("IxVMInd.DedupM.rec", 128_275_371), + ("IxVMInd.DepthM", 112_305_397), + ("IxVMInd.DepthM.rec", 123_506_204), + ("String.Internal.append", 2_375_681_040), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_519_021_255), + ("Lean.Syntax.rec", 2_434_931_223), + ("IxVMInd.AuxTie", 303_560_632), + ("IxVMInd.AuxTie.rec", 348_849_592), + ("IxVMInd.HiddenIdx", 109_711_717), + ("IxVMInd.HiddenIdx.rec", 113_178_609), + ("IxVMInd.thmMajorUse", 477_896_745), + ("IxVMInd.partialKRec", 129_810_071), + ("IxVMInd.deepRebase", 200_140_117), + ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 3_304_553_428), + ("Lean.Widget.TaggedText.rec", 2_403_042_928), + ("Lean.Doc.Part.rec", 2_445_512_655), + ("Lean.Doc.Block.rec", 2_668_808_782), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 111_823_090), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 115_300_949), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 114_539_434), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 114_539_434), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 114_539_434), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 112_136_679), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 124_061_154), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 124_060_118), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 114_539_434), + ("strOfListFoldSize", 2_673_997_843), + ("strOfListFoldSizeAscii", 2_674_602_649), + ("IxVMPrim.lazy_ble_offset", 213_003_842), + ("IxVMPrim.lazy_unit_cast", 523_654_301), + ("IxVMPrim.sizeof_unit", 141_010_145), + ("IxVMPerf.let_continuations", 148_337_223), + ("IxVMPerf.mul_row", 421_848_128), + ("IxVMPerf.context_tower", 504_617_117), + ("IxVMPerf.mul_wide", 245_116_045), ] /-- Variant of `kernelChecks`, pinned to the baseline diff --git a/Tests/Ix/IxVM/Exploits.lean b/Tests/Ix/IxVM/Exploits.lean index 75185fbc4..7e96ef235 100644 --- a/Tests/Ix/IxVM/Exploits.lean +++ b/Tests/Ix/IxVM/Exploits.lean @@ -483,35 +483,34 @@ def storeRawAt (env : Ixon.Env) (bytes : ByteArray) : Ixon.Env × Address := consts := env.consts.insert addr (Ixon.LazyConstant.ofSlice bytes 0 bytes.size) }, addr) -/-- Rewrite the one-byte canonical `Tag0` at `off` as an OVERLONG - encoding of the same value: head `0x88` announces nine payload bytes, - then eight zeros and one trailing byte. - - `Tag0`'s `small` field is 7 bits, so a payload width of 9 is - expressible and unguarded. The in-circuit `get_u64_le` consumes all - nine and keeps the first eight, discarding the ninth; the Lean host - folds it back in (its shift is taken mod 64, and it has no length - guard); Rust rejects `len > 8` outright. Same bytes, same address, - three readings. -/ -def overlongTag0At (bytes : ByteArray) (off : Nat) (trailing : UInt8) : +/-- 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 - ++ (⟨#[0x88, 0, 0, 0, 0, 0, 0, 0, 0, trailing]⟩ : ByteArray) + bytes.extract 0 off ++ (⟨encoding⟩ : ByteArray) ++ bytes.extract (off + 1) bytes.size /-- An axiom `_ : Prop`. Serializes as - `[0xD2][isUnsafe][lvls Tag0][typ…][sharing][refs][univs]`, so the - `lvls` `Tag0` is at byte 2 — the field the overlong rewrite targets, + `[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]⟩ /-! ### Encodings the format forbids and the circuit reads anyway -A `Tag4` byte is `[flag:4][large:1][size:3]`, so `flag * 16 + large * 8 + -small`. The three rewrites below are all legal `Tag4`s carrying values -the Rust reference rejects outright. Each yields a SECOND address for a -constant the circuit reads identically — never two readings of one +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 @@ -533,16 +532,16 @@ def zeroTelescopeAt (bytes : ByteArray) (off : Nat) (head : UInt8) : bytes.extract 0 off ++ (⟨#[head]⟩ : ByteArray) ++ bytes.extract off bytes.size -/-- Rewrite the leading `ConstantInfo` `Tag4` so its size needs two - bytes and its LOW byte is still the variant number. +/-- Rewrite the leading `ConstantInfo` TagN4 so its size is + `variant + 0x100`, whose LOW byte is still the variant number. - `0xD9` is flag `0xD`, large, one surplus payload byte, so the size is - the two little-endian bytes that follow. `variant + 0x100` therefore - has low byte `variant`. `get_constant_info` dispatches on `size[0]` - alone, so the circuit parses the variant; Rust matches the full `u64` - and errors on anything outside 0-7 (`serialize.rs:968-980`). -/ -def wideVariantTag4 (bytes : ByteArray) (variant : UInt8) : ByteArray := - (⟨#[0xD9, variant, 0x01]⟩ : ByteArray) ++ bytes.extract 1 bytes.size + 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`. -/ @@ -922,8 +921,10 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address) ] let axiomBytes := Ixon.ser propAxiom let (canonBytesEnv, canonBytesAddr) := storeRawAt base axiomBytes - let (overlongEnv, overlongAddr) := - storeRawAt base (overlongTag0At axiomBytes 2 0x2A) + 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) @@ -931,7 +932,7 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address) storeRawAt base (zeroTelescopeAt axiomBytes 3 0x90) -- `.axio` is variant 2, so the wide size is 0x0102 = 258. let (wideVariantEnv, wideVariantAddr) := - storeRawAt base (wideVariantTag4 axiomBytes 2) + 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) @@ -1374,20 +1375,25 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address) -- 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-tag0-axiom" + { name := "control-canonical-tagn-axiom" intent := "an axiom `_ : Prop` with canonical bytes, which must be \ accepted" env := canonBytesEnv, claim := .check canonBytesAddr none expectAccept := true }, - -- The same axiom with its `lvls` Tag0 written overlong. No host will - -- accept these bytes — Rust rejects the width outright and the Lean - -- host reads a different value — so the kernel accepting them means - -- its accepted language is strictly wider than the format, and one - -- address denotes different constants to different readers. - { name := "overlong-tag0-accepted" - intent := "a constant accepted from a non-canonical Tag0 encoding \ - that Rust rejects and the Lean host reads differently" - env := overlongEnv, claim := .check overlongAddr none }, + -- 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 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 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. @@ -1429,7 +1435,7 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address) env := nestedAllEnv claim := .reveal nestedAllAddr (.axio none none none) }, { name := "invalid-let-flags" - intent := "Reveal rejects a Let whose Tag4 size exceeds the two v3 flag bits" + 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" diff --git a/Tests/Ix/IxVM/TagN.lean b/Tests/Ix/IxVM/TagN.lean new file mode 100644 index 000000000..87592ae24 --- /dev/null +++ b/Tests/Ix/IxVM/TagN.lean @@ -0,0 +1,297 @@ +/- + 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_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_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/Ixon.lean b/Tests/Ix/Ixon.lean index 580b1a8cb..d03d5686d 100644 --- a/Tests/Ix/Ixon.lean +++ b/Tests/Ix/Ixon.lean @@ -1,6 +1,5 @@ module public import Ix.Ixon -public import Ix.Sharing public import Tests.Gen.Ixon public import Tests.FFI.Ixon @@ -65,7 +64,7 @@ def univUnits : TestSeq := .succ (.succ .zero), .succ (.succ (.succ .zero)), -- Test telescope compression Univ.addSucc 31 .zero, - Univ.addSucc 32 .zero, -- Cross the large-Tag2 boundary + Univ.addSucc 32 .zero, -- 32 successors: TagN f=2 rung 2 .max .zero (.var 0), .imax (.var 1) .zero, .max (.succ .zero) (.succ (.succ .zero)), @@ -142,7 +141,8 @@ def exprRejects (bytes : Array UInt8) : Bool := | .error _ => true | .ok _ => false -/-- Directed malformed vectors for the v2 maximal-telescope grammar. -/ +/-- Directed malformed vectors for the maximal-telescope grammar. Reserved + binder, forall and let codes are covered by `Tests.IxonV4.rejectedExprCases`. -/ def strictExprUnits : TestSeq := test "rejects empty app spine" (exprRejects #[0x70]) ++ test "rejects nested app base" @@ -150,10 +150,191 @@ def strictExprUnits : TestSeq := test "rejects nested lambda body" (exprRejects #[0x81, 0x03, 0x00, 0x81, 0x03, 0x00, 0x10]) ++ test "rejects nested forall codomain" - (exprRejects #[0x91, 0x07, 0x00, 0x91, 0x07, 0x00, 0x10]) ++ - test "rejects non-Boolean let flag" (exprRejects #[0xA2]) ++ - test "rejects invalid lambda mode" (exprRejects #[0x81, 0x04]) ++ - test "rejects invalid forall mode" (exprRejects #[0x91, 0x08]) + (exprRejects #[0x91, 0x07, 0x00, 0x91, 0x07, 0x00, 0x10]) + +/-! ## TagN integer code -/ + +/-- Rung boundary values for an `f`-bit flag, plus the `UInt64` extremes. -/ +def tagNBoundaries (f : Nat) : List Nat := + let ends := [tagNEnd1 f, tagNEnd2 f, tagNEnd3 f, tagNEnd4 f, tagNEnd5 f] + [0, 1, 2 ^ 64 - 1] ++ ends.flatMap fun e => [e - 1, e, e + 1] + +/-- Encode, check the width, decode exactly. -/ +def tagNRoundtrip (f : Nat) (flag : UInt8) (v : Nat) : Bool := + let t : TagN := ⟨flag, v.toUInt64⟩ + let bytes := runPut (putTagN f flag v.toUInt64) + bytes.size == tagNByteWidth f v && + match runGetExact (getTagN f) bytes with + | .ok t' => t' == t + | .error _ => false + +def tagNEncodes (f : Nat) (flag : UInt8) (v : Nat) (expected : Array UInt8) : Bool := + runPut (putTagN f flag v.toUInt64) == ByteArray.mk expected + +def tagNRejects (f : Nat) (bytes : Array UInt8) : Bool := + match runGetExact (getTagN f) (ByteArray.mk bytes) with + | .error _ => true + | .ok _ => false + +/-- Every byte string of length 1 or 2 that decodes exactly re-encodes to +itself (no value has two encodings within these lengths). -/ +def tagNShortCanonical (f : Nat) : Bool := Id.run do + for a in [0:256] do + let one := ByteArray.mk #[a.toUInt8] + if let .ok t := runGetExact (getTagN f) one then + if runPut (putTagN f t.flag t.value) != one then return false + for b in [0:256] do + let two := ByteArray.mk #[a.toUInt8, b.toUInt8] + if let .ok t := runGetExact (getTagN f) two then + if runPut (putTagN f t.flag t.value) != two then return false + return true + +def tagNUnits : TestSeq := + let perF (f : Nat) : TestSeq := + let flags : List UInt8 := [0, (2 ^ f - 1).toUInt8] + let cases := flags.flatMap fun flag => (tagNBoundaries f).map (flag, ·) + cases.foldl (init := .done) fun acc (flag, v) => + acc ++ test s!"TagN f={f} flag={flag} value={v}: width and roundtrip" + (tagNRoundtrip f flag v) + perF 0 ++ perF 2 ++ perF 4 ++ + test "TagN rung ends f=0" ([tagNEnd1 0, tagNEnd2 0, tagNEnd3 0, tagNEnd4 0, tagNEnd5 0] + == [128, 16512, 82048, 16859264, 4311826560]) ++ + test "TagN rung ends f=2" ([tagNEnd1 2, tagNEnd2 2, tagNEnd3 2, tagNEnd4 2, tagNEnd5 2] + == [32, 4128, 69664, 16846880, 4311814176]) ++ + test "TagN rung ends f=4" ([tagNEnd1 4, tagNEnd2 4, tagNEnd3 4, tagNEnd4 4, tagNEnd5 4] + == [8, 1032, 66568, 16843784, 4311811080]) ++ + test "TagN f=4 bytes: 7" (tagNEncodes 4 0xA 7 #[0xA7]) ++ + test "TagN f=4 bytes: 8" (tagNEncodes 4 0xA 8 #[0xA8, 0x00]) ++ + test "TagN f=4 bytes: 1031" (tagNEncodes 4 0x1 1031 #[0x1B, 0xFF]) ++ + test "TagN f=4 bytes: 1032" (tagNEncodes 4 0 1032 #[0x0C, 0x00, 0x00]) ++ + test "TagN f=4 bytes: 66567" (tagNEncodes 4 0 66567 #[0x0C, 0xFF, 0xFF]) ++ + test "TagN f=4 bytes: 66568" (tagNEncodes 4 0 66568 #[0x0D, 0, 0, 0]) ++ + test "TagN f=4 bytes: 16843783" (tagNEncodes 4 0 16843783 #[0x0D, 0xFF, 0xFF, 0xFF]) ++ + test "TagN f=4 bytes: 16843784" (tagNEncodes 4 0 16843784 #[0x0E, 0, 0, 0, 0]) ++ + test "TagN f=4 bytes: 4311811079" + (tagNEncodes 4 0 4311811079 #[0x0E, 0xFF, 0xFF, 0xFF, 0xFF]) ++ + test "TagN f=4 bytes: 4311811080" + (tagNEncodes 4 0 4311811080 #[0x0F, 0, 0, 0, 0, 0, 0, 0, 0]) ++ + test "TagN f=0 bytes: 127" (tagNEncodes 0 0 127 #[0x7F]) ++ + test "TagN f=0 bytes: 128" (tagNEncodes 0 0 128 #[0x80, 0x00]) ++ + test "TagN f=0 bytes: 16512" (tagNEncodes 0 0 16512 #[0xC0, 0x00, 0x00]) ++ + test "TagN f=0 bytes: 82047" (tagNEncodes 0 0 82047 #[0xC0, 0xFF, 0xFF]) ++ + test "TagN f=0 bytes: 82048" (tagNEncodes 0 0 82048 #[0xC1, 0, 0, 0]) ++ + test "TagN f=0 bytes: 16859263" (tagNEncodes 0 0 16859263 #[0xC1, 0xFF, 0xFF, 0xFF]) ++ + test "TagN f=0 bytes: 16859264" (tagNEncodes 0 0 16859264 #[0xC2, 0, 0, 0, 0]) ++ + test "TagN f=0 bytes: 4311826560" + (tagNEncodes 0 0 4311826560 #[0xC3, 0, 0, 0, 0, 0, 0, 0, 0]) ++ + test "TagN f=0 bytes: 2^64 - 1" + (tagNEncodes 0 0 (2 ^ 64 - 1) #[0xC3, 0x7F, 0xBF, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF]) ++ + test "TagN f=2 bytes: 32" (tagNEncodes 2 3 32 #[0xE0, 0x00]) ++ + test "TagN f=2 bytes: 4128" (tagNEncodes 2 3 4128 #[0xF0, 0x00, 0x00]) ++ + test "TagN f=2 bytes: 69663" (tagNEncodes 2 3 69663 #[0xF0, 0xFF, 0xFF]) ++ + test "TagN f=2 bytes: 69664" (tagNEncodes 2 3 69664 #[0xF1, 0, 0, 0]) ++ + test "TagN f=2 bytes: 16846879" (tagNEncodes 2 3 16846879 #[0xF1, 0xFF, 0xFF, 0xFF]) ++ + test "TagN f=2 bytes: 16846880" (tagNEncodes 2 3 16846880 #[0xF2, 0, 0, 0, 0]) ++ + test "TagN f=2 bytes: 4311814176" + (tagNEncodes 2 3 4311814176 #[0xF3, 0, 0, 0, 0, 0, 0, 0, 0]) ++ + test "TagN f=2 rejects code 4" (tagNRejects 2 #[0x34]) ++ + test "TagN f=2 rejects code 15" (tagNRejects 2 #[0x3F]) ++ + test "TagN f=0 rejects code 4" (tagNRejects 0 #[0xC4]) ++ + test "TagN f=0 rejects code 63" (tagNRejects 0 #[0xFF]) ++ + test "TagN f=4 rejects overflow" + (tagNRejects 4 #[0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]) ++ + test "TagN f=0 rejects overflow" + (tagNRejects 0 #[0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]) ++ + -- The smallest overflowing rung-6 payloads: 2^64 - R5 for each f, one past + -- the payload of 2^64 - 1 (R5 = 0x1_0101_4080, 0x1_0101_1020, 0x1_0101_0408). + test "TagN f=0 rejects the smallest overflow" + (tagNRejects 0 #[0xC3, 0x80, 0xBF, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF]) ++ + test "TagN f=2 accepts 2^64 - 1" + (tagNEncodes 2 0 (2 ^ 64 - 1) #[0x33, 0xDF, 0xEF, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF]) ++ + test "TagN f=2 rejects the smallest overflow" + (tagNRejects 2 #[0x33, 0xE0, 0xEF, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF]) ++ + test "TagN f=4 accepts 2^64 - 1" + (tagNEncodes 4 0 (2 ^ 64 - 1) #[0x0F, 0xF7, 0xFB, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF]) ++ + test "TagN f=4 rejects the smallest overflow" + (tagNRejects 4 #[0x0F, 0xF8, 0xFB, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF]) ++ + -- An invalid code followed by as many bytes as a valid rung would read: + -- a reader that kept only the low two code bits would accept these. + test "TagN f=0 rejects code 4 with two following bytes" (tagNRejects 0 #[0xC4, 0x00, 0x00]) ++ + test "TagN f=2 rejects code 4 with two following bytes" (tagNRejects 2 #[0x34, 0x00, 0x00]) ++ + test "TagN rejects truncated rung 2" (tagNRejects 4 #[0x08]) ++ + test "TagN rejects truncated rung 4" (tagNRejects 4 #[0x0D, 0x00, 0x00]) ++ + test "TagN rejects truncated rung 5" (tagNRejects 4 #[0x0E, 0x00, 0x00, 0x00]) ++ + test "TagN rejects truncated rung 6" (tagNRejects 4 #[0x0F, 0x00, 0x00, 0x00]) ++ + test "TagN rejects trailing byte" (tagNRejects 4 #[0x07, 0x00]) ++ + test "TagN f=0 short strings canonical" (tagNShortCanonical 0) ++ + test "TagN f=2 short strings canonical" (tagNShortCanonical 2) ++ + test "TagN f=4 short strings canonical" (tagNShortCanonical 4) + +/-! ## ExprMeta arena wire format + +Directed byte vectors for the arena encoding (implicit post-order children, +explicit TagN backward deltas); the same vectors are pinned in Rust +(`ixon::metadata::tests::arena_vector_*`). Name indices are 0 and 1 (one +byte in every integer code). -/ + +def arenaVecNames : Address × Address × NameIndex × NameReverseIndex := + let a := Address.blake3 (ByteArray.mk #[1]) + let b := Address.blake3 (ByteArray.mk #[2]) + (a, b, (({} : NameIndex).insert a 0).insert b 1, #[a, b]) + +def arenaBytes (arena : ExprMetaArena) : ByteArray := + runPut (putExprMetaArenaIndexed arena arenaVecNames.2.2.1) + +def arenaFrom (bytes : Array UInt8) : Except String ExprMetaArena := + runGetExact (getExprMetaArenaIndexed arenaVecNames.2.2.2) (ByteArray.mk bytes) + +/-- The arena writes exactly `bytes`, and `bytes` read back to the arena. -/ +def arenaVector (arena : ExprMetaArena) (bytes : Array UInt8) : Bool := + arenaBytes arena == ByteArray.mk bytes && + match arenaFrom bytes with + | .ok a => a == arena + | .error _ => false + +def arenaRejects (bytes : Array UInt8) : Bool := + match arenaFrom bytes with + | .error _ => true + | .ok _ => false + +def exprMetaArenaUnits : TestSeq := + let a := arenaVecNames.1 + let b := arenaVecNames.2.1 + -- `fun (x : T) => f x` in post-order: every child implicit. + let tree : ExprMetaArena := { nodes := #[ + .ref b, .ref a, .leaf, .app 1 2, .binder a .default 0 3] } + -- Shared nodes: explicit backward deltas next to implicit slots. + let dag : ExprMetaArena := { nodes := #[ + .leaf, .app 0 0, .letBinder a 0 1 0, .prj b 1, .mdata #[] 3] } + -- Call-site references are explicit; a forward reference wraps. + let calls : ExprMetaArena := { nodes := #[ + .leaf, + .callSite a #[.kept 0 0, .collapsed 1 0] #[0] (some (2, 0)), + .etaCallSite 1 b #[.kept 0 1] #[1] 1, + .prj a 7] } + test "arena: a post-order tree writes no references" + (arenaVector tree #[0x05, 0x38, 0x01, 0x38, 0x00, 0x00, 0x0B, 0x13, 0x00]) ++ + test "arena: shared nodes are explicit backward deltas" + (arenaVector dag #[0x05, 0x00, 0x0A, 0x00, 0x32, 0x00, 0x01, 0x01, 0x40, + 0x01, 0x01, 0x49, 0x00]) ++ + test "arena: call-site references are explicit; a forward reference wraps" + (arenaVector calls #[0x04, 0x00, + 0x50, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x00, + 0x58, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x40, 0x00, 0xC3, 0x7B, 0xBF, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF]) ++ + test "arena: rejects an explicit slot at the implicit position" + (arenaRejects #[0x02, 0x00, 0x08, 0x00, 0x00]) ++ + test "arena: rejects an implicit slot with no preceding node" + (arenaRejects #[0x01, 0x09, 0x00]) ++ + test "arena: rejects mask bits beyond the kind's slots" + (arenaRejects #[0x01, 0x01] && arenaRejects #[0x02, 0x00, 0x0C] && + arenaRejects #[0x01, 0x39, 0x00]) ++ + test "arena: rejects unknown kinds" (arenaRejects #[0x01, 0x60]) ++ + test "arena: rejects every truncation" + (let bytes : Array UInt8 := #[0x05, 0x38, 0x01, 0x38, 0x00, 0x00, 0x0B, 0x13, 0x00] + (List.range bytes.size).all fun n => arenaRejects (bytes.extract 0 n)) ++ + test "arena: the canonical form of a rejected vector is accepted" + (arenaVector { nodes := #[.leaf, .app 0 0] } #[0x02, 0x00, 0x0A, 0x00]) def constantUnits : TestSeq := let defn := Definition.mk .defn .safe 0 (.sort 0) (.var 0) @@ -170,43 +351,6 @@ def commUnits : TestSeq := let c := Comm.mk addr1 addr2 test "Comm roundtrip" (commSerde c) -/-! -## Sharing Analysis Tests --/ - -def sharingTest1 : Bool := - let e1 := Expr.app (.var 0) (.var 1) - let (rewritten1, sharing1) := Ix.Sharing.applySharing #[e1] - sharing1.isEmpty && rewritten1[0]! == e1 - -def sharingTest2 : Bool := - let ty := Expr.sort 0 - let e2 := Expr.app (.leanLam ty (.var 0)) (.leanLam ty (.var 1)) - let (_, sharing2) := Ix.Sharing.applySharing #[e2] - sharing2.size == 1 - -def sharingTest3 : Bool := - let var0 := Expr.var 0 - let e3a := Expr.app var0 var0 - let e3b := Expr.app var0 (.var 1) - let e3c := Expr.app var0 (.var 2) - let (_, sharing3) := Ix.Sharing.applySharing #[e3a, e3b, e3c] - sharing3.size >= 1 - -def sharingTest4 : Bool := - let e4 := Expr.leanLam (.sort 0) (.app (.var 0) (.var 0)) - let (rewritten4, _) := Ix.Sharing.applySharing #[e4] - let serialized := serExpr rewritten4[0]! - match deExpr serialized with - | .ok e => e == rewritten4[0]! - | .error _ => false - -def sharingUnits : TestSeq := - test "no sharing for unique subterms" sharingTest1 - ++ test "shares repeated sort 0" sharingTest2 - ++ test "analyzes multiple expressions" sharingTest3 - ++ test "roundtrip after sharing" sharingTest4 - /-! ## Env Unit Tests -/ def envSerdeUnit (env : Env) : Bool := @@ -472,14 +616,45 @@ def envMerkleRootUnitTests : TestSeq := test "(a,b) and (b,a) same root" (raw_ab.merkleRoot == raw_ba.merkleRoot) +/-! ## Format version 4: header byte and version rejection -/ + +/-- The empty env's bytes, with the header byte replaced by `header`. -/ +private def emptyEnvWithHeader (header : UInt8) : ByteArray := + match serEnv ({} : Env) with + | .ok bytes => bytes.set! 0 header + | .error _ => .empty + +/-- `r` failed with the readers' format-version error for version `got`. -/ +private def versionRejected {α : Type} (r : Except String α) (got : Nat) : Bool := + match r with + | .ok _ => false + | .error e => + (e.splitOn s!"expected .ixe format version {Env.VERSION}, got {got}").length > 1 + +def envHeaderUnits : TestSeq := + let bytes := match serEnv ({} : Env) with | .ok b => b | .error _ => .empty + test "env header is TagN(4, 0xE, 4) = 0xE4" (bytes.data[0]? == some 0xE4) + ++ test "wireFormatId is ixon-v4" (wireFormatId == "ixon-v4") + ++ test "object-format byte is the version" (Env.OBJECT_FORMAT == 4) + ++ test "Lean reader accepts the version 4 header" ((deEnv bytes).toOption.isSome) + ++ test "Lean reader rejects a version 3 header" + (versionRejected (deEnv (emptyEnvWithHeader 0xE3)) 3) + ++ test "Lean streaming reader rejects a version 3 header" + (versionRejected (deEnvVerifiedLazy (emptyEnvWithHeader 0xE3)) 3) + ++ test "Rust reader rejects a version 3 header" + (versionRejected (deEnvAnon (emptyEnvWithHeader 0xE3)) 3) + /-! ## Test Suite (property-based) -/ public def Tests.Ixon.suite : List TestSeq := [ + envHeaderUnits, univExactUnits, univUnits, exprExactUnits, exprUnits, strictExprUnits, + tagNUnits, + exprMetaArenaUnits, -- Env unit tests (for debugging serialization) envUnitTests, -- Env serialization comparison unit tests diff --git a/Tests/Ix/IxonV3Text.lean b/Tests/Ix/IxonText.lean similarity index 96% rename from Tests/Ix/IxonV3Text.lean rename to Tests/Ix/IxonText.lean index eaa40fb0e..393941074 100644 --- a/Tests/Ix/IxonV3Text.lean +++ b/Tests/Ix/IxonText.lean @@ -1,6 +1,6 @@ import Tests.Ix.IxonSyntax -namespace Tests.IxonV3 +namespace Tests.IxonText open Ixon.Syntax def textContractKey : Term → Option (String × Nat × Nat) @@ -18,7 +18,7 @@ def textContractKey : Term → Option (String × Nat × Nat) | _ => none def runText : IO Nat := do - let bytes ← IO.FS.readFile "Tests/Fixtures/ixon-v3/text.tsv" + let bytes ← IO.FS.readFile "Tests/Fixtures/ixon-v4/text.tsv" let mut count := 0 for line in bytes.splitOn "\n" do if line.isEmpty then continue @@ -64,4 +64,4 @@ def runText : IO Nat := do unless result == 0 do throw (IO.userError "text grammar regression suite failed") return count -end Tests.IxonV3 +end Tests.IxonText diff --git a/Tests/Ix/IxonV3.lean b/Tests/Ix/IxonV4.lean similarity index 68% rename from Tests/Ix/IxonV3.lean rename to Tests/Ix/IxonV4.lean index bf0e54592..2d98e15a7 100644 --- a/Tests/Ix/IxonV3.lean +++ b/Tests/Ix/IxonV4.lean @@ -1,10 +1,9 @@ module public import Ix.Ixon -public import Ix.Sharing public section -namespace Tests.IxonV3 +namespace Tests.IxonV4 open Ixon structure ExprCase where @@ -27,7 +26,36 @@ def fixtures : List (String × Expr) := [ ("borrow", .letE (.borrow false .affine) (.sort 0) (.prj 2 1 (.var 1)) (.var 0)), ("borrow_nondep", .letE (.borrow true .many) (.sort 0) (.var 1) (.var 0)), ("reference", .ref 0 #[]), - ("recursion", .recur 2 #[0, 1]) + ("recursion", .recur 2 #[0, 1]), + -- The last and first value of every TagN rung, f = 4 (an expression + -- header) and f = 0 (a Ref index); the bytes are derived by hand in the + -- fixture file. + ("tagn4_rung1_last", .var 7), + ("tagn4_rung2_first", .var 8), + ("tagn4_rung2_last", .var 1031), + ("tagn4_rung3_first", .var 1032), + ("tagn4_rung3_last", .var 66567), + ("tagn4_rung4_first", .var 66568), + ("tagn4_rung4_last", .var 16843783), + ("tagn4_rung5_first", .var 16843784), + ("tagn4_rung5_last", .var 4311811079), + ("tagn4_rung6_first", .var 4311811080), + ("tagn4_rung6_last", .var 18446744073709551615), + ("tagn0_rung1_last", .ref 127 #[]), + ("tagn0_rung2_first", .ref 128 #[]), + ("tagn0_rung2_last", .ref 16511 #[]), + ("tagn0_rung3_first", .ref 16512 #[]), + ("tagn0_rung3_last", .ref 82047 #[]), + ("tagn0_rung4_first", .ref 82048 #[]), + ("tagn0_rung4_last", .ref 16859263 #[]), + ("tagn0_rung5_first", .ref 16859264 #[]), + ("tagn0_rung5_last", .ref 4311826559 #[]), + ("tagn0_rung6_first", .ref 4311826560 #[]), + ("tagn0_rung6_last", .ref 18446744073709551615 #[]), + ("app_telescope_8", + (List.range 8).reverse.foldl (fun f i => .app f (.var i.toUInt64)) (.var 8)), + ("ref_univs_8", .ref 0 #[0, 1, 2, 3, 4, 5, 6, 7]), + ("share_rung3", .share 1032) ] def valueContracts : Array ValueContract := #[.unique, .shared, .localUnique, .localShared] @@ -59,8 +87,12 @@ def modeCases : List ExprCase := Id.run do /-- Load independent golden bytes once for the Lean, Rust FFI, and VM suites. -/ def readExprCases : IO (List ExprCase) := do - let file ← IO.FS.readFile "Tests/Fixtures/ixon-v3/expressions.txt" + let file ← IO.FS.readFile "Tests/Fixtures/ixon-v4/expressions.txt" let lines := file.splitOn "\n" + -- Every row of the file is a case here (and in the Rust golden test). + let rows := lines.filter fun line => !line.isEmpty && !line.startsWith "#" + unless rows.length == fixtures.length do + throw <| IO.userError s!"expressions.txt has {rows.length} rows, {fixtures.length} cases" let golden : List ExprCase ← fixtures.mapM fun (name, expr) => do let some line := lines.find? (·.startsWith (name ++ " ")) | throw <| IO.userError s!"missing fixture {name}" @@ -94,9 +126,17 @@ def malformedCases : Array (String × ByteArray) := #[ ("split-lambda-telescope", .mk #[0x81, 0x07, 0x00, 0x81, 0x07, 0x00, 0x10]), ("split-forall-telescope", .mk #[0x91, 0x17, 0x00, 0x91, 0x17, 0x00, 0x10]), ("reserved-let-flags", .mk #[0xA4, 0x07, 0x00, 0x10, 0x10]), - ("nonminimal-variable", .mk #[0x18, 0x00]), - ("nonminimal-reference-count", .mk #[0x28, 0x07, 0x00]), - ("nonminimal-reference-index", .mk #[0x20, 0x80, 0x00]), + -- TagN is bijective, so no integer has a second encoding (the v3 + -- non-minimal cases `18 00` and `20 80 00` are now `Var(8)` and + -- `Ref(128, [])`, and `28 07` heads a 15-universe reference). The integer + -- rejections are a missing rung byte, an invalid `f = 0` code, a value + -- reaching 2^64, and a count larger than the remaining input. A + -- reference header carries its universe count, then the TagN index. + ("truncated-variable-rung", .mk #[0x18]), + ("truncated-reference-count-rung", .mk #[0x2C, 0x00]), + ("invalid-reference-index-code", .mk #[0x20, 0xC4]), + ("overflowing-variable", .mk #[0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]), + ("oversized-reference-universe-count", .mk #[0x28, 0xFF, 0x00]), ("truncated-lambda-telescope", .mk #[0x87, 0x07, 0x00, 0x10]), ("truncated-app-telescope", .mk #[0x77, 0x10]) ] @@ -121,4 +161,4 @@ def runGolden (cases : List ExprCase) : IO Nat := do checks := checks + 1 return checks -end Tests.IxonV3 +end Tests.IxonV4 diff --git a/Tests/Ix/IxonV3FFI.lean b/Tests/Ix/IxonV4FFI.lean similarity index 84% rename from Tests/Ix/IxonV3FFI.lean rename to Tests/Ix/IxonV4FFI.lean index 6c0f16af2..0899cd9df 100644 --- a/Tests/Ix/IxonV3FFI.lean +++ b/Tests/Ix/IxonV4FFI.lean @@ -1,15 +1,14 @@ module -public import Tests.Ix.IxonV3 +public import Tests.Ix.IxonV4 public section -namespace Tests.IxonV3 +namespace Tests.IxonV4 open Ixon @[extern "rs_roundtrip_ixon_expr"] opaque roundtripExpr : @& Expr → Expr @[extern "rs_roundtrip_ixon_constant"] opaque roundtripConstant : @& Constant → Constant @[extern "rs_eq_expr_serialization"] opaque equalExprBytes : @& Expr → @& ByteArray → Bool @[extern "rs_eq_constant_serialization"] opaque equalConstantBytes : @& Constant → @& ByteArray → Bool -@[extern "rs_expr_hash_matches"] opaque equalSharingHash : @& Expr → @& Address → Bool def runFFI (cases : List ExprCase) : IO Nat := do let mut checks := 0 @@ -18,9 +17,7 @@ def runFFI (cases : List ExprCase) : IO Nat := do throw <| IO.userError s!"{name}: FFI roundtrip differs" unless equalExprBytes expr (runPut (putExpr expr)) do throw <| IO.userError s!"{name}: Lean/Rust bytes differ" - unless equalSharingHash expr (Ix.Sharing.computeExprHash expr) do - throw <| IO.userError s!"{name}: Lean/Rust sharing hash differs" - checks := checks + 3 + checks := checks + 2 let typ := Expr.all ⟨.linear, .localUnique⟩ .localShared (.sort 0) (.sort 0) let value := lambdaTelescope let ctor : Constructor := ⟨true, 5, 1, 2, 3, typ⟩ @@ -40,4 +37,4 @@ def runFFI (cases : List ExprCase) : IO Nat := do checks := checks + 2 return checks -end Tests.IxonV3 +end Tests.IxonV4 diff --git a/Tests/Ix/IxonV4Paths.lean b/Tests/Ix/IxonV4Paths.lean new file mode 100644 index 000000000..72537af95 --- /dev/null +++ b/Tests/Ix/IxonV4Paths.lean @@ -0,0 +1,44 @@ +module + +public section + +namespace Tests.IxonV4 + +/-- Environment variable naming the scratch directory of the Ixon v4 test +executables. `ixon-v4-primitives` writes the primitive closure there and +`ixon-v4-tests --primitives` reads it back; `--export-fixtures` and +`--export-handoff` write under it. Unset, it is `/tmp`; checkouts that run +these executables at the same time should each set their own directory. -/ +def scratchDirVar : String := "IX_IXON_V4_DIR" + +/-- The scratch directory: `$IX_IXON_V4_DIR`, or `/tmp`. -/ +def scratchDir : IO System.FilePath := + return System.FilePath.mk ((← IO.getEnv scratchDirVar).getD "/tmp") + +/-- The primitive address table written by `ixon-v4-primitives`. -/ +def primitivesTsv (dir : System.FilePath) : System.FilePath := + dir / "ixon-v4-primitives.tsv" + +/-- The primitive closure written by `ixon-v4-primitives` and validated by +`ixon-v4-tests --primitives`. -/ +def primitivesIxe (dir : System.FilePath) : System.FilePath := + dir / "ixon-v4-primitives.ixe" + +/-- Where `ixon-v4-tests --export-fixtures` writes the generated text fixtures. -/ +def fixtureExportDir (dir : System.FilePath) : System.FilePath := + dir / "ixon-v4-fixtures" + +/-- Where `ixon-v4-tests --export-handoff` writes the handoff artifacts. -/ +def handoffExportDir (dir : System.FilePath) : System.FilePath := + dir / "ixon-v4-handoff" + +/-- The scratch-directory paragraph of both executables' usage text. -/ +def scratchUsage : String := + s!"Scratch files live in ${scratchDirVar} (default /tmp): ixon-v4-primitives.tsv +and ixon-v4-primitives.ixe from ixon-v4-primitives, read back by +ixon-v4-tests --primitives; ixon-v4-fixtures/ and ixon-v4-handoff/ from the +export flags. Set {scratchDirVar} when two checkouts run these at the same time." + +end Tests.IxonV4 + +end diff --git a/Tests/Ix/IxonV3VM.lean b/Tests/Ix/IxonV4VM.lean similarity index 88% rename from Tests/Ix/IxonV3VM.lean rename to Tests/Ix/IxonV4VM.lean index 524a427de..fb4a17bee 100644 --- a/Tests/Ix/IxonV3VM.lean +++ b/Tests/Ix/IxonV4VM.lean @@ -1,5 +1,5 @@ module -public import Tests.Ix.IxonV3 +public import Tests.Ix.IxonV4 public import Tests.Aiur.Common public import Ix.IxVM.Toplevel public import Ix.IxVM.ClaimHarness @@ -7,7 +7,7 @@ public import Ix.Resource.Claim public import Tests.Ix.ResourceAddressed public section -namespace Tests.IxonV3 +namespace Tests.IxonV4 def codecEntrypoints := ⟦ pub fn ixon_expr_decode() { @@ -114,18 +114,17 @@ def checkVMProof (env : AiurTestEnv) (fnName : Lean.Name) 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 or the largest canonical UInt64. Each -truncated stream supplies one element, then ends. The decode-only entrypoints -ensure rejection happens before reserialization. -/ +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, (2 ^ 64 - 1 : Nat)] do - let large := count > 2 + for count in [1, 2, 128, (2 ^ 64 - 1 : Nat)] do + let large := count == 2 ^ 64 - 1 let accept := count == 1 - let suffix : Array UInt8 := if large then Array.replicate 8 0xff else #[] - let tag0 : ByteArray := .mk ((if large then #[0x87] else #[count.toUInt8]) ++ suffix) - let tag4 (flag : UInt8) : ByteArray := - .mk (#[flag * 16 + (if large then 15 else count.toUInt8)] ++ suffix) + 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 [ @@ -183,11 +182,25 @@ def runVMClaims : IO Nat := 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 2), + ("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 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 tree.root none))) 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 @@ -233,4 +246,4 @@ def runVM (cases : List ExprCase) : IO Nat := do -- Execute and prove the actual production claim boundary as well. return checks + 2 + (← runVMClaims) -end Tests.IxonV3 +end Tests.IxonV4 diff --git a/Tests/Ix/Resource.lean b/Tests/Ix/Resource.lean index 5f49a5994..f0254ed16 100644 --- a/Tests/Ix/Resource.lean +++ b/Tests/Ix/Resource.lean @@ -263,17 +263,29 @@ def higherOrderCases : Array Case := Id.run do def allCases : Array Case := cases ++ higherOrderCases +/-- One `resource.tsv` row: name, expected outcome, type and body bytes. -/ +def fixtureLine (test : Case) : String := + s!"{test.name}\t{test.expected}\t{hexOfBytes (runPut (putExpr test.type))}\t{hexOfBytes (runPut (putExpr test.value))}" + +/-- The shared `resource.tsv` fixture, also read by the Rust resource checker. +`lake exe ixon-v4-tests --export-fixtures` writes it. -/ +def fixtureText : String := + allCases.foldl (fun text test => text ++ fixtureLine test ++ "\n") + s!"# name\texpected\ttype ({Ixon.wireFormatId} hex)\tbody ({Ixon.wireFormatId} hex)\n" + def runFixtureCases : IO Nat := do - let file ← IO.FS.readFile "Tests/Fixtures/ixon-v3/resource.tsv" + let file ← IO.FS.readFile "Tests/Fixtures/ixon-v4/resource.tsv" let lines := file.splitOn "\n" for test in allCases do let actual := runCase test.type test.value let code := match actual with | .ok _ => "ok" | .error e => errorCode e unless code == test.expected do throw <| IO.userError s!"resource: {test.name}: expected {test.expected}, got {repr actual}" - let line := s!"{test.name}\t{test.expected}\t{hexOfBytes (runPut (putExpr test.type))}\t{hexOfBytes (runPut (putExpr test.value))}" - unless lines.contains line do + unless lines.contains (fixtureLine test) do throw <| IO.userError s!"resource fixture bytes differ: {test.name}" + unless file == fixtureText do + throw <| IO.userError "resource fixture differs from its producer; regenerate it with \ + `lake exe ixon-v4-tests --export-fixtures`" return allCases.size def runContractMatrix : IO Nat := do diff --git a/Tests/Ix/ResourceAddressed.lean b/Tests/Ix/ResourceAddressed.lean index d0d6fe569..787643eeb 100644 --- a/Tests/Ix/ResourceAddressed.lean +++ b/Tests/Ix/ResourceAddressed.lean @@ -49,17 +49,37 @@ def get (label : String) (result : Except String α) : IO α := | .ok value => pure value | .error e => throw <| IO.userError s!"addressed resource {label}: {e}" +/-- The profile the shared fixture pins. -/ +def fixtureProfile : Profile := + let (_, unit) := unitEnv + { natType := some unit, shareableTypes := #[unit] } + +/-- One `addressed.tsv` row: a constant's address and canonical bytes. -/ +def fixtureLine (label : String) (constant : Constant) : String := + s!"{label}\t{Addressed.commit constant}\t{hexOfBytes (serConstant constant)}" + +/-- The shared `addressed.tsv` fixture, also read by the Rust resource +validator. `lake exe ixon-v4-tests --export-fixtures` writes it. -/ +def fixtureText : Except String String := do + let profileAddress ← fixtureProfile.address + let rows := fixtures.map fun (label, constant) => fixtureLine label constant + let rows := rows.push s!"profile\t{profileAddress}\t{hexOfBytes fixtureProfile.bytes}" + return rows.foldl (fun text row => text ++ row ++ "\n") "# name\taddress\tcanonical bytes\n" + def run : IO Unit := do let (base, unit) := unitEnv - let profile : Profile := { natType := some unit, shareableTypes := #[unit] } - let fixture ← IO.FS.readFile "Tests/Fixtures/ixon-v3/addressed.tsv" + let profile := fixtureProfile + let fixture ← IO.FS.readFile "Tests/Fixtures/ixon-v4/addressed.tsv" let lines := fixture.splitOn "\n" for (label, constant) in fixtures do - let line := s!"{label}\t{Addressed.commit constant}\t{hexOfBytes (serConstant constant)}" - unless lines.contains line do throw <| IO.userError s!"addressed fixture differs: {label}" + unless lines.contains (fixtureLine label constant) do + throw <| IO.userError s!"addressed fixture differs: {label}" let profileAddress ← get "profile address" profile.address unless lines.contains s!"profile\t{profileAddress}\t{hexOfBytes profile.bytes}" do throw <| IO.userError "addressed profile fixture differs" + unless fixture == (← get "fixture text" fixtureText) do + throw <| IO.userError "addressed fixture differs from its producer; regenerate it with \ + `lake exe ixon-v4-tests --export-fixtures`" let decoded ← get "profile roundtrip" (Profile.ofBytes profile.bytes) unless decoded.bytes == profile.bytes do throw <| IO.userError "profile roundtrip differs" for length in [:profile.bytes.size] do diff --git a/Tests/Ix/Sharing.lean b/Tests/Ix/Sharing.lean deleted file mode 100644 index 2b4dd3e65..000000000 --- a/Tests/Ix/Sharing.lean +++ /dev/null @@ -1,677 +0,0 @@ -/- - Unit tests for Sharing module - verifies hash-consing compatibility with Rust. - - The hashing algorithm must produce identical results to Rust's `hash_node` function - for cross-implementation compatibility. --/ - -module -public import Ix.Sharing -public import Ix.Ixon -public import Ix.CompileM -public import Ix.CanonM -public import Ix.Meta -public import Ix.Environment -public import LSpec - -public section - -open LSpec Ix.Sharing Ixon Ix.CompileM Ix - -namespace Tests.Sharing - -/-! ## uint64ToBytes tests -/ - -/-- Verify uint64ToBytes produces exactly 8 bytes. -/ -def testUint64ToBytesLength : TestSeq := - group "uint64ToBytes length" <| - test "0" ((uint64ToBytes 0).size == 8) ++ - test "1" ((uint64ToBytes 1).size == 8) ++ - test "255" ((uint64ToBytes 255).size == 8) ++ - test "256" ((uint64ToBytes 256).size == 8) ++ - test "maxUInt64" ((uint64ToBytes UInt64.MAX).size == 8) - -/-- Verify uint64ToBytes produces correct little-endian encoding. -/ -def testUint64ToBytesEncoding : TestSeq := - group "uint64ToBytes encoding" <| - -- 0 should be [0,0,0,0,0,0,0,0] - test "0 bytes" (uint64ToBytes 0 == ⟨#[0,0,0,0,0,0,0,0]⟩) ++ - -- 1 should be [1,0,0,0,0,0,0,0] - test "1 bytes" (uint64ToBytes 1 == ⟨#[1,0,0,0,0,0,0,0]⟩) ++ - -- 256 should be [0,1,0,0,0,0,0,0] - test "256 bytes" (uint64ToBytes 256 == ⟨#[0,1,0,0,0,0,0,0]⟩) ++ - -- 0x0102030405060708 should be [8,7,6,5,4,3,2,1] - test "0x0102030405060708 bytes" - (uint64ToBytes 0x0102030405060708 == ⟨#[0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01]⟩) - -/-! ## Hash consistency tests -/ - -/-- Verify that the same expression always produces the same hash. -/ -def testHashConsistency : TestSeq := - let e1 := Expr.var 0 - let e2 := Expr.var 0 - let h1 := computeExprHash e1 - let h2 := computeExprHash e2 - test "same expr same hash" (h1 == h2) - -/-- Verify that different expressions produce different hashes. -/ -def testHashDifferent : TestSeq := - let e1 := Expr.var 0 - let e2 := Expr.var 1 - let h1 := computeExprHash e1 - let h2 := computeExprHash e2 - test "different expr different hash" (h1 != h2) - -/-! ## Hash buffer construction tests -/ - -/-- Test that Sort expression hash buffer is: [FLAG_SORT, u64_le_bytes...] -/ -def testSortHashBuffer : TestSeq := - -- Sort(5) should hash buffer: [0x00, 5, 0, 0, 0, 0, 0, 0, 0] - let expected := ByteArray.empty - |>.push Expr.FLAG_SORT - |>.append (uint64ToBytes 5) - test "sort buffer size" (expected.size == 9) ++ - test "sort buffer content" (expected.data[0]! == 0x00 && expected.data[1]! == 5) - -/-- Test that Var expression hash buffer is: [FLAG_VAR, u64_le_bytes...] -/ -def testVarHashBuffer : TestSeq := - -- Var(3) should hash buffer: [0x01, 3, 0, 0, 0, 0, 0, 0, 0] - let expected := ByteArray.empty - |>.push Expr.FLAG_VAR - |>.append (uint64ToBytes 3) - test "var buffer size" (expected.size == 9) ++ - test "var buffer content" (expected.data[0]! == 0x01 && expected.data[1]! == 3) - -/-- Test that App expression includes child hashes (64 bytes for 2 children). -/ -def testAppHashBuffer : TestSeq := - let fun_ := Expr.var 0 - let arg := Expr.var 1 - let funHash := computeExprHash fun_ - let argHash := computeExprHash arg - -- App buffer: [0x07, funHash(32 bytes), argHash(32 bytes)] - let expected := ByteArray.empty - |>.push Expr.FLAG_APP - |>.append funHash.hash - |>.append argHash.hash - test "app buffer size" (expected.size == 65) ++ - test "app buffer flag" (expected.data[0]! == 0x07) - -/-! ## Sharing analysis tests -/ - -/-- Test that applySharing returns empty sharing vec for unique subterms. -/ -def testNoSharing : TestSeq := - let exprs := #[Expr.var 0, Expr.var 1, Expr.var 2] - let (rewritten, sharingVec) := applySharing exprs - test "no sharing needed" (sharingVec.isEmpty) ++ - test "expressions unchanged" (rewritten == exprs) - -/-- Test that applySharing detects shared subterms. -/ -def testWithSharing : TestSeq := - -- Create expressions with shared subterm: (var 42) appears twice - let shared := Expr.var 42 - let e1 := Expr.app shared (Expr.var 1) - let e2 := Expr.app shared (Expr.var 2) - let e3 := Expr.app shared (Expr.var 3) - let exprs := #[e1, e2, e3] - let (_rewritten, _sharingVec) := applySharing exprs - -- var 42 should be shared since it appears 3 times - -- But it's a small term, so sharing might not be profitable - -- Just verify the function runs without error - test "sharing analysis completes" (_rewritten.size == exprs.size) - -/-- Test that sharing vector is in topological order (leaves first). -/ -def testSharingTopoOrder : TestSeq := - -- Create: App(Lam(T, B), A) where T appears in multiple places - let t := Expr.var 0 -- type - let b := Expr.var 1 -- body - let a := Expr.var 2 -- arg - let lam := Expr.leanLam t b - let app := Expr.app lam a - -- Use the same type in another expression - let e2 := Expr.app (Expr.leanLam t (Expr.var 3)) a - let exprs := #[app, e2] - let (_, sharingVec) := applySharing exprs - -- Verify no forward references in sharing vector - -- (each Share(idx) in sharingVec[i] must have idx < i) - let valid := sharingVec.foldl (init := (true, 0)) fun (ok, i) e => - let thisOk := checkNoForwardRefs e i - (ok && thisOk, i + 1) - test "no forward references" valid.1 -where - checkNoForwardRefs (e : Ixon.Expr) (maxIdx : Nat) : Bool := - match e with - | .share idx => idx.toNat < maxIdx - | .app f a => checkNoForwardRefs f maxIdx && checkNoForwardRefs a maxIdx - | .lam _ t b => checkNoForwardRefs t maxIdx && checkNoForwardRefs b maxIdx - | .all _ _ t b => checkNoForwardRefs t maxIdx && checkNoForwardRefs b maxIdx - | .letE _ t v b => - checkNoForwardRefs t maxIdx && checkNoForwardRefs v maxIdx && checkNoForwardRefs b maxIdx - | .prj _ _ v => checkNoForwardRefs v maxIdx - | _ => true - -/-! ## Known hash value tests (for cross-impl verification) -/ - -/-- Compute expected hash for Var(0) and verify it's deterministic. - The actual hash value should match Rust's hash_node for the same input. -/ -def testKnownHashVar0 : TestSeq := - let e := Expr.var 0 - let h := computeExprHash e - -- V3 sharing uses the canonical scalar node header: Var(0) is [0x10]. - let buf := ByteArray.mk #[0x10] - let expected := Address.blake3 buf - test "var 0 hash matches expected" (h == expected) - -/-- Compute expected hash for Sort(0) and verify. -/ -def testKnownHashSort0 : TestSeq := - let e := Expr.sort 0 - let h := computeExprHash e - -- V3 sharing uses the canonical scalar node header: Sort(0) is [0x00]. - let buf := ByteArray.mk #[0x00] - let expected := Address.blake3 buf - test "sort 0 hash matches expected" (h == expected) - -/-! ## Cross-implementation tests (Lean vs Rust) -/ - -/-- FFI: Run Rust's sharing analysis and return the count of shared items. -/ -@[extern "rs_analyze_sharing_count"] -opaque rsAnalyzeSharingCount : @& Array Ixon.Expr → UInt64 - -/-- FFI: Compare Lean's sharing analysis with Rust's on the same input. - Returns packed u64: - - bits 0-31: 1 if sharing vectors match, 0 otherwise - - bits 32-47: Lean sharing count - - bits 48-63: Rust sharing count -/ -@[extern "rs_compare_sharing_analysis"] -opaque rsCompareSharingAnalysis : @& Array Ixon.Expr → @& Array Ixon.Expr → @& Array Ixon.Expr → UInt64 - -/-- FFI: Debug sharing analysis - print Rust's view of the input expressions. -/ -@[extern "rs_debug_sharing_analysis"] -opaque rsDebugSharingAnalysis : @& Array Ixon.Expr → Unit - -/-- Opaque type representing a compiled environment from Rust. - This is an external object managed by the Rust FFI layer. -/ -opaque RustCompiledEnv : Type - -/-- FFI: Get the buffer length needed for pre-sharing expressions. -/ -@[extern "rs_get_pre_sharing_exprs_len"] -opaque rsGetPreSharingExprsLen : @& RustCompiledEnv → @& Lean.Name → UInt64 - -/-- FFI: Get the pre-sharing root expressions for a constant as serialized bytes. - Returns the number of expressions. Output buffer format: - [n_exprs:u64, len1:u64, expr1_bytes..., len2:u64, expr2_bytes..., ...] -/ -@[extern "rs_get_pre_sharing_exprs"] -opaque rsGetPreSharingExprs : @& RustCompiledEnv → @& Lean.Name → @& ByteArray → IO UInt64 - -/-- FFI: Look up a constant's compiled address (32-byte blake3 hash). - Returns true if found, copies address to out_addr ByteArray. -/ -@[extern "rs_lookup_const_addr"] -opaque rsLookupConstAddr : @& RustCompiledEnv → @& Lean.Name → @& ByteArray → IO Bool - -/-- FFI: Get the total number of compiled constants. -/ -@[extern "rs_get_compiled_const_count"] -opaque rsGetCompiledConstCount : @& RustCompiledEnv → UInt64 - -/-- Unpack the comparison result from rsCompareSharingAnalysis -/ -def unpackSharingComparison (packed : UInt64) : Bool × UInt64 × UInt64 := - let isMatch := (packed &&& 0xFFFFFFFF) == 1 - let leanCount := (packed >>> 32) &&& 0xFFFF - let rustCount := (packed >>> 48) &&& 0xFFFF - (isMatch, leanCount, rustCount) - -/-! ## Recursor sharing test -/ - -/-- Test sharing analysis on a recursor-like structure. - - A typical 4-constructor recursor type looks like: - ∀ (motive : T → Sort u), - (minor1 : motive C1) → (minor2 : motive C2) → (minor3 : motive C3) → (minor4 : motive C4) → - ∀ (t : T), motive t - - Where T = ref 0 #[] appears 6 times (in motive type, each minor, and final target). - With usage=6, size=2 (tag4(0) + tag0(0)), profitability is: - (6-1)*2 = 10 > 6*1 = 6 ✓ PROFITABLE - - This test verifies Lean correctly identifies and shares such repeated refs. --/ -def testRecursorSharing : TestSeq := Id.run do - -- Test: Expression with ref appearing 4 times should be shared - -- For profitability: (n-1)*size > n*ref_size - -- With n=4, size=2: (4-1)*2 = 6 > 4*1 = 4 ✓ PROFITABLE - let t := Expr.ref 0 #[] -- size=2 (tag4(0) + tag0(0)) - let sortU := Expr.sort 1 - - -- Use t four times: in nested all expressions - let e1 := Expr.leanAll t sortU -- use 1 - let e2 := Expr.leanAll t e1 -- use 2 - let e3 := Expr.leanAll t e2 -- use 3 - let e4 := Expr.leanAll t e3 -- use 4 - - let result := analyzeBlock #[e4] - let effectiveSizes := computeEffectiveSizes result.infoMap result.topoOrder - let sharedHashes := decideSharing result.infoMap result.topoOrder - - let refHash := computeExprHash t - let refInfo := result.infoMap.get? refHash - let refUsage := refInfo.map (·.usageCount) |>.getD 0 - let refEffSize := effectiveSizes.getD refHash 0 - let refGross : _root_.Int := (refUsage - 1 : _root_.Int) * refEffSize - let refPotential : _root_.Int := refGross - refUsage - - let refShared := sharedHashes.any (· == refHash) - - let (_, sharingVec) := buildSharingVec #[e4] sharedHashes result.infoMap result.ptrToHash - - return group "recursor sharing" ( - test "ref found with usage >= 4" (refUsage >= 4) ++ - test "ref potential > 0" (refPotential > 0) ++ - test "ref is shared" refShared ++ - test "sharing vector non-empty" (sharingVec.size >= 1) - ) - -/-- Test with a realistic recursor-like structure. - This mimics what we see in the actual test output: - - Type: ∀ (motive : T → Sort u), motive C1 → motive C2 → motive C3 → ∀ (t : T), motive t - - Rules: var X, var Y, var Z (just minor arguments) --/ -def testRealisticRecursor : TestSeq := Id.run do - -- The inductive type T = ref 0 - let tRef := Expr.ref 0 #[] - let sortU := Expr.sort 1 - let _sort0 := Expr.sort 0 - - -- Constructor refs - let c1 := Expr.ref 1 #[] - let c2 := Expr.ref 2 #[] - let c3 := Expr.ref 3 #[] - - -- Build the type: ∀ (motive : T → Sort u), motive C1 → motive C2 → motive C3 → ∀ (t : T), motive t - -- From inside out: - let _motiveVar := Expr.var 0 -- motive when in scope - let tVar := Expr.var 0 -- t when innermost - - -- ∀ (t : T), motive t (motive is var 1 here due to binder) - let targetBody := Expr.app (Expr.var 1) tVar - let target := Expr.leanAll tRef targetBody - - -- motive C3 → target (motive is var 3 here) - let minor3 := Expr.app (Expr.var 3) c3 - let withMinor3 := Expr.leanAll minor3 target - - -- motive C2 → ... (motive is var 2 here) - let minor2 := Expr.app (Expr.var 2) c2 - let withMinor2 := Expr.leanAll minor2 withMinor3 - - -- motive C1 → ... (motive is var 1 here) - let minor1 := Expr.app (Expr.var 1) c1 - let withMinor1 := Expr.leanAll minor1 withMinor2 - - -- ∀ (motive : T → Sort u), ... - let motiveType := Expr.leanAll tRef sortU - let fullType := Expr.leanAll motiveType withMinor1 - - -- Rules are just bound variables (minor arguments) - let rule1 := Expr.var 1 - let rule2 := Expr.var 2 - let rule3 := Expr.var 3 - - -- Analyze all expressions together (like Rust does) - let allExprs := #[fullType, rule1, rule2, rule3] - let result := analyzeBlock allExprs - let _effectiveSizes := computeEffectiveSizes result.infoMap result.topoOrder - let sharedHashes := decideSharing result.infoMap result.topoOrder - - -- Check each ref - let tRefHash := computeExprHash tRef - let c1Hash := computeExprHash c1 - let c2Hash := computeExprHash c2 - let c3Hash := computeExprHash c3 - - let tRefUsage := result.infoMap.get? tRefHash |>.map (·.usageCount) |>.getD 0 - let _c1Usage := result.infoMap.get? c1Hash |>.map (·.usageCount) |>.getD 0 - let _c2Usage := result.infoMap.get? c2Hash |>.map (·.usageCount) |>.getD 0 - let _c3Usage := result.infoMap.get? c3Hash |>.map (·.usageCount) |>.getD 0 - - -- Build sharing vector - let (_rewritten, _sharingVec) := buildSharingVec allExprs sharedHashes result.infoMap result.ptrToHash - - -- ref 0 (type) appears 2 times: in motiveType and target - -- With usage=2, size=2: potential = 1*2 - 2 = 0, NOT shared - - return group "realistic recursor" ( - test "type ref usage = 2" (tRefUsage == 2) ++ - test "analysis completes" true - ) - -/-- Test that content hash collision correctly increments usage. - If we create the same expression multiple times (different Lean pointers), - the sharing analysis should still count them as the same subterm. -/ -def testContentHashCollision : TestSeq := Id.run do - -- Create "ref 0 #[]" three times - different Lean objects, same content - let r1 := Expr.ref 0 #[] - let r2 := Expr.ref 0 #[] - let r3 := Expr.ref 0 #[] - - -- Wrap each in a different expression - let e1 := Expr.leanAll r1 (Expr.sort 0) - let e2 := Expr.leanAll r2 (Expr.sort 1) - let e3 := Expr.leanAll r3 (Expr.sort 2) - - let result := analyzeBlock #[e1, e2, e3] - - let refHash := computeExprHash (Expr.ref 0 #[]) - let refUsage := result.infoMap.get? refHash |>.map (·.usageCount) |>.getD 0 - - return group "content hash collision" ( - test "ref usage counted via hash collision" (refUsage == (3 : Nat)) - ) - -/-! ## Cross-implementation sharing tests -/ - -/-- Test that Lean and Rust produce identical sharing decisions for a simple case. - Creates a set of expressions with known sharing opportunities and compares - the sharing vectors produced by both implementations. -/ -def testCrossImplSharingSimple : TestSeq := Id.run do - -- Create expressions with 4 usages of ref 0 #[] (should be shared) - let t := Expr.ref 0 #[] - let sortU := Expr.sort 1 - let e1 := Expr.leanAll t sortU - let e2 := Expr.leanAll t e1 - let e3 := Expr.leanAll t e2 - let e4 := Expr.leanAll t e3 - let exprs := #[e4] - - -- Run Lean's sharing analysis - let result := analyzeBlock exprs - let sharedHashes := decideSharing result.infoMap result.topoOrder - let (rewritten, sharingVec) := buildSharingVec exprs sharedHashes result.infoMap result.ptrToHash - - -- Run Rust's sharing analysis via FFI - let rustSharingCount := rsAnalyzeSharingCount exprs - let (isMatch, _leanCount, _rustCount) := unpackSharingComparison (rsCompareSharingAnalysis exprs sharingVec rewritten) - - return group "cross-impl simple" ( - test "sharing counts match" (sharingVec.size.toUInt64 == rustSharingCount) ++ - test "sharing vectors match" isMatch - ) - -/-- Test cross-implementation sharing for the content hash collision case. - This verifies both implementations correctly count usages via content hashing. -/ -def testCrossImplContentHash : TestSeq := Id.run do - -- Create "ref 0 #[]" three times with different wrappers - let r1 := Expr.ref 0 #[] - let r2 := Expr.ref 0 #[] - let r3 := Expr.ref 0 #[] - let e1 := Expr.leanAll r1 (Expr.sort 0) - let e2 := Expr.leanAll r2 (Expr.sort 1) - let e3 := Expr.leanAll r3 (Expr.sort 2) - let exprs := #[e1, e2, e3] - - -- Run Lean's sharing analysis - let result := analyzeBlock exprs - let sharedHashes := decideSharing result.infoMap result.topoOrder - let (rewritten, sharingVec) := buildSharingVec exprs sharedHashes result.infoMap result.ptrToHash - - -- Run Rust's sharing analysis via FFI - let rustSharingCount := rsAnalyzeSharingCount exprs - let (isMatch, _leanCount, _rustCount) := unpackSharingComparison (rsCompareSharingAnalysis exprs sharingVec rewritten) - - return group "cross-impl content hash" ( - test "sharing counts match" (sharingVec.size.toUInt64 == rustSharingCount) ++ - test "sharing vectors match" isMatch - ) - -/-- Test cross-implementation sharing for a realistic recursor structure. - This mimics the actual failing case we see in the full test. -/ -def testCrossImplRecursor : TestSeq := Id.run do - -- Build a 3-constructor recursor type - -- Type: ∀ (motive : T → Sort u), minor1 → minor2 → minor3 → ∀ (t : T), motive t - let tRef := Expr.ref 0 #[] -- The inductive type - let c1 := Expr.ref 1 #[] -- Constructor 1 - let c2 := Expr.ref 2 #[] -- Constructor 2 - let c3 := Expr.ref 3 #[] -- Constructor 3 - let sortU := Expr.sort 1 - - -- Build from inside out - let targetBody := Expr.app (Expr.var 1) (Expr.var 0) -- motive t - let target := Expr.leanAll tRef targetBody -- ∀ (t : T), motive t - - let minor3 := Expr.app (Expr.var 3) c3 - let withMinor3 := Expr.leanAll minor3 target - - let minor2 := Expr.app (Expr.var 2) c2 - let withMinor2 := Expr.leanAll minor2 withMinor3 - - let minor1 := Expr.app (Expr.var 1) c1 - let withMinor1 := Expr.leanAll minor1 withMinor2 - - let motiveType := Expr.leanAll tRef sortU - let fullType := Expr.leanAll motiveType withMinor1 - - -- Rules (just return minor arguments) - let rule1 := Expr.var 1 - let rule2 := Expr.var 2 - let rule3 := Expr.var 3 - - let exprs := #[fullType, rule1, rule2, rule3] - - -- Debug: print Rust's view - let _ := rsDebugSharingAnalysis exprs - - -- Run Lean's sharing analysis - let result := analyzeBlock exprs - let sharedHashes := decideSharing result.infoMap result.topoOrder - let (rewritten, sharingVec) := buildSharingVec exprs sharedHashes result.infoMap result.ptrToHash - - -- Run Rust's sharing analysis via FFI - let rustSharingCount := rsAnalyzeSharingCount exprs - let (isMatch, _leanCount, _rustCount) := unpackSharingComparison (rsCompareSharingAnalysis exprs sharingVec rewritten) - - return group "cross-impl recursor" ( - test "sharing counts match" (sharingVec.size.toUInt64 == rustSharingCount) ++ - test "sharing vectors match" isMatch - ) - -/-! ## forall_imp and flip sharing tests -/ - -/-- Test forall_imp sharing using the exact Ixon.Expr structure from compile output. - - From the compile test, forall_imp has this structure (pre-sharing): - Type: all (sort 0) (all (all (var 0) (sort 1)) (all (all (var 1) (sort 1)) - (all (all (var 2) (all (app (var 2) (var 0)) (app (var 2) (var 1)))) - (all (all (var 3) (app (var 3) (var 0))) (all (var 4) (app (var 3) (var 0))))))) - - Value: similar structure with lam instead of all - - Key difference: Lean shares `app (var 2) (var 1)` (8 entries), Rust doesn't (7 entries) --/ -def testForallImpReal : TestSeq := Id.run do - -- Build the forall_imp type structure based on compile output - -- ∀ (α : Sort u), ∀ (p : α → Prop), ∀ (q : α → Prop), - -- ∀ (h : ∀ a, p a → q a), (∀ a, p a) → (∀ a, q a) - -- - -- IMPORTANT: Create fresh objects for each occurrence to simulate real compilation - -- where the same content might have different Lean pointers - - -- Build type with fresh objects - let typ := Expr.leanAll (Expr.sort 0) -- ∀ α : Sort u - (Expr.leanAll (Expr.leanAll (Expr.var 0) (Expr.sort 1)) -- ∀ p : α → Prop (fresh) - (Expr.leanAll (Expr.leanAll (Expr.var 1) (Expr.sort 1)) -- ∀ q : α → Prop (fresh!) - (Expr.leanAll -- ∀ h : ∀ a, p a → q a - (Expr.leanAll (Expr.var 2) - (Expr.leanAll (Expr.app (Expr.var 2) (Expr.var 0)) -- p a → q a - (Expr.app (Expr.var 2) (Expr.var 1)))) - (Expr.leanAll -- (∀ a, p a) → (∀ a, q a) - (Expr.leanAll (Expr.var 3) (Expr.app (Expr.var 3) (Expr.var 0))) -- ∀ a, p a - (Expr.leanAll (Expr.var 4) (Expr.app (Expr.var 3) (Expr.var 0))))))) -- ∀ a, q a - - -- Build value with fresh objects - let value := Expr.leanLam (Expr.sort 0) -- λ α - (Expr.leanLam (Expr.leanAll (Expr.var 0) (Expr.sort 1)) -- λ p : α → Prop (fresh) - (Expr.leanLam (Expr.leanAll (Expr.var 1) (Expr.sort 1)) -- λ q : α → Prop (fresh!) - (Expr.leanLam -- λ h : ∀ a, p a → q a - (Expr.leanAll (Expr.var 2) - (Expr.leanAll (Expr.app (Expr.var 2) (Expr.var 0)) -- p a → q a (fresh) - (Expr.app (Expr.var 2) (Expr.var 1)))) -- (fresh) - (Expr.leanLam -- λ h' : ∀ a, p a - (Expr.leanAll (Expr.var 3) (Expr.app (Expr.var 3) (Expr.var 0))) -- (fresh) - (Expr.leanLam (Expr.var 4) -- λ a : α - (Expr.app - (Expr.app (Expr.var 2) (Expr.var 0)) -- h a - (Expr.app (Expr.var 1) (Expr.var 0)))))))) -- h' a - - let exprs := #[typ, value] - - -- Run Lean sharing analysis - let result := analyzeBlock exprs - let sharedHashes := decideSharing result.infoMap result.topoOrder - let (rewritten, sharingVec) := buildSharingVec exprs sharedHashes result.infoMap result.ptrToHash - - -- Run Rust sharing analysis - let rustCount := rsAnalyzeSharingCount exprs - let (isMatch, _leanCnt, _rustCnt) := unpackSharingComparison (rsCompareSharingAnalysis exprs sharingVec rewritten) - - return group "forall_imp real" ( - test "sharing counts match" (sharingVec.size.toUInt64 == rustCount) ++ - test "sharing vectors match" isMatch - ) - -/-- Test forall_imp sharing difference. - - forall_imp has type: - ∀ (α : Sort u), ∀ (p q : α → Prop), (∀ a, p a → q a) → (∀ a, p a) → (∀ a, q a) - - Key expressions: - - `α → Prop` (appears twice for p and q binder types) - - `app (var N) (var M)` patterns like `p a`, `q a` - - Lean shares both `app (var 2) (var 1)` and `app (var 2) (var 0)` → 8 entries - Rust only shares `app (var 2) (var 0)` → 7 entries - - This tests the profitability calculation difference. --/ -def testForallImpSharing : TestSeq := Id.run do - -- Simplified forall_imp structure focusing on the key pattern - -- The pattern that differs: `all (app var2 var0) (app var2 var1)` - -- appears in the type as `p a → q a` - - -- Create expressions where `app (var 2) (var 1)` and `app (var 2) (var 0)` both appear twice - let app21 := Expr.app (Expr.var 2) (Expr.var 1) - let app20 := Expr.app (Expr.var 2) (Expr.var 0) - - -- Use each twice - let e1 := Expr.leanAll app21 app20 -- p a → q a pattern - let e2 := Expr.leanAll app20 app21 -- q a → p a (reversed) - let e3 := Expr.leanAll (Expr.var 3) e1 -- ∀ a, p a → q a - let e4 := Expr.leanAll (Expr.var 3) e2 -- ∀ a, q a → p a - - let exprs := #[e3, e4] - - -- Analyze with Lean - let result := analyzeBlock exprs - let sharedHashes := decideSharing result.infoMap result.topoOrder - let (rewritten, sharingVec) := buildSharingVec exprs sharedHashes result.infoMap result.ptrToHash - - -- Check usage and profitability of app21 and app20 - let app21Hash := computeExprHash app21 - let app20Hash := computeExprHash app20 - - let app21Info := result.infoMap.get? app21Hash - let app20Info := result.infoMap.get? app20Hash - - let app21Usage := app21Info.map (·.usageCount) |>.getD 0 - let app20Usage := app20Info.map (·.usageCount) |>.getD 0 - - -- Run Rust's sharing analysis via FFI - let rustSharingCount := rsAnalyzeSharingCount exprs - let (isMatch, _leanCount, _rustCount) := unpackSharingComparison (rsCompareSharingAnalysis exprs sharingVec rewritten) - - return group "forall_imp sharing" ( - test "app20 used twice" (app20Usage >= 2) ++ - test "app21 used twice" (app21Usage >= 2) ++ - test "sharing counts match" (sharingVec.size.toUInt64 == rustSharingCount) ++ - test "sharing vectors match" isMatch - ) - -def testFlipSharing : TestSeq := Id.run do - -- Recreate the `flip` function structure - -- Type: ∀ (A : Sort 0), ∀ (B : Sort 1), ∀ (C : Sort 2), (A → B → C) → B → A → C - -- In Ixon.Expr terms: - -- all (sort 0) (all (sort 1) (all (sort 2) (all (all (var 2) (all (var 4) (var 3)))))) - -- where = all (var 2) (all (var 2) (var 2)) - - -- The key subexpression that appears multiple times - let innerAll := Expr.leanAll (Expr.var 2) (Expr.var 2) -- (var 2) → (var 2) - let funcType := Expr.leanAll (Expr.var 2) innerAll -- (var 2) → (var 2) → (var 2) - - -- Build the full type - let resultType := Expr.leanAll (Expr.var 2) (Expr.leanAll (Expr.var 4) (Expr.var 3)) -- B → A → C - let withFunc := Expr.leanAll funcType resultType -- (A → B → C) → B → A → C - let withC := Expr.leanAll (Expr.sort 2) withFunc - let withB := Expr.leanAll (Expr.sort 1) withC - let typ := Expr.leanAll (Expr.sort 0) withB - - -- Value: λ A B C f b a => f a b - -- In Ixon.Expr terms: lam ... lam (app (app (var 2) (var 0)) (var 1)) - let body := Expr.app (Expr.app (Expr.var 2) (Expr.var 0)) (Expr.var 1) -- f a b - let lamA := Expr.leanLam (Expr.var 4) body - let lamB := Expr.leanLam (Expr.var 2) lamA - let lamFunc := Expr.leanLam funcType lamB -- Note: funcType appears again here! - let lamC := Expr.leanLam (Expr.sort 2) lamFunc - let lamBSort := Expr.leanLam (Expr.sort 1) lamC - let value := Expr.leanLam (Expr.sort 0) lamBSort - - let exprs := #[typ, value] - - -- Analyze with Lean - let result := analyzeBlock exprs - let sharedHashes := decideSharing result.infoMap result.topoOrder - let (rewritten, sharingVec) := buildSharingVec exprs sharedHashes result.infoMap result.ptrToHash - - -- Check what got shared - let innerAllHash := computeExprHash innerAll - let funcTypeHash := computeExprHash funcType - - let innerAllInfo := result.infoMap.get? innerAllHash - let funcTypeInfo := result.infoMap.get? funcTypeHash - - let innerAllUsage := innerAllInfo.map (·.usageCount) |>.getD 0 - let funcTypeUsage := funcTypeInfo.map (·.usageCount) |>.getD 0 - - -- Run Rust's sharing analysis via FFI - let rustSharingCount := rsAnalyzeSharingCount exprs - let (isMatch, _leanCount, _rustCount) := unpackSharingComparison (rsCompareSharingAnalysis exprs sharingVec rewritten) - - return group "flip sharing" ( - test "funcType used twice" (funcTypeUsage >= 2) ++ - test "innerAll used multiple times" (innerAllUsage >= 2) ++ - test "sharing counts match" (sharingVec.size.toUInt64 == rustSharingCount) ++ - test "sharing vectors match" isMatch - ) - -/-! ## Suite -/ - -public def suite : List TestSeq := [ - testForallImpReal, - testForallImpSharing, - testUint64ToBytesLength, - testUint64ToBytesEncoding, - testHashConsistency, - testHashDifferent, - testSortHashBuffer, - testVarHashBuffer, - testAppHashBuffer, - testNoSharing, - testWithSharing, - testSharingTopoOrder, - testKnownHashVar0, - testKnownHashSort0, - testRecursorSharing, - testRealisticRecursor, - testContentHashCollision, - testCrossImplSharingSimple, - testCrossImplContentHash, - testCrossImplRecursor, - testFlipSharing, -] - -end Tests.Sharing diff --git a/Tests/Ix/SharingExact.lean b/Tests/Ix/SharingExact.lean new file mode 100644 index 000000000..9d1cb0526 --- /dev/null +++ b/Tests/Ix/SharingExact.lean @@ -0,0 +1,1214 @@ +/- + Tests for the exact minimum sharing core (`Ix.Sharing.Exact`; specified in + `docs/sharing-minimum.md`). + + Groups: + * exact serializer lengths vs the production writer (integer widths, + telescope boundaries, Share widths, complete-Constant decomposition); + * structural IDs vs an independent naive implementation, representation + independence, bounded expansion and its failure modes, root API; + * the fixed-dictionary optimizer vs exhaustive enumeration in arbitrary + dictionary orders and at every Share width boundary; + * the full optimizer vs the exhaustive oracle (full key), vs a unit-width + relaxation oracle, vs a brute force over independent atoms; + * the §2 fixtures byte for byte; + * size ≤ unshared / another encoding, idempotence, and resource limits. + + Generated inputs use a fixed-seed splitmix64 generator, so every failure + is reproducible from the printed seed and case index. +-/ +module + +public import Ix.Sharing.Exact +public import Ix.Ixon +public import Ix.CompileM +public import LSpec +public import Tests.Gen.Ixon + +public section + +open LSpec Ixon Ix.Sharing.Exact + +-- Test groups are functions run from deferred IO actions; keep their closed +-- bodies from being hoisted into constants evaluated at program start. +set_option compiler.extract_closed false + +namespace Tests.SharingExact + +/-! ## Helpers -/ + +def hexOf (b : ByteArray) : String := + let d := "0123456789abcdef".toList.toArray + String.join (b.toList.map fun x => String.ofList [d[x.toNat / 16]!, d[x.toNat % 16]!]) + +def P : Ixon.Expr := .sort 0 + +/-- Ordinary non-dependent arrow `a → b` with default contracts. -/ +def arr (a b : Ixon.Expr) : Ixon.Expr := .all .many .shared a b + +/-- `Tn = Prop → … → Prop` with `n` binders. -/ +def chain : Nat → Ixon.Expr + | 0 => P + | n + 1 => arr P (chain n) + +def axiomOf (typ : Ixon.Expr) (univs : Array Univ := #[.zero]) : Constant := + { info := .axio { isUnsafe := false, lvls := 0, typ }, sharing := #[], refs := #[], univs } + +/-- Another valid shared encoding of `c` (the uniform-width construction at +`w = 1`): an input representation that differs from the canonical one. -/ +def alternateOf (c : Constant) : Constant := + (normalizeConstantSharingUniform 1 c).toOption.getD c + +/-- Little-endian bytes of a `UInt64`. -/ +def u64LE (x : UInt64) : ByteArray := + ByteArray.mk ((Array.range 8).map fun i => (x >>> (8 * i).toUInt64).toUInt8) + +def cbytes (c : Constant) : Nat := (serConstant c).size + +def withOk {α} (name : String) (x : Except SharingError α) (k : α → TestSeq) : TestSeq := + match x with + | .ok a => k a + | .error e => test s!"{name}: unexpected error {reprStr e}" false + +def isErr {α} (x : Except SharingError α) (p : SharingError → Bool) : Bool := + match x with + | .ok _ => false + | .error e => p e + +def exhausted (r : Resource) : SharingError → Bool + | .resourceExhausted r' _ => r' == r + | _ => false + +def expandRoots (roots : Array Ixon.Expr) : Except SharingError Expanded := + expand {} #[] roots false + +def distinctCount (roots : Array Ixon.Expr) : Nat := + match expandRoots roots with + | .ok ex => ex.dag.size + | .error _ => 0 + +/-! ## Deterministic generator (splitmix64) -/ + +structure Rng where + state : UInt64 + +def Rng.next (r : Rng) : UInt64 × Rng := + let s := r.state + 0x9E3779B97F4A7C15 + let z := (s ^^^ (s >>> 30)) * 0xBF58476D1CE4E5B9 + let z := (z ^^^ (z >>> 27)) * 0x94D049BB133111EB + (z ^^^ (z >>> 31), ⟨s⟩) + +abbrev RGen := StateM Rng + +def rand (n : Nat) : RGen Nat := do + let (x, r) := (← get).next + set r + return if n == 0 then 0 else x.toNat % n + +def runGen {α} (seed : Nat) (g : RGen α) : α := (g.run ⟨seed.toUInt64⟩).1 + +def genBinder : RGen BinderContract := do + if (← rand 3) != 0 then return .many + let uses := #[Uses.erased, .linear, .affine, .many][← rand 4]! + let owned := #[Owned.unique, .shared][← rand 2]! + let loc := #[Locality.unrestricted, .local][← rand 2]! + return ⟨uses, ⟨owned, loc⟩⟩ + +def genValue : RGen ValueContract := do + if (← rand 3) != 0 then return .shared + return ⟨#[Owned.unique, .shared][← rand 2]!, #[Locality.unrestricted, .local][← rand 2]!⟩ + +def genLet : RGen LetContract := do + let nonDep := (← rand 2) == 0 + let kind := if (← rand 3) == 0 then LetKind.borrowShared else .value + return ⟨nonDep, kind, ← genBinder⟩ + +def genLeaf : RGen Ixon.Expr := do + match ← rand 12 with + | 0 => return .sort (#[0, 1, 300][← rand 3]!) + | 1 => return .var (#[0, 1, 9][← rand 3]!) + | 2 => return .ref (← rand 2).toUInt64 (#[#[], #[0], #[0, 1]][← rand 3]!) + | 3 => return .recur 0 #[] + | 4 => return .str (← rand 2).toUInt64 + | 5 => return .nat 1 + | 6 => return .ref 1 #[] + | 7 => return .sort 0 + | 8 => return .var 1 + | _ => return .var 0 + +def isApp : Ixon.Expr → Bool | .app .. => true | _ => false +def isLam : Ixon.Expr → Bool | .lam .. => true | _ => false +def isAll : Ixon.Expr → Bool | .all .. => true | _ => false + +/-- A node over pool elements; with `noMerge` no telescope can merge. -/ +def genNode (pool : Array Ixon.Expr) (noMerge : Bool := false) : RGen Ixon.Expr := do + let c := pool[← rand pool.size]! + let d := pool[← rand pool.size]! + let e := pool[← rand pool.size]! + match ← rand 7 with + | 0 | 1 => + if noMerge && isApp c then return .prj 0 0 c else return .app c d + | 2 => + if noMerge && isLam d then return .prj 1 2 d else return .lam (← genBinder) c d + | 3 | 4 => + if noMerge && isAll d then return .prj 0 1 d else return .all (← genBinder) (← genValue) c d + | 5 => return .prj (← rand 2).toUInt64 (← rand 3).toUInt64 c + | _ => return .letE (← genLet) c d e + +/-- Roots built from a pool, so subterms repeat. -/ +def genRoots (leaves nodes roots : Nat) (noMerge : Bool := false) : RGen (Array Ixon.Expr) := do + let mut pool : Array Ixon.Expr := #[] + for _ in [0:1 + (← rand leaves)] do pool := pool.push (← genLeaf) + for _ in [0:(← rand (nodes + 1))] do pool := pool.push (← genNode pool noMerge) + let mut out : Array Ixon.Expr := #[] + for _ in [0:1 + (← rand roots)] do + let i ← if (← rand 3) == 0 then rand pool.size + else do pure (pool.size - 1 - (← rand (min 3 pool.size))) + out := out.push pool[i]! + return out + +def testRefs : Array Address := #[Address.blake3 ⟨#[1]⟩, Address.blake3 ⟨#[2]⟩] +def testUnivs : Array Univ := #[.zero, .succ .zero] + +/-- Wrap roots in a ConstantInfo of a kind selected by the root count. -/ +def wrapRoots (roots : Array Ixon.Expr) (sel : Nat) : Constant := + let info : ConstantInfo := match roots.size with + | 0 => .iPrj ⟨0, testRefs[0]!⟩ + | 1 => if sel % 2 == 0 then .axio ⟨false, 0, roots[0]!⟩ else .quot ⟨.type, 0, roots[0]!⟩ + | 2 => .defn ⟨.defn, .safe, 0, roots[0]!, roots[1]!⟩ + | _ => + if sel % 2 == 0 then + .recr ⟨false, false, 0, 0, 0, 0, 0, roots[0]!, + (roots.extract 1 roots.size).map fun rhs => ⟨0, rhs⟩⟩ + else + let ctors := (roots.extract 3 roots.size).map fun t => ⟨false, 0, 0, 0, 0, t⟩ + .muts #[.defn ⟨.defn, .safe, 0, roots[0]!, roots[1]!⟩, + .indc ⟨false, 0, 0, 0, roots[2]!, ctors⟩] + { info, sharing := #[], refs := testRefs, univs := testUnivs } + +/-! ## Independent references used by the tests -/ + +def exprChildren : Ixon.Expr → List Ixon.Expr + | .prj _ _ v => [v] + | .app f a => [f, a] + | .lam _ t b => [t, b] + | .all _ _ t b => [t, b] + | .letE _ t v b => [t, v, b] + | _ => [] + +partial def exprHeight (e : Ixon.Expr) : Nat := + (exprChildren e).foldl (fun acc c => max acc (exprHeight c + 1)) 0 + +partial def allSubterms (e : Ixon.Expr) : List Ixon.Expr := + e :: (exprChildren e).flatMap allSubterms + +/-- §3.2 tag, restated from the table. -/ +def exprTag : Ixon.Expr → Nat + | .sort _ => 0 | .var _ => 1 | .ref .. => 2 | .recur .. => 3 | .prj .. => 4 + | .str _ => 5 | .nat _ => 6 | .app .. => 7 | .lam .. => 8 | .all .. => 9 + | .letE .. => 10 | .share _ => 11 + +/-- §3.2 scalar vector, restated from the table. -/ +def exprScalars : Ixon.Expr → List Nat + | .sort i | .var i | .str i | .nat i => [i.toNat] + | .ref r us | .recur r us => [r.toNat, us.size] ++ us.toList.map (·.toNat) + | .prj t f _ => [t.toNat, f.toNat] + | .app .. => [] + | .lam c .. => [c.toBits.toNat] + | .all c r .. => [(packAllContract c r).toNat] + | .letE c .. => [c.flags.toNat, c.binder.toBits.toNat] + | .share i => [i.toNat] + +def cmpNats : List Nat → List Nat → Ordering + | [], [] => .eq + | [], _ => .lt + | _, [] => .gt + | x :: xs, y :: ys => if x < y then .lt else if y < x then .gt else cmpNats xs ys + +/-- Naive canonical order: distinct subterms by structural `==`, grouped by +height, sorted by `(tag, scalars, child positions)`. -/ +def naiveCanonical (roots : Array Ixon.Expr) : Array Ixon.Expr := Id.run do + let mut distinct : Array Ixon.Expr := #[] + for r in roots do + for s in allSubterms r do + if !distinct.contains s then distinct := distinct.push s + let maxH := distinct.foldl (fun acc e => max acc (exprHeight e)) 0 + let mut out : Array Ixon.Expr := #[] + for h in [0:maxH + 1] do + let level := distinct.filter (exprHeight · == h) + let placed := out + -- Tag, then scalars, then child positions (all lexicographic). + let cmp (a b : Ixon.Expr) : Ordering := + match cmpNats [exprTag a] [exprTag b] with + | .eq => match cmpNats (exprScalars a) (exprScalars b) with + | .eq => cmpNats ((exprChildren a).map fun c => (placed.findIdx? (· == c)).getD 0) + ((exprChildren b).map fun c => (placed.findIdx? (· == c)).getD 0) + | o => o + | o => o + out := out ++ level.qsort fun a b => cmp a b == .lt + return out + +/-- Direct substitution of a backward-reference table. -/ +partial def naiveExpand (table : Array Ixon.Expr) : Ixon.Expr → Ixon.Expr + | .share j => naiveExpand (table.extract 0 j.toNat) table[j.toNat]! + | .prj t f v => .prj t f (naiveExpand table v) + | .app f a => .app (naiveExpand table f) (naiveExpand table a) + | .lam c t b => .lam c (naiveExpand table t) (naiveExpand table b) + | .all c r t b => .all c r (naiveExpand table t) (naiveExpand table b) + | .letE c t v b => .letE c (naiveExpand table t) (naiveExpand table v) (naiveExpand table b) + | e => e + +/-! ## Integer widths and exact lengths -/ + +def boundaryValues : List Nat := + [0, 1, 7, 8, 127, 128, 255, 256, 65535, 65536, 2^24 - 1, 2^24, 2^32 - 1, 2^32, + 2^40 - 1, 2^40, 2^48 - 1, 2^48, 2^56 - 1, 2^56, 2^64 - 1] ++ + ([0, 2, 4].flatMap fun f => + [tagNEnd1 f, tagNEnd2 f, tagNEnd3 f, tagNEnd4 f, tagNEnd5 f].flatMap fun e => + [e - 1, e, e + 1]) + +def widthTests (_ : Unit) : TestSeq := + group "integer widths" <| + test "tag0Size = putTagN 0 length at every rung boundary" + (boundaryValues.all fun n => tag0Size n == (runPut (putTagN 0 0 n.toUInt64)).size) ++ + test "tag4Size = putTagN 4 length at every rung boundary" + (boundaryValues.all fun n => + [0x7, 0x8, 0x9, 0xB].all fun (f : UInt8) => + tag4Size n == (runPut (putTagN 4 f n.toUInt64)).size) ++ + test "shareWidth = serialized Share length at every boundary" + (boundaryValues.all fun n => + shareWidth n == (serExpr (.share n.toUInt64)).size && + exprSize (.share n.toUInt64) == shareWidth n) ++ + test "Share 7/8 → 1/2 bytes" (shareWidth 7 == 1 && shareWidth 8 == 2) ++ + test "Share 1031/1032 → 2/3 bytes" (shareWidth 1031 == 2 && shareWidth 1032 == 3) ++ + test "Share 66567/66568 → 3/4 bytes" (shareWidth 66567 == 3 && shareWidth 66568 == 4) ++ + test "Share 16843783/16843784 → 4/5 bytes" + (shareWidth 16843783 == 4 && shareWidth 16843784 == 5) ++ + test "Share 4311811079/4311811080 → 5/9 bytes" + (shareWidth 4311811079 == 5 && shareWidth 4311811080 == 9) ++ + test "Share 2^64-1 → 9 bytes" (shareWidth (2^64 - 1) == 9) ++ + test "TagN f=0 127/128 → 1/2 bytes, 16511/16512 → 2/3, 82047/82048 → 3/4, 16859263/16859264 → 4/5" + (tag0Size 127 == 1 && tag0Size 128 == 2 && tag0Size 16511 == 2 && tag0Size 16512 == 3 && + tag0Size 82047 == 3 && tag0Size 82048 == 4 && tag0Size 16859263 == 4 && + tag0Size 16859264 == 5) ++ + test "tag0BracketStart is the start of the count's TagN rung" + (boundaryValues.all fun k => + tag0Size (tag0BracketStart k) == tag0Size k && + (tag0BracketStart k == 0 || tag0Size (tag0BracketStart k - 1) < tag0Size k)) ++ + test "tag0StepBound bounds the growth of the count's TagN width" + ((boundaryValues.all fun n => + n == 0 || decide (tag0Size n - tag0Size (n - 1) ≤ tag0StepBound n)) && + tag0StepBound 82048 == 1 && tag0StepBound (tagNEnd5 0 - 1) == 1 && + tag0StepBound (tagNEnd5 0) == 4) + +/-- App spine with `n` arguments, Lam/All telescopes with `n` binders, and +mixed nestings. -/ +def telescopeExprs : List Ixon.Expr := Id.run do + let mut out : List Ixon.Expr := [] + for n in [1, 2, 7, 8, 9, 255, 256, 257] do + let app := (List.range n).foldl (fun f i => .app f (.var (i % 3).toUInt64)) (.ref 0 #[]) + let lam := (List.range n).foldl (fun b i => .lam (if i % 2 == 0 then .many else .linear) (.sort 0) b) (.var 0) + let all := (List.range n).foldl (fun b _ => arr (.var 1) b) (.sort 1) + out := out ++ [app, lam, all, .app lam app, .lam .many all lam, arr app (.share 300), + .app (.share 8) app, .letE (.lean true) app lam all, .prj 3 9 app, arr (.share 7) all] + return out + +def genExprForSize : RGen Ixon.Expr := do + let roots ← genRoots 4 8 1 + let e := roots[0]! + -- Sprinkle Shares with boundary indices. + let idx := [0, 7, 8, 255, 256, 65535, 65536, 2^32, 2^64 - 1][← rand 9]! + match ← rand 4 with + | 0 => return .app e (.share idx.toUInt64) + | 1 => return arr (.share idx.toUInt64) e + | 2 => return .lam .many e (.share idx.toUInt64) + | _ => return e + +def exprSizeTests (_ : Unit) : TestSeq := + let gen := runGen 7 ((List.range 2000).mapM fun _ => genExprForSize) + group "exact expression length" <| + test "exprSize = serExpr size on telescope boundaries (1/2/7/8/9/255/256/257)" + (telescopeExprs.all fun e => exprSize e == (serExpr e).size) ++ + test "exprSize = serExpr size on 2000 generated expressions with boundary Shares" + (gen.all fun e => exprSize e == (serExpr e).size) ++ + test "App with 7/8 args uses 1/2 header bytes" + (let a7 := (List.range 7).foldl (fun f _ => .app f (.var 0)) (.var 1) + let a8 := Ixon.Expr.app a7 (.var 0) + (serExpr a7).size == 1 + 8 && (serExpr a8).size == 2 + 9) + +/-- A table of `k` entries: entry `i` is `Var i` (so entries are distinct), +and roots reference the last entries. -/ +def tableConstant (info : ConstantInfo) (k : Nat) : Constant := + { info, sharing := (Array.range k).map fun i => .var i.toUInt64, refs := testRefs, + univs := testUnivs } + +def decompositionHolds (c : Constant) : Bool := + cbytes c == fixedConstantBytes c + exprsSize (constantInfoRoots c.info) + + tag0Size c.sharing.size + exprsSize c.sharing + +def decompositionTests (_ : Unit) : TestSeq := + let mkRoots (k : Nat) (n : Nat) : Array Ixon.Expr := + (Array.range n).map fun i => .app (.share (k - 1 - i % (max k 1)).toUInt64) (.var i.toUInt64) + let infos (rs : Array Ixon.Expr) : List ConstantInfo := + [ .defn ⟨.defn, .safe, 0, rs[0]!, rs[1]!⟩, .axio ⟨false, 1, rs[0]!⟩, + .quot ⟨.lift, 2, rs[0]!⟩, + .recr ⟨true, false, 1, 2, 3, 4, 5, rs[0]!, #[⟨1, rs[1]!⟩, ⟨300, rs[2]!⟩]⟩, + .cPrj ⟨1, 2, testRefs[0]!⟩, .rPrj ⟨3, testRefs[1]!⟩, .iPrj ⟨200, testRefs[0]!⟩, + .dPrj ⟨0, testRefs[1]!⟩, + .muts #[.defn ⟨.thm, .part, 0, rs[0]!, rs[1]!⟩, + .indc ⟨true, 1, 1, 0, rs[2]!, #[⟨false, 1, 0, 1, 2, rs[3]!⟩, ⟨false, 1, 1, 1, 0, rs[0]!⟩]⟩, + .recr ⟨false, true, 0, 0, 0, 0, 0, rs[1]!, #[⟨2, rs[2]!⟩]⟩] ] + let cases := [0, 1, 8, 9, 127, 128, 255, 256, 257, 1032, 1033].flatMap fun k => + (infos (mkRoots k 4)).map fun info => tableConstant info k + group "complete-Constant length decomposition" <| + test s!"serConstant size = fixed + roots + tag0(table) + table on {cases.length} constants (all kinds; tables 0/1/8/9/127/128/255/256/257/1032/1033)" + (cases.all decompositionHolds) ++ + test "Share 7/8 and 1031/1032 have widths 1/2 and 2/3" + (exprSize (.share 7) == 1 && exprSize (.share 8) == 2 && + exprSize (.share 1031) == 2 && exprSize (.share 1032) == 3) + +/-! ## Structural IDs, expansion and roots -/ + +def fixtureA : Ixon.Expr := arr P P +def fixtureB : Ixon.Expr := arr P (.sort 1) +def twoMinimaRoot : Ixon.Expr := arr fixtureA (arr fixtureA (arr fixtureB fixtureB)) + +def structuralIdTests (_ : Unit) : TestSeq := + let naiveAgree := runGen 11 do + let mut ok := true + for _ in [0:300] do + let roots ← genRoots 5 10 3 + match expandRoots roots with + | .ok ex => + let naive := naiveCanonical roots + let rootIdx := roots.map fun r => (naive.findIdx? (· == r)).getD 1000000 + ok := ok && ex.dag.toExprs == naive && ex.roots == rootIdx + | .error _ => ok := false + return ok + group "structural IDs" <| + withOk "two-minima fixture" (expandRoots #[twoMinimaRoot]) (fun ex => + test "ids: Sort0=0 Sort1=1 A=2 B=3 (B→B)=4 (A→B→B)=5 root=6" + (ex.dag.toExprs == #[P, .sort 1, fixtureA, fixtureB, arr fixtureB fixtureB, + arr fixtureA (arr fixtureB fixtureB), twoMinimaRoot] && ex.roots == #[6])) ++ + withOk "witness" (expandRoots #[arr (chain 2) (chain 2)]) (fun ex => + test "ids: P=0 T1=1 T2=2 R=3" (ex.dag.toExprs == #[P, chain 1, chain 2, + arr (chain 2) (chain 2)])) ++ + test "canonical IDs equal an independent naive assignment on 300 generated inputs" + naiveAgree ++ + test "contracts are part of structural identity" + (distinctCount #[.lam .many P P, .lam .linear P P, .all .many .shared P P, + .all .many .unique P P, .letE (.lean true) P P P, .letE (.lean false) P P P] == 7) ++ + test "lexCompare: proper prefix first, then numeric" + (lexCompare [1] [1, 0] == .lt && lexCompare [] [0] == .lt && + lexCompare [2] [10] == .lt && lexCompare [1, 0] [1] == .gt) ++ + test "compareBytes: unsigned, proper prefix first" + (compareBytes ⟨#[0x7f]⟩ ⟨#[0x80]⟩ == .lt && compareBytes ⟨#[1]⟩ ⟨#[1, 0]⟩ == .lt && + compareBytes ⟨#[0xff]⟩ ⟨#[0x00, 0x00]⟩ == .gt) + +/-- The same AST in three pointer layouts: generated (pool-shared), fresh +(deserialized, no sharing), and maximally shared (from the DAG). -/ +def representationTests (_ : Unit) : TestSeq := + let ok := runGen 13 do + let mut ok := true + for i in [0:120] do + let roots ← genRoots 5 10 3 + let c := wrapRoots roots i + let fresh := match deConstant (serConstant c) with + | .ok c' => c' + | .error _ => c + let dagShared := match expandConstantSharing c with + | .ok c' => c' + | .error _ => c + let alt := alternateOf c + let outs := [c, fresh, dagShared, alt].map fun x => + (normalizeConstantSharing x).toOption.map serConstant + let tiered := [c, fresh, dagShared, alt].map fun x => + (normalizeConstantSharingTiered .tagN x).toOption.map serConstant + ok := ok && outs.all (· == outs.head!) && outs.head!.isSome && + tiered.all (· == tiered.head!) && tiered.head!.isSome + return ok + group "representation independence" <| + test "pool-shared, deserialized, DAG-shared and uniform-w1-encoded inputs normalize to identical bytes, by the exact search and by the tiered construction (120 inputs)" ok + +def expansionTests (_ : Unit) : TestSeq := + let chainTable (k : Nat) : Array Ixon.Expr := + #[.var 0] ++ (Array.range (k - 1)).map fun i => .app (.share i.toUInt64) (.var 0) + let validTables := runGen 17 do + let mut ok := true + for _ in [0:100] do + -- A random valid backward table: entry i is a node over earlier Shares and leaves. + let k := 1 + (← rand 6) + let mut table : Array Ixon.Expr := #[] + for i in [0:k] do + let pick : RGen Ixon.Expr := do + if i > 0 && (← rand 2) == 0 then pure (.share (← rand i).toUInt64) else genLeaf + table := table.push (← genNode #[← pick, ← pick, ← pick]) + let roots := #[Ixon.Expr.app (.share (k - 1).toUInt64) (.share 0), .share (← rand k).toUInt64] + let info : ConstantInfo := .defn ⟨.defn, .safe, 0, roots[0]!, roots[1]!⟩ + let c : Constant := { info, sharing := table, refs := #[], univs := #[] } + match expandConstantSharing c with + | .ok c' => ok := ok && constantInfoRoots c'.info == roots.map (naiveExpand table) + | .error _ => ok := false + return ok + group "bounded share expansion" <| + test "expansion equals direct substitution on 100 random backward tables" validTables ++ + test "forward reference is rejected" + (isErr (optimizeSharingTable #[.share 1, P] #[.share 0]) + (· == .nonBackwardShare 0 1)) ++ + test "self reference is rejected" + (isErr (optimizeSharingTable #[.app (.share 0) P] #[.share 0]) + (· == .nonBackwardShare 0 0)) ++ + test "out-of-range root reference is rejected" + (isErr (optimizeSharingTable #[] #[.share 3]) (· == .shareOutOfRange none 3 0)) ++ + test "re-expanding the DAG's own roots gives their IDs; an encoding of another term (the fast path's fallback) gives it a fresh ID" + (match expandRoots #[arr (chain 2) (chain 2)] with + | .ok ex => + (reexpand {} ex.dag #[] #[arr (chain 2) (chain 2)]).toOption.map (·.2.1) == some ex.roots && + ((reexpand {} ex.dag #[] #[arr (chain 3) (chain 3)]).toOption.map + fun r => r.2.1.all (· ≥ ex.dag.size)) == some true + | .error _ => false : Bool) ++ + test "out-of-range entry reference is rejected" + (isErr (optimizeSharingTable #[.share 5] #[P]) (· == .shareOutOfRange (some 0) 5 1)) ++ + test "Share in an expanded-root input is rejected" + (isErr (optimizeSharing #[P, .share 0]) (· == .shareInExpandedInput 1 0)) ++ + test "stored depth limit" + (isErr (optimizeSharing #[chain 20] { maxDepth := 10 }) (exhausted .depth)) ++ + test "expanded height limit (shallow entries, deep expansion)" + (isErr (optimizeSharingTable (chainTable 40) #[.share 39] { maxDepth := 20 }) + (exhausted .depth)) ++ + test "distinct-node limit" + (isErr (optimizeSharing #[chain 30] { maxNodes := 10 }) (exhausted .nodes)) ++ + test "walk limit" + (isErr (optimizeSharing #[chain 30] { maxExprVisits := 10 }) (exhausted .exprVisits)) ++ + test "unreachable entries do not affect the result" + (let c := axiomOf (arr (chain 2) (chain 2)) + let garbage : Constant := { c with + info := .axio ⟨false, 0, arr (.share 2) (.share 2)⟩, + sharing := #[.var 7, arr P P, arr P (.share 1), .app (.var 3) (.share 0)] } + (normalizeConstantSharing garbage).toOption.map serConstant == + (normalizeConstantSharing c).toOption.map serConstant) + +def sampleInfos : List ConstantInfo := + let e (i : Nat) : Ixon.Expr := .var i.toUInt64 + [ .defn ⟨.defn, .safe, 0, e 0, e 1⟩, .axio ⟨false, 0, e 2⟩, .quot ⟨.ind, 0, e 3⟩, + .recr ⟨false, false, 0, 0, 0, 0, 0, e 4, #[⟨0, e 5⟩, ⟨1, e 6⟩]⟩, + .recr ⟨false, false, 0, 0, 0, 0, 0, e 4, #[]⟩, + .cPrj ⟨0, 0, testRefs[0]!⟩, .rPrj ⟨0, testRefs[0]!⟩, .iPrj ⟨0, testRefs[0]!⟩, + .dPrj ⟨0, testRefs[0]!⟩, + .muts #[.defn ⟨.defn, .safe, 0, e 7, e 8⟩, + .indc ⟨false, 0, 0, 0, e 9, #[⟨false, 0, 0, 0, 0, e 10⟩, ⟨false, 0, 1, 0, 0, e 11⟩]⟩, + .indc ⟨false, 0, 0, 0, e 12, #[]⟩, + .recr ⟨false, false, 0, 0, 0, 0, 0, e 13, #[⟨0, e 14⟩]⟩], + .muts #[] ] + +def rootApiTests (_ : Unit) : TestSeq := + let shift (rs : Array Ixon.Expr) := rs.map fun r => Ixon.Expr.app r (.var 99) + group "root extraction and reassembly" <| + test "constantInfoRoots = Ix.CompileM.constantInfoRootExprs on every kind" + (sampleInfos.all fun i => constantInfoRoots i == Ix.CompileM.constantInfoRootExprs i) ++ + test "withRoots consumes exactly the extracted roots in order" + (sampleInfos.all fun i => + let rs := shift (constantInfoRoots i) + match withRoots i rs with + | .ok i' => constantInfoRoots i' == rs && (withRoots i' (constantInfoRoots i)).toOption == some i + | .error _ => false) ++ + test "mapRoots f info = withRoots info ((constantInfoRoots info).map f) on every kind" + (sampleInfos.all fun i => + let g := fun r => Ixon.Expr.app r (.var 98) + (withRoots i ((constantInfoRoots i).map g)).toOption == some (mapRoots g i)) ++ + test "withRoots rejects one root too many / too few" + (sampleInfos.all fun i => + let rs := constantInfoRoots i + isErr (withRoots i (rs.push P)) (· == .rootCountMismatch rs.size (rs.size + 1)) && + (rs.size == 0 || isErr (withRoots i rs.pop) (· == .rootCountMismatch rs.size (rs.size - 1)))) + +/-! ## Fixed-dictionary optimizer vs enumeration (P2) -/ + +/-- Every ordered dictionary over the DAG's terms (up to `maxOrders`), with +table indices shifted by each offset so Share widths cross every boundary; +checks `C_M` and the materialized bytes against exhaustive enumeration. -/ +def dictionaryAgreement (dag : Dag) (offsets : List Nat) (maxOrders : Nat) (stride : Nat := 1) : + Nat × Option String := Id.run do + let p := Prep.ofDag dag + let n := dag.size + let mut checked := 0 + let orders := ((orderedSubsets n (List.range n)).zipIdx.filter fun (_, i) => i % stride == 0).map (·.1) + for order in orders.take maxOrders do + for off in offsets do + let index := indexOfPairs n (order.zipIdx.map fun (t, i) => (t, i + off)) + match p.materialize index (Array.range n) {} with + | .error e => return (checked, some s!"materialize error {reprStr e} order={order} off={off}") + | .ok (exprs, cost, _) => + for t in [0:n] do + match (bestPart dag index {} t).run {} with + | .error e => return (checked, some s!"enumeration error {reprStr e}") + | .ok ((_, bytes), _) => + checked := checked + 1 + unless cost[t]! == bytes.size && serExpr exprs[t]! == bytes do + return (checked, some s!"order={order} off={off} term={t} C_M={cost[t]!} enum={bytes.size} got={hexOf (serExpr exprs[t]!)} want={hexOf bytes}") + return (checked, none) + +def dictOffsets : List Nat := [0, 5, 250, 65530, 2^24 - 3, 2^32 - 3, 2^56 - 3, 2^64 - 8] + +/-- Reference `C_M`: for every telescope node, walk every inline prefix +length `j = 1..l` directly (quadratic in the spine length). -/ +def walkCosts (dag : Dag) (width : Array (Option Nat)) : Array Nat := Id.run do + let mut cost : Array Nat := Array.replicate dag.size 0 + for t in [0:dag.size] do + let node := dag.node t + let fam := node.head.family + let mut inl := 0 + if fam == .none then + inl := node.children.foldl (fun acc c => acc + cost[c]!) node.head.ownBytes + else + let mut l := 0 + let mut cur := t + for _ in [0:dag.size] do + if (dag.node cur).head.family == fam then + l := l + 1 + cur := (dag.node cur).spineNext + else break + cur := t + let mut sides := 0 + let mut best : Option Nat := none + for j in [1:l + 1] do + let cn := dag.node cur + sides := sides + cn.sideExtra + cost[cn.sideChild]! + let nxt := cn.spineNext + let cand? : Option Nat := + if j < l then (width[nxt]!).map fun w => tag4Size j + sides + w + else some (tag4Size j + sides + cost[nxt]!) + if let some cand := cand? then + best := some (match best with | some b => min b cand | none => cand) + cur := nxt + inl := best.getD 0 + cost := cost.set! t (match width[t]! with | some w => min inl w | none => inl) + return cost + +/-- Long spines over a small pool: App spines, Lam and All telescopes with +mixed contracts, nested in each other. -/ +def genSpines : RGen (Array Ixon.Expr) := do + let pool ← (List.range 4).toArray.mapM fun _ => genLeaf + let mut roots : Array Ixon.Expr := #[] + for _ in [0:1 + (← rand 3)] do + let len := 5 + (← rand 40) + let mut e := pool[← rand pool.size]! + for _ in [0:len] do + let a := pool[← rand pool.size]! + e ← match ← rand 5 with + | 0 | 1 => pure (.app e a) + | 2 => do pure (.lam (← genBinder) a e) + | 3 => do pure (.all (← genBinder) (← genValue) a e) + | _ => pure (arr a e) + roots := roots.push e + roots := roots.push (.app e e) + return roots + +def spineWalkTests (_ : Unit) : TestSeq := + let (checked, err) := runGen 53 do + let mut checked := 0 + let mut err : Option String := none + for i in [0:200] do + if err.isSome then break + let roots ← genSpines + match expandRoots roots with + | .ok ex => + let n := ex.dag.size + let p := Prep.ofDag ex.dag + let mut width : Array (Option Nat) := Array.replicate n none + for t in [0:n] do + if (← rand 3) == 0 then + let idx := [← rand 8, 8 + (← rand 300), 65530 + (← rand 12), 2^32 + (← rand 3)][← rand 4]! + width := width.set! t (some (shareWidth idx)) + checked := checked + 1 + unless (p.costsAll width).1 == walkCosts ex.dag width && + p.base == walkCosts ex.dag (Array.replicate n none) do + err := some s!"case {i}: available-descendant evaluation differs from the full spine walk" + | .error e => err := some s!"case {i}: error {reprStr e}" + return (checked, err) + group "telescope evaluation vs full spine walk" <| + test s!"{checked} long-spine DAGs with random dictionaries (widths 1–5): costs equal the O(l) walk over every cut" (err.isNone && checked == 200) ++ + (match err with | some m => test m false | none => .done) + +def deepTests (_ : Unit) : TestSeq := + let d := 10000 + let nested : Ixon.Expr := + (List.range d).foldl (fun acc i => .app (.var (i % 2).toUInt64) acc) (.sort 0) + let telescope : Ixon.Expr := + (List.range d).foldl (fun acc i => .lam .many (.var (i % 3).toUInt64) acc) (.sort 0) + group "deep inputs" <| + withOk "deep" (optimizeSharing #[nested, telescope]) fun r => + test s!"{d}-deep argument nesting and a {d}-binder telescope optimize under default limits ({r.variableBytes} bytes = unshared {r.unsharedBytes})" + (r.variableBytes == r.unsharedBytes && + r.variableBytes == exprSize nested + exprSize telescope + 1 && + r.variableBytes == (serExpr nested).size + (serExpr telescope).size + 1) + +def dictionaryTests (_ : Unit) : TestSeq := + let fixtures : List (String × Array Ixon.Expr) := + [("T2→T2", #[arr (chain 2) (chain 2)]), ("A→A→B→B", #[twoMinimaRoot]), + ("mixed spines", #[.app (.app (.lam .many P (arr P P)) (arr P P)) (.app (.var 0) (arr P P))]), + ("let/prj", #[.letE (.lean false) (arr P P) (.prj 0 1 (.app (.var 0) P)) (.app (.var 0) P)])] + let fixtureSeq := fixtures.foldl (init := .done) fun acc (name, roots) => + acc ++ withOk name (expandRoots roots) fun ex => + -- Up to 2000 of the ordered dictionaries (every 7th when there are + -- more), each at indices 0.., and 300 of them at every index offset. + let total := (orderedSubsets ex.dag.size (List.range ex.dag.size)).length + let stride := if total > 2000 then 7 else 1 + let (c1, e1) := dictionaryAgreement ex.dag [0] 2000 stride + let (c2, e2) := dictionaryAgreement ex.dag dictOffsets 300 (stride * 3) + let err := e1.or e2 + test s!"{name}: C_M and byte-least materialization = enumeration ({c1 + c2} cases over {total} ordered dictionaries, stride {stride}; {dictOffsets.length} index offsets)" + (err.isNone) ++ + (match err with | some m => test m false | none => .done) + let (genChecked, genErr) := runGen 19 do + let mut checked := 0 + let mut err : Option String := none + let mut cases := 0 + for _ in [0:400] do + if cases ≥ 60 || err.isSome then break + let roots ← genRoots 3 4 2 + match expandRoots roots with + | .ok ex => + if ex.dag.size ≤ 5 then + cases := cases + 1 + let (c, e) := dictionaryAgreement ex.dag [0, 6, 254] 400 + checked := checked + c + if let some m := e then err := some s!"{m} roots={reprStr roots}" + | .error _ => pure () + return (checked, err) + group "fixed-dictionary optimizer vs enumeration" <| + fixtureSeq ++ + test s!"generated inputs (N ≤ 5): {genChecked} (dictionary, term) cases agree" genErr.isNone ++ + (match genErr with | some m => test m false | none => .done) + +/-! ## Full optimizer vs exhaustive oracle (P1/P3) -/ + +/-- Compare the optimizer with the oracle on generated constants. Inputs whose +oracle enumeration exceeds the per-case oracle budget are skipped and +counted (the optimizer is not given a budget). Returns +`(checked, skipped, tables, first failure)`. -/ +def oracleAgreement (seed cases maxN : Nat) (product : Bool) : Nat × Nat × Nat × Option String := + runGen seed do + let mut checked := 0 + let mut skipped := 0 + let mut attempts := 0 + let mut err : Option String := none + let mut tables := 0 + let budget : Limits := { maxOracleVariants := 400000 } + while checked < cases && attempts < 20 * cases && err.isNone do + attempts := attempts + 1 + let roots ← genRoots 3 5 3 + if distinctCount roots > maxN || distinctCount roots == 0 then continue + let c := wrapRoots roots attempts + match optimizeSharingTable c.sharing (constantInfoRoots c.info), + normalizeConstantSharing c, oracleConstant c budget product with + | .ok r, .ok n, .ok (oc, o) => + checked := checked + 1 + tables := tables + o.work.tables + unless serConstant n == serConstant oc && r.tableTerms == o.table do + err := some s!"case {attempts}: exact={hexOf (serConstant n)} Q={r.tableTerms} oracle={hexOf (serConstant oc)} Q={o.table} roots={reprStr roots}" + | .ok _, .ok _, .error (.resourceExhausted .oracleVariants _) => + skipped := skipped + 1 + | .error e, _, _ | _, .error e, _ | _, _, .error e => + err := some s!"case {attempts}: error {reprStr e} roots={reprStr roots}" + return (checked, skipped, tables, err) + +def oracleTests (_ : Unit) : TestSeq := + let (n1, s1, t1, e1) := oracleAgreement 23 150 6 false + let (n2, s2, t2, e2) := oracleAgreement 29 40 4 true + group "optimizer vs exhaustive oracle (full key)" <| + test s!"per-part oracle: {n1} generated constants (N ≤ 6, all kinds/contracts, {t1} tables) agree on bytes and table IDs ({s1} skipped: oracle budget)" (e1.isNone && n1 == 150) ++ + (match e1 with | some m => test m false | none => .done) ++ + test s!"full-product oracle: {n2} generated constants (N ≤ 4, {t2} tables) agree ({s2} skipped: oracle budget)" (e2.isNone && n2 == 40) ++ + (match e2 with | some m => test m false | none => .done) + +/-- Unit-width relaxation (§4.1): with no telescope merging and at most 8 +positive-weight terms of indegree ≥ 2, the minimum variable length is +`R + k* + tag0(k*) + Σ w(t)` over distinct terms, `w(t)` = node bytes − 1 +with every child written as one byte. -/ +def unitWidthLength (roots : Array Ixon.Expr) : Option Nat := Id.run do + let distinct := naiveCanonical roots + let stub (e : Ixon.Expr) : Ixon.Expr := match e with + | .prj t f _ => .prj t f (.var 0) + | .app .. => .app (.var 0) (.var 0) + | .lam c .. => .lam c (.var 0) (.var 0) + | .all c r .. => .all c r (.var 0) (.var 0) + | .letE c .. => .letE c (.var 0) (.var 0) (.var 0) + | e => e + let w (e : Ixon.Expr) : Nat := (serExpr (stub e)).size - 1 + let indeg (t : Ixon.Expr) : Nat := + distinct.foldl (fun acc s => acc + ((exprChildren s).filter (· == t)).length) 0 + + (roots.filter (· == t)).size + let kstar := (distinct.filter fun t => w t > 0 && indeg t ≥ 2).size + if kstar > 8 then return none + return some (roots.size + kstar + tag0Size kstar + + distinct.foldl (fun acc t => acc + w t) 0) + +def unitWidthTests (_ : Unit) : TestSeq := + let (checked, err) := runGen 31 do + let mut checked := 0 + let mut err : Option String := none + for i in [0:600] do + if checked ≥ 150 || err.isSome then break + let roots ← genRoots 6 14 4 (noMerge := true) + let some expected := unitWidthLength roots | continue + match optimizeSharing roots with + | .ok r => + checked := checked + 1 + unless r.variableBytes == expected do + err := some s!"case {i}: exact={r.variableBytes} unit={expected} roots={reprStr roots}" + | .error e => err := some s!"case {i}: error {reprStr e}" + return (checked, err) + group "unit-width relaxation oracle" <| + test s!"exact length = unit-width optimum on {checked} merge-free generated inputs" (err.isNone && checked ≥ 100) ++ + (match err with | some m => test m false | none => .done) + +/-- Independent atoms: for a fixed stored set the optimal order gives the +cheapest slots to the most-used atoms, so a brute force over subsets gives +the exact minimum, including the width-2 slots from index 8. -/ +def atomsBrute (sizes occs : Array Nat) : Nat := Id.run do + let n := sizes.size + let mut best := 0 + for mask in [0:2 ^ n] do + let inS (i : Nat) := (mask >>> i) % 2 == 1 + let stored := ((List.range n).filter inS).toArray.qsort fun a b => occs[a]! > occs[b]! + let mut cost := tag0Size stored.size + for h : slot in [0:stored.size] do + let a := stored[slot] + cost := cost + sizes[a]! + occs[a]! * shareWidth slot + for i in [0:n] do + if !inS i then cost := cost + occs[i]! * sizes[i]! + if mask == 0 || cost < best then best := cost + return best + +def atomsTests (_ : Unit) : TestSeq := + let (checked, err) := runGen 37 do + let mut checked := 0 + let mut err : Option String := none + for i in [0:12] do + let n := 9 + (← rand 3) + let mut atoms : Array Ixon.Expr := #[] + let mut occs : Array Nat := #[] + for j in [0:n] do + atoms := atoms.push (.ref (j + 2).toUInt64 (Array.replicate (← rand 4) 0)) + occs := occs.push (2 + (← rand 12)) + let roots := (Array.range n).foldl (fun acc j => acc ++ Array.replicate occs[j]! atoms[j]!) #[] + let sizes := atoms.map exprSize + let expected := atomsBrute sizes occs + match optimizeSharing roots with + | .ok r => + checked := checked + 1 + unless r.variableBytes == expected do + err := some s!"case {i}: exact={r.variableBytes} brute={expected} occs={occs} sizes={sizes}" + | .error e => err := some s!"case {i}: error {reprStr e}" + return (checked, err) + group "multi-width buckets vs brute force" <| + test s!"independent atoms (9–11 atoms, slots cross index 8): {checked} cases equal the brute-force minimum" (err.isNone && checked == 12) ++ + (match err with | some m => test m false | none => .done) + +/-! ## §2 fixtures -/ + +def witness2 : Constant := axiomOf (arr (chain 2) (chain 2)) + +def witnessTests (_ : Unit) : TestSeq := + -- A valid 19-byte encoding of T2 → T2, two bytes above the minimum. + let altBytes := ByteArray.mk #[0xd2, 0x00, 0x00, 0x91, 0x17, 0xb1, 0xb1, 0x02, 0x91, 0x17, + 0x00, 0x00, 0x91, 0x17, 0x00, 0xb0, 0x00, 0x01, 0x00] + let alt := (deConstant altBytes).toOption.getD witness2 + group "fixture T2 → T2 (19 → 17)" <| + test "the 19-byte encoding decodes to T2 → T2" + (hexOf (serConstant alt) == "d200009117b1b10291170000911700b0000100" && + (expandConstantSharing alt).toOption.map (constantInfoRoots ·.info) == + some (constantInfoRoots witness2.info)) ++ + test "unshared is 20 bytes" (cbytes witness2 == 20) ++ + withOk "exact" (optimizeSharingTable #[] (constantInfoRoots witness2.info)) (fun r => + test "exact table term IDs = [T2] = [2]" (r.tableTerms == #[2])) ++ + withOk "exact" (normalizeConstantSharing witness2) (fun n => + test "exact bytes d200009117b0b001921700170000000100 (17)" + (hexOf (serConstant n) == "d200009117b0b001921700170000000100")) ++ + withOk "exact from the 19-byte encoding" (normalizeConstantSharing alt) (fun n => + test "normalizing the 19-byte encoding gives the same 17 bytes" + (hexOf (serConstant n) == "d200009117b0b001921700170000000100")) ++ + withOk "oracle" (oracleConstant witness2) (fun (oc, o) => + test s!"per-part oracle: 17-byte unique minimum over {o.work.tables} ordered tables" + (hexOf (serConstant oc) == "d200009117b0b001921700170000000100" && + o.work.tables == 65 && o.minima.size == 1)) ++ + withOk "product oracle" (oracleConstant witness2 {} true) (fun (oc, o) => + test s!"full-product oracle: {o.work.candidates} complete candidates, 17-byte unique minimum" + (hexOf (serConstant oc) == "d200009117b0b001921700170000000100" && + o.work.candidates == 3061082 && o.minima.size == 1)) + +def witness16 : Constant := axiomOf (arr (chain 16) (chain 16)) + +def t16Tests (_ : Unit) : TestSeq := + let only16 : Constant := { witness16 with + info := .axio ⟨false, 0, arr (.share 0) (.share 0)⟩, sharing := #[chain 16] } + group "fixture T16 → T16" <| + test "unshared is 78 bytes" (cbytes witness16 == 78) ++ + test "storing only T16 is 46 bytes" (cbytes only16 == 46) ++ + withOk "exact" (optimizeSharingTable #[] (constantInfoRoots witness16.info)) (fun r => + withOk "exact" (normalizeConstantSharing witness16) fun n => + test s!"exact certified minimum = {cbytes n} bytes ≤ 46 (candidates {r.stats.candidates}, states reached {r.stats.statesReached}, expanded {r.stats.statesExpanded}, pruned {r.stats.statesPruned}, transitions {r.stats.transitions})" + (cbytes n ≤ 46 && cbytes n == r.variableBytes + 6)) + +/-- The nine-Ref fixture, built as in the production probe: atoms sorted by +the blake3 hash of their encoding, each twice, then 98 more uses of the last (hot) atom; one +recursor with the first root as type and the rest as rule bodies. -/ +def nineRef : Constant × Ixon.Expr := + let atoms0 : Array Ixon.Expr := (Array.range 9).map fun i => .ref i.toUInt64 #[0, 0, 0] + let atoms := atoms0.qsort fun a b => + compareBytes (Address.blake3 (serExpr a)).hash (Address.blake3 (serExpr b)).hash == .lt + let hot := atoms[8]! + let roots := atoms.foldl (fun acc a => acc ++ #[a, a]) #[] ++ Array.replicate 98 hot + let c : Constant := { + info := .recr ⟨false, false, 0, 0, 0, 0, 0, roots[0]!, + (roots.extract 1 roots.size).map fun rhs => ⟨0, rhs⟩⟩, + sharing := #[], + refs := (Array.range 9).map fun i => Address.blake3 (u64LE i.toUInt64), + univs := #[.zero] } + (c, hot) + +def nineRefTests (_ : Unit) : TestSeq := + let (c, hot) := nineRef + -- Two tables of the nine atoms: hash order (the hot atom last, in the 2-byte + -- slot 8) and most-used first. + let atoms := (constantInfoRoots c.info).foldl + (fun acc a => if acc.contains a then acc else acc.push a) #[] + let tableWith (table : Array Ixon.Expr) : Constant := + let idxOf (a : Ixon.Expr) : Nat := (table.findIdx? (· == a)).getD 0 + let roots := (constantInfoRoots c.info).map fun a => Ixon.Expr.share (idxOf a).toUInt64 + match withRoots c.info roots with + | .ok info => { c with info, sharing := table } + | .error _ => c + let hashOrder := tableWith atoms + let freqTable := #[hot] ++ (atoms.filter (· != hot)) + group "fixture nine independent Refs (676 → 578)" <| + test "hot atom is Ref(2,[0,0,0])" (hot == .ref 2 #[0, 0, 0]) ++ + test "hash order: 676 bytes, hot atom in slot 8" + (cbytes hashOrder == 676 && atoms.size == 9 && atoms[8]? == some hot) ++ + test "same entries, frequency order: 578 bytes" (cbytes (tableWith freqTable) == 578) ++ + withOk "exact" (optimizeSharingTable #[] (constantInfoRoots c.info)) (fun r => + withOk "exact" (normalizeConstantSharing c) fun n => + test s!"exact: {cbytes n} bytes, table IDs {r.tableTerms}, hot atom at a width-1 slot" + (cbytes n == 578 && r.tableTerms == #[0, 1, 2, 3, 4, 5, 6, 7, 8] && + ((n.sharing.findIdx? (· == hot)).map fun i => decide (i < 8)) == some true)) + +def twoMinimaTests (_ : Unit) : TestSeq := + let c := axiomOf twoMinimaRoot #[.zero, .succ .zero] + let first := "d200009317b017b017b1b102911700009117000100020001" ++ "00" + let second := "d200009317b117b117b0b002911700019117000000020001" ++ "00" + group "fixture two 25-byte minima" <| + withOk "oracle" (oracleConstant c) (fun (oc, o) => + test s!"oracle: minimum 25 over {o.work.tables} ordered tables; both [A,B] and [B,A] attain it; tie picks [A,B]" + (cbytes oc == 25 && o.work.tables == 13700 && + o.minima.any (hexOf · == first) && o.minima.any (hexOf · == second) && + hexOf (serConstant oc) == first && o.table == #[2, 3])) ++ + withOk "exact" (optimizeSharingTable #[] (constantInfoRoots c.info)) (fun r => + withOk "exact" (normalizeConstantSharing c) fun n => + test "exact picks the [A,B] minimum (table IDs [2,3])" + (hexOf (serConstant n) == first && r.tableTerms == #[2, 3])) + +/-- A parent stored before its separately stored descendant (which the +parent's entry therefore inlines): seven hot atoms take slots 0–6, the +50-use parent `P = App(Var 0, D)` takes slot 7 and `D` (3 more uses) slot 8. -/ +def orderingTests (_ : Unit) : TestSeq := + let d : Ixon.Expr := .ref 1 #[0, 0, 0] + let p : Ixon.Expr := .app (.var 0) d + let hots := (Array.range 7).map fun i => Ixon.Expr.ref (i + 2).toUInt64 #[0, 0, 0] + let roots := hots.foldl (fun acc h => acc ++ Array.replicate 100 h) #[] ++ + Array.replicate 50 p ++ Array.replicate 3 d + group "ordering: parent before descendant" <| + withOk "exact" (optimizeSharing roots) fun r => + test s!"variable bytes {r.variableBytes} = 804, table IDs {r.tableTerms} = [2..8, 9 (P), 1 (D)], P's entry inlines D" + (r.variableBytes == 804 && r.tableTerms == #[2, 3, 4, 5, 6, 7, 8, 9, 1] && + r.sharing[7]? == some p) + +/-! ## Properties on generated inputs -/ + +def propertyTests (_ : Unit) : TestSeq := + let (checked, err) := runGen 41 do + let mut checked := 0 + let mut err : Option String := none + for i in [0:250] do + if err.isSome then break + let roots ← genRoots 5 12 4 + let c := wrapRoots roots i + let alt := alternateOf c + match normalizeConstantSharing c, optimizeSharingTable #[] (constantInfoRoots c.info) with + | .ok n, .ok r => + checked := checked + 1 + let idem := (normalizeConstantSharing n).toOption.map serConstant == some (serConstant n) + let fromAlt := (normalizeConstantSharing alt).toOption.map serConstant == some (serConstant n) + let fromExpanded := ((expandConstantSharing n).toOption.bind + fun e => (normalizeConstantSharing e).toOption).map serConstant == some (serConstant n) + let minimum := match checkExactMinimum n with + | .ok .minimum => true + | _ => false + let altCheck := match checkExactMinimum alt with + | .ok .minimum => serConstant alt == serConstant n + | .ok (.notMinimum exp) => exp == serConstant n + | .error _ => false + let f := fixedConstantBytes c + let fixedOk := cbytes n == f + r.variableBytes && cbytes c == f + r.unsharedBytes + let expandsBack := (expandConstantSharing n).toOption.map (fun e => constantInfoRoots e.info) == + some (constantInfoRoots c.info) + unless cbytes n ≤ cbytes c && cbytes n ≤ cbytes alt && idem && fromAlt && + fromExpanded && minimum && altCheck && fixedOk && expandsBack do + err := some s!"case {i}: exact={cbytes n} unshared={cbytes c} uniform-w1={cbytes alt} idem={idem} fromAlt={fromAlt} fromExpanded={fromExpanded} minimum={minimum} altCheck={altCheck} fixed={fixedOk} expands={expandsBack} roots={reprStr roots}" + | .error e, _ | _, .error e => err := some s!"case {i}: error {reprStr e}" + return (checked, err) + group "properties on generated inputs" <| + test s!"{checked} constants: exact ≤ unshared, exact ≤ uniform-w1, idempotent, normalize(uniform-w1) = normalize(expanded) = exact, check=minimum, decomposition, expansion preserved" (err.isNone && checked == 250) ++ + (match err with | some m => test m false | none => .done) + +/-- LB pruning never changes a result: compare +with the search with pruning disabled, on inputs with 9–11 candidates +(beyond the oracle's reach; tables can cross the 8-slot width boundary). -/ +def pruningTests (_ : Unit) : TestSeq := + let (checked, wide, err) := runGen 43 do + let mut checked := 0 + let mut wide := 0 + let mut err : Option String := none + for i in [0:4000] do + if checked ≥ 25 || err.isSome then break + let roots ← genRoots 8 24 6 + let cands := match sharingProfile (wrapRoots roots 0) with + | .ok p => p.candidates + | .error _ => 0 + if cands < 9 || cands > 11 then continue + match optimizeSharing roots, + optimizeSharing roots { prune := false } with + | .ok a, .ok b => + checked := checked + 1 + if a.sharing.size > 8 then wide := wide + 1 + unless a.sharing == b.sharing && a.roots == b.roots && + a.tableTerms == b.tableTerms && a.variableBytes == b.variableBytes do + err := some s!"case {i}: pruned={a.variableBytes} {a.tableTerms} unpruned={b.variableBytes} {b.tableTerms}" + | .error e, _ | _, .error e => err := some s!"case {i}: error {reprStr e}" + return (checked, wide, err) + -- Many profitable atoms plus nested nodes over them: optimal tables + -- usually exceed 8 entries, so widths 1 and 2 compete. + let genWide : RGen (Array Ixon.Expr) := do + let n := 9 + (← rand 3) + let atoms : Array Ixon.Expr := (Array.range n).map fun j => + .ref (j + 2).toUInt64 (Array.replicate (1 + j % 3) 0) + let mut roots : Array Ixon.Expr := #[] + for j in [0:n] do + for _ in [0:2 + (← rand 4)] do roots := roots.push atoms[j]! + for _ in [0:(← rand 3)] do + let a := atoms[← rand n]! + let b := atoms[← rand n]! + let node : Ixon.Expr := if (← rand 2) == 0 then .app a b else arr a b + for _ in [0:2 + (← rand 2)] do roots := roots.push node + return roots + let (wChecked, wWide, wErr) := runGen 47 do + let mut checked := 0 + let mut wide := 0 + let mut err : Option String := none + for i in [0:400] do + if checked ≥ 15 || err.isSome then break + let roots ← genWide + let cands := match sharingProfile (wrapRoots roots 0) with + | .ok p => p.candidates + | .error _ => 0 + if cands > 12 then continue + match optimizeSharing roots, + optimizeSharing roots { prune := false } with + | .ok a, .ok b => + checked := checked + 1 + if a.sharing.size > 8 then wide := wide + 1 + unless a.sharing == b.sharing && a.roots == b.roots && + a.tableTerms == b.tableTerms && a.variableBytes == b.variableBytes do + err := some s!"wide case {i}: pruned={a.variableBytes} {a.tableTerms} unpruned={b.variableBytes} {b.tableTerms}" + | .error e, _ | _, .error e => err := some s!"wide case {i}: error {reprStr e}" + return (checked, wide, err) + group "pruning never changes the result" <| + test s!"{checked} inputs with 9–11 candidates ({wide} with more than 8 table entries): pruned search = unpruned search" + (err.isNone && checked == 25) ++ + (match err with | some m => test m false | none => .done) ++ + test s!"{wChecked} atom-heavy inputs with ≤ 12 candidates ({wWide} with more than 8 table entries): pruned = unpruned" + (wErr.isNone && wChecked == 15 && wWide > 0) ++ + (match wErr with | some m => test m false | none => .done) + +def profileTests (_ : Unit) : TestSeq := + group "sharing profile" <| + withOk "T2 → T2" (sharingProfile witness2) (fun p => + test "T2→T2: N=4, 3 repeated, 2 candidates (T1,T2), height 3, unshared 14 variable bytes" + (p.distinctSubterms == 4 && p.repeated == 3 && p.candidates == 2 && p.height == 3 && + p.unsharedBytes == 14 && p.inputBytes == 14)) ++ + withOk "T16 → T16" (sharingProfile witness16) (fun p => + test "T16→T16: N=18, 16 candidates, unshared 72 variable bytes" + (p.distinctSubterms == 18 && p.candidates == 16 && p.unsharedBytes == 72)) + +/-! ## Safety, limits, empty input -/ + +def staleProjection : Constant := + let info : ConstantInfo := .iPrj ⟨0, testRefs[0]!⟩ + { info, sharing := #[arr P P, .share 0], refs := testRefs, univs := #[] } + +def safetyTests (_ : Unit) : TestSeq := + let roots := constantInfoRoots witness16.info + group "resource limits and edge cases" <| + test "state limit → resourceExhausted, no result" + (isErr (optimizeSharing roots { maxStates := 5 }) (exhausted .states)) ++ + test "transition limit → resourceExhausted" + (isErr (optimizeSharing roots { maxTransitions := 5 }) (exhausted .transitions)) ++ + test "cost-evaluation limit → resourceExhausted" + (isErr (optimizeSharing roots { maxCostEvals := 50 }) (exhausted .costEvals)) ++ + test "output-byte limit → resourceExhausted" + (isErr (optimizeSharing roots { maxOutputBytes := 10 }) (exhausted .outputBytes)) ++ + test "materialization limit → resourceExhausted" + (isErr (optimizeSharing roots { maxMaterialize := 3 }) (exhausted .materialize)) ++ + test "oracle table limit → resourceExhausted" + (isErr (oracleConstant witness2 { maxOracleTables := 10 }) (exhausted .oracleTables)) ++ + test "oracle variant limit → resourceExhausted" + (isErr (oracleConstant witness2 { maxOracleVariants := 100 }) (exhausted .oracleVariants)) ++ + test "larger limits do not change a successful result" + ((optimizeSharing roots { maxStates := 1 <<< 30, maxCostEvals := 1 <<< 40 }).toOption.map (·.sharing) == + (optimizeSharing roots).toOption.map (·.sharing)) ++ + withOk "empty input" (optimizeSharing #[]) (fun r => + test "no roots: empty table, 1 variable byte (the table count)" + (r.sharing.isEmpty && r.roots.isEmpty && r.variableBytes == 1)) ++ + withOk "projection with a stale table" + (normalizeConstantSharing staleProjection) (fun n => + test "a constant without roots drops its (unreachable) table" n.sharing.isEmpty) ++ + test "repeated identical roots can be shared as whole roots" + ((optimizeSharing #[chain 5, chain 5, chain 5]).toOption.map (·.sharing.size) == some 1) + +/-! ## Randomized codec properties (SlimCheck) -/ + +def slimTests (_ : Unit) : TestSeq := + checkIO "exprSize = serExpr size (SlimCheck)" (∀ e : Ixon.Expr, exprSize e == (serExpr e).size) ++ + checkIO "Constant length decomposition (SlimCheck)" (∀ c : Constant, decompositionHolds c) + +/-! ## Suite -/ + +/-- Build and run a test group only when the suite executes (never at module +initialization), printing its report and wall time. -/ +def deferred (descr : String) (mk : Unit → TestSeq) : TestSeq := + .individualIO descr none (do + let start ← IO.monoMsNow + let (ok, out) ← (mk ()).runIO 4 + let stop ← IO.monoMsNow + IO.print out + IO.println s!" [{descr}: {stop - start} ms]" + return (ok, 0, 0, if ok then none else some s!"a check in '{descr}' failed; see above")) .done + +/-! ## Limits: defaults and overrides -/ + +def overrideFails (e : Except String Limits) : Bool := + match e with + | .ok _ => false + | .error _ => true + +/-- Override specs and the `states` limit each sets (`none`: rejected). The +Rust test list `LIMIT_SPEC_PARITY` (`crates/ixon/src/sharing_exact/tests.rs`) +is the same list, so both parsers give every spec the same verdict. Values +are ASCII digits, `2^k` or `max` (no sign, no `_` separator, no other +spelling); items and keys are trimmed of space, tab, line feed and carriage +return only. -/ +def limitSpecParity : List (String × Option Nat) := [ + ("states=5", some 5), + ("states=007", some 7), + (" states = 2^10 ", some (2 ^ 10)), + ("states=2^0", some 1), + ("states=2^63", some (2 ^ 63)), + ("states=max", some limitMax), + ("states=18446744073709551615", some limitMax), + ("unbounded", some limitMax), + ("", some (2 ^ 40)), + (",,states=5,,", some 5), + ("\tstates=5\n", some 5), + ("states=5\r", some 5), + ("states= 5", some 5), + ("states =5", some 5), + ("states=1_000", none), + ("states=2^1_0", none), + ("states=+5", none), + ("states=2^+5", none), + ("states=-1", none), + ("states=1e3", none), + ("states=0x10", none), + ("states=2^64", none), + ("states=18446744073709551616", none), + ("states=", none), + ("states=2^", none), + ("=5", none), + ("states", none), + ("a=b=c", none), + ("bogus=1", none), + ("STATES=5", none), + ("states=MAX", none), + ("states=\u00a05", none), + ("states=\uff15", none), + ("states=\x0c5", none), + ("states=\x0b5", none)] + +/-- The specs of `limitSpecParity` whose verdict differs from the list. -/ +def limitSpecMismatches : List String := + limitSpecParity.filterMap fun (spec, want) => + let got := match ({} : Limits).withOverrides spec with + | .ok l => some l.maxStates + | .error _ => none + if got == want then none else some spec + +def limitTests (_ : Unit) : TestSeq := + let d : Limits := {} + let resources : List Resource := [.exprVisits, .depth, .nodes, .states, .transitions, + .costEvals, .outputBytes, .materialize, .materializeWork, .knapsackCells] + group "limits" <| + test "the defaults are the safety net" + (d.maxExprVisits == 2 ^ 40 && d.maxDepth == 2 ^ 20 && d.maxNodes == 2 ^ 32 && + d.maxStates == 2 ^ 40 && d.maxTransitions == 2 ^ 40 && d.maxCostEvals == 2 ^ 50 && + d.maxOutputBytes == 2 ^ 40 && d.maxMaterialize == 2 ^ 40 && + d.maxMaterializeWork == 2 ^ 56 && d.maxKnapsackCells == 2 ^ 28) ++ + test "overrides set the named limits, left to right" + (match d.withOverrides " states = 2^10 ,cost_evals=12345, output_bytes=max,, states=2^11" with + | .ok l => l.maxStates == 2048 && l.maxCostEvals == 12345 && + l.maxOutputBytes == limitMax && l.maxDepth == d.maxDepth + | .error _ => false : Bool) ++ + test "Rust-only keys are accepted and ignored" + (match d.withOverrides "height=5,work=2^3,layer_states=9,input_nodes=1,distinct_nodes=1,candidates=1" with + | .ok l => reprStr l == reprStr d + | .error _ => false : Bool) ++ + test "unbounded sets every production limit to max; a later item still applies" + (match d.withOverrides "unbounded,states=2" with + | .ok l => l.maxDepth == limitMax && l.maxMaterializeWork == limitMax && + l.maxStates == 2 && l.maxOracleTables == d.maxOracleTables + | .error _ => false : Bool) ++ + test "malformed overrides are errors" + (["bogus=1", "states", "states=2^64", "states=-1", "states=1e3", "=3", + "states=18446744073709551616"].all fun s => overrideFails (d.withOverrides s)) ++ + test s!"the {limitSpecParity.length} specs shared with Rust get the listed verdict" + (limitSpecParity.length == 35 && limitSpecMismatches.isEmpty) ++ + test "every production resource key names a limit" + (resources.all fun r => (d.set? r.key 3).isSome) + +public def suite : List TestSeq := [ + deferred "integer widths" widthTests, + deferred "limits" limitTests, + deferred "exact expression length" exprSizeTests, + deferred "Constant length decomposition" decompositionTests, + deferred "structural IDs" structuralIdTests, + deferred "representation independence" representationTests, + deferred "bounded share expansion" expansionTests, + deferred "root extraction and reassembly" rootApiTests, + deferred "fixed-dictionary optimizer vs enumeration" dictionaryTests, + deferred "telescope evaluation vs full spine walk" spineWalkTests, + deferred "deep inputs" deepTests, + deferred "optimizer vs exhaustive oracle" oracleTests, + deferred "unit-width relaxation oracle" unitWidthTests, + deferred "multi-width buckets vs brute force" atomsTests, + deferred "fixture T2 → T2" witnessTests, + deferred "fixture T16 → T16" t16Tests, + deferred "fixture nine Refs" nineRefTests, + deferred "fixture two 25-byte minima" twoMinimaTests, + deferred "ordering: parent before descendant" orderingTests, + deferred "properties on generated inputs" propertyTests, + deferred "pruning never changes the result" pruningTests, + deferred "sharing profile" profileTests, + deferred "resource limits and edge cases" safetyTests, + slimTests (), +] + +end Tests.SharingExact diff --git a/Tests/Ix/SharingExactFFI.lean b/Tests/Ix/SharingExactFFI.lean new file mode 100644 index 000000000..992529378 --- /dev/null +++ b/Tests/Ix/SharingExactFFI.lean @@ -0,0 +1,602 @@ +/- + Lean/Rust differential test of the exact sharing constructions. + + Every check normalizes one Constant twice: in Lean (`normalizeConstantSharing`, + `normalizeConstantSharingUniform`, `normalizeConstantSharingTiered` from + `Ix.Sharing.Exact`) and in Rust through the `test-ffi` hooks + `rs_exact_sharing_normalize`, `rs_uniform_sharing_normalize` and + `rs_tiered_sharing_normalize` (crate `ixon::sharing_exact`). The two sides + agree when both succeed with the same serialized bytes, or both fail with + the same error category (malformed / format / resource / internal). One + side exhausting a resource limit while the other succeeds is reported + separately: the two implementations count work differently, and limits + may change success but never the bytes of a success. These groups are + strict: every comparison must be a byte-identical success (the exact + search runs only on inputs with few candidates). + + The inputs of these groups: the §2 fixtures, 350 inputs of the generated + families of the uniform and tiered tests, the tiered outputs of the + fixtures and of generated inputs re-normalized from their stored tables, + and the scale inputs of the tiered tests (a table past the 3-byte TagN + rung, a 1288-argument spine, 10000-deep inputs; uniform and tiered modes). + Malformed stored tables (forward, self and out-of-range references) must + be rejected as malformed by both sides, with the expected Lean error. + + A codec group checks the TagN Share codec: Lean and Rust serialize + Share-bearing Constants (tiered TagN outputs and synthetic tables up to + 66,600 entries) to the same bytes (`rs_eq_constant_serialization`). + + A compiler-route group checks the fourth hook, `rs_compiler_sharing_build` + (Rust `apply_sharing_to_*_with_limits`, crate `ix_compile`): it and Lean + `Ix.CompileM.buildConstantWithSharing` build the same bytes from the same + unshared Constant, equal to the tiered normalizer's. + + Modes: `tiered-tagN` is the canonical construction (the compiler's); + `uniform-w` is its phase-1 optimizer alone at Share width `k`; `exact` + is the width-state search for the global minimum, a test oracle for small + inputs (not the compiler path). + + Corpus mode: when `IX_SHARING_CORPUS` names an `.ixe` file, every constant + of that corpus (expanded from its stored table) is compared in the modes + listed in `IX_SHARING_CORPUS_MODES` (comma separated, default + `tiered-tagN`; also `uniform-w`, `exact`), only the constants whose + addresses are listed in the file `IX_SHARING_CORPUS_SELECT` when that is + set, and stops after `IX_SHARING_CORPUS_LIMIT` constants when that is set. + No CI job sets `IX_SHARING_CORPUS`. +-/ +module + +public import Tests.Ix.SharingExact +public import Tests.Ix.SharingUniform +public import Tests.Ix.SharingTiered +public import Tests.FFI.Ixon + +public section + +open LSpec Ixon Ix.Sharing.Exact Tests.SharingExact + +-- Groups are functions run from deferred IO actions. +set_option compiler.extract_closed false + +namespace Tests.SharingExactFFI + +/-! ## Rust entry points (`test-ffi`) -/ + +@[extern "rs_exact_sharing_normalize"] +opaque rsExactNormalize : @& ByteArray → Except String ByteArray + +@[extern "rs_uniform_sharing_normalize"] +opaque rsUniformNormalize : UInt64 → @& ByteArray → Except String ByteArray + +/-- The canonical tiered construction (TagN layout). -/ +@[extern "rs_tiered_sharing_normalize"] +opaque rsTieredNormalize : @& ByteArray → Except String ByteArray + +/-! ## Modes and outcomes -/ + +/-- A sharing construction compared across the two implementations. -/ +inductive Mode where + | exact + | uniform (w : Nat) + | tiered + deriving BEq, Repr, Inhabited + +def Mode.name : Mode → String + | .exact => "exact" + | .uniform w => s!"uniform-w{w}" + | .tiered => "tiered-tagN" + +def Mode.parse (s : String) : Option Mode := + if s == "exact" then some .exact + else if s == "tiered-tagN" then some .tiered + else if s.startsWith "uniform-w" then (String.ofList (s.toList.drop 9)).toNat?.map .uniform + else none + +/-- One side's result: the serialized Constant, or an error category with +its detail. -/ +inductive Outcome where + | ok (bytes : ByteArray) + | err (category detail : String) + deriving Inhabited + +def leanCategory : SharingError → String + | .shareInExpandedInput .. | .shareOutOfRange .. | .nonBackwardShare .. + | .rootCountMismatch .. => "malformed" + | .formatBound .. => "format" + | .resourceExhausted .. => "resource" + | .internal _ => "internal" + +def rustCategory (s : String) : String := + if s.startsWith "malformed sharing:" then "malformed" + else if s.startsWith "format bound:" then "format" + else if s.startsWith "resource exhausted:" then "resource" + else if s.startsWith "internal error:" then "internal" + else if s.startsWith "decode:" then "decode" + else "unknown" + +/-- The Lean construction under explicit limits. -/ +def leanNormalize (m : Mode) (c : Constant) (limits : Limits) : Except SharingError Constant := + match m with + | .exact => normalizeConstantSharing c limits + | .uniform w => normalizeConstantSharingUniform w c limits + | .tiered => normalizeConstantSharingTiered .tagN c limits + +@[noinline] def leanSide (m : Mode) (c : Constant) : Outcome := + match leanNormalize m c {} with + | .ok n => .ok (serConstant n) + | .error e => .err (leanCategory e) (reprStr e) + +@[noinline] def rustSide (m : Mode) (bytes : ByteArray) : Outcome := + let r := match m with + | .exact => rsExactNormalize bytes + | .uniform w => rsUniformNormalize w.toUInt64 bytes + | .tiered => rsTieredNormalize bytes + match r with + | .ok b => .ok b + | .error s => .err (rustCategory s) s + +/-- Index of the first differing byte (the shorter length if one is a +prefix of the other). -/ +def firstDiff (a b : ByteArray) : Nat := Id.run do + for i in [0:min a.size b.size] do + if a.get! i != b.get! i then return i + return min a.size b.size + +/-- Comparison of the two sides. -/ +inductive Verdict where + | sameBytes + | sameError (category : String) + /-- One side exhausted a resource limit, the other succeeded. -/ + | resourceOnly (leanFailed : Bool) + | differ (msg : String) + deriving Inhabited + +def compareOutcomes (lean rust : Outcome) : Verdict := + match lean, rust with + | .ok a, .ok b => + if a == b then .sameBytes + else .differ s!"bytes differ: Lean {a.size} B, Rust {b.size} B, first differing byte {firstDiff a b}" + | .err ca da, .err cb db => + if ca == cb then .sameError ca else .differ s!"error categories differ: Lean {ca} ({da}), Rust {cb} ({db})" + | .err "resource" _, .ok _ => .resourceOnly true + | .ok _, .err "resource" _ => .resourceOnly false + | .err ca da, .ok b => .differ s!"Lean error {ca} ({da}); Rust ok ({b.size} B)" + | .ok a, .err cb db => .differ s!"Lean ok ({a.size} B); Rust error {cb} ({db})" + +/-- Tallies of one batch of comparisons. -/ +structure Tally where + same : Nat := 0 + sameErr : Nat := 0 + resourceLean : Nat := 0 + resourceRust : Nat := 0 + differences : Array String := #[] + /-- Labels of same-category errors and of one-sided resource exhaustion. -/ + notes : Array String := #[] + leanNs : Nat := 0 + rustNs : Nat := 0 + deriving Inhabited + +def Tally.add (t : Tally) (label : String) : Verdict → Tally + | .sameBytes => { t with same := t.same + 1 } + | .sameError c => { t with sameErr := t.sameErr + 1, notes := t.notes.push s!"{label}: both {c}" } + | .resourceOnly true => { t with resourceLean := t.resourceLean + 1, notes := t.notes.push s!"{label}: Lean resource exhaustion, Rust ok" } + | .resourceOnly false => { t with resourceRust := t.resourceRust + 1, notes := t.notes.push s!"{label}: Rust resource exhaustion, Lean ok" } + | .differ msg => { t with differences := t.differences.push s!"{label}: {msg}" } + +def Tally.summary (t : Tally) : String := + s!"{t.same} same bytes, {t.sameErr} same error category, {t.resourceLean} Lean-only and {t.resourceRust} Rust-only resource exhaustion, {t.differences.size} disagreements" + +/-- Compare one Constant under one mode, timing both sides. -/ +def compareOne (m : Mode) (c : Constant) (bytes : ByteArray) : IO (Verdict × Nat × Nat) := do + let t0 ← IO.monoNanosNow + let l ← IO.lazyPure fun _ => leanSide m c + let t1 ← IO.monoNanosNow + let r ← IO.lazyPure fun _ => rustSide m bytes + let t2 ← IO.monoNanosNow + return (compareOutcomes l r, t1 - t0, t2 - t1) + +/-- A limit's name and value. -/ +def limitOf (l : Limits) : Resource → String × Nat + | .exprVisits => ("maxExprVisits", l.maxExprVisits) + | .depth => ("maxDepth", l.maxDepth) + | .nodes => ("maxNodes", l.maxNodes) + | .states => ("maxStates", l.maxStates) + | .transitions => ("maxTransitions", l.maxTransitions) + | .costEvals => ("maxCostEvals", l.maxCostEvals) + | .outputBytes => ("maxOutputBytes", l.maxOutputBytes) + | .materialize => ("maxMaterialize", l.maxMaterialize) + | .materializeWork => ("maxMaterializeWork", l.maxMaterializeWork) + | .oracleTables => ("maxOracleTables", l.maxOracleTables) + | .oracleVariants => ("maxOracleVariants", l.maxOracleVariants) + | .knapsackCells => ("maxKnapsackCells", l.maxKnapsackCells) + +/-- Double one limit. -/ +def doubleLimit (l : Limits) : Resource → Limits + | .exprVisits => { l with maxExprVisits := 2 * l.maxExprVisits } + | .depth => { l with maxDepth := 2 * l.maxDepth } + | .nodes => { l with maxNodes := 2 * l.maxNodes } + | .states => { l with maxStates := 2 * l.maxStates } + | .transitions => { l with maxTransitions := 2 * l.maxTransitions } + | .costEvals => { l with maxCostEvals := 2 * l.maxCostEvals } + | .outputBytes => { l with maxOutputBytes := 2 * l.maxOutputBytes } + | .materialize => { l with maxMaterialize := 2 * l.maxMaterialize } + | .materializeWork => { l with maxMaterializeWork := 2 * l.maxMaterializeWork } + | .oracleTables => { l with maxOracleTables := 2 * l.maxOracleTables } + | .oracleVariants => { l with maxOracleVariants := 2 * l.maxOracleVariants } + | .knapsackCells => { l with maxKnapsackCells := 2 * l.maxKnapsackCells } + +/-- For a Lean-only resource exhaustion: rerun Lean, doubling whichever +limit fires (at most 12 doublings in total), and report the limits that +fired, the values that sufficed, and whether the bytes then equal Rust's. -/ +def diagnose (m : Mode) (c : Constant) (rust : Outcome) : String := Id.run do + let mut limits : Limits := {} + let mut fired : Array String := #[] + let mut raised : Array Resource := #[] + for _ in [0:13] do + match leanNormalize m c limits with + | .ok n => + let same := match rust with + | .ok b => if serConstant n == b then "equal to Rust" else "DIFFERENT from Rust" + | .err .. => "Rust failed" + let final := raised.toList.map fun r => + let (name, v) := limitOf limits r + s!"{name}={v}" + return s!"Lean exhausted {fired.toList}; succeeded with {final}; bytes {same}" + | .error (.resourceExhausted r lim) => + let (name, _) := limitOf limits r + fired := fired.push s!"{name}={lim}" + unless raised.contains r do raised := raised.push r + limits := doubleLimit limits r + | .error e => return s!"Lean exhausted {fired.toList}; then error {reprStr e}" + return s!"Lean fired {fired.toList}; still exhausted after 12 doublings" + +def compareMany (cases : Array (String × Constant)) (modes : Constant → List Mode) : IO Tally := do + let mut t : Tally := {} + for (label, c) in cases do + let bytes := serConstant c + for m in modes c do + let (v, ln, rn) ← compareOne m c bytes + t := { t.add s!"{label} [{m.name}]" v with leanNs := t.leanNs + ln, rustNs := t.rustNs + rn } + return t + +/-- A test group whose body runs in `IO` when the suite executes. -/ +def ioGroup (descr : String) (run : IO (Bool × String)) : TestSeq := + .individualIO descr none (do + let start ← IO.monoMsNow + let (ok, msg) ← run + IO.println msg + IO.println s!" [{descr}: {(← IO.monoMsNow) - start} ms]" + return (ok, 0, 0, if ok then none else some s!"'{descr}' failed; see above")) .done + +/-- Pass/fail and the printed report of a batch: no disagreement and at least +one byte-identical success, so a batch cannot pass on matching errors alone. +With `expectAll`, every comparison must be a byte-identical success. -/ +def judge (descr : String) (t : Tally) (expectAll : Bool) : Bool × String := + let ok := t.differences.isEmpty && t.same > 0 && + (!expectAll || (t.resourceLean == 0 && t.resourceRust == 0 && t.sameErr == 0)) + let lines := (t.differences.toList.take 50).map (s!" DISAGREEMENT {·}") + (ok, String.intercalate "\n" + (s!" {descr}: {t.summary}; Lean {t.leanNs / 1000000} ms, Rust {t.rustNs / 1000000} ms" :: lines)) + +/-! ## Fixtures and generated families -/ + +def allModes : List Mode := + [.exact, .uniform 1, .uniform 2, .uniform 3, .uniform 5, .tiered] + +def fixtures : Array (String × Constant) := + let chains := #[1, 2, 3, 4, 7, 8, 9, 16, 32].map fun n => + (s!"T{n} → T{n}", axiomOf (arr (chain n) (chain n))) + #[("T2 → T2", witness2), ("T16 → T16", witness16), ("nine Refs", nineRef.1), + ("two 25-byte minima", axiomOf twoMinimaRoot #[.zero, .succ .zero])] ++ chains + +/-- The exact width-state search is exponential: skip it on T32. -/ +def fixtureModes (c : Constant) : List Mode := + if (serConstant c).size > 100 then allModes.filter (· != .exact) else allModes + +def fixtureTests : TestSeq := + ioGroup "Lean/Rust: §2 fixtures" do + let t ← compareMany fixtures fixtureModes + return judge s!"§2 fixtures × {allModes.map Mode.name}" t true + +/-- The generated families of the uniform and tiered tests. -/ +def genFamily (i : Nat) : Tests.SharingExact.RGen (Array Ixon.Expr) := + match i % 7 with + | 0 => Tests.SharingUniform.genPrefixes + | 1 => Tests.SharingUniform.genSmallPayload + | 2 => Tests.SharingUniform.genPairs + | 3 => Tests.SharingUniform.genChain + | 4 => Tests.SharingTiered.genHeavyParent + | _ => genRoots 5 12 4 + +def generatedCases (n : Nat) : Array (String × Constant) := + runGen 83 do + let mut out : Array (String × Constant) := #[] + for i in [0:n] do + let roots ← genFamily i + out := out.push (s!"generated #{i} (family {i % 7})", wrapRoots roots i) + return out + +/-- The exact width-state search only on inputs with few candidates. -/ +def generatedModes (c : Constant) : List Mode := + let small : Bool := match sharingProfile c with + | .ok p => p.candidates ≤ 12 + | .error _ => false + if small then allModes else allModes.filter (· != .exact) + +def generatedTests : TestSeq := + ioGroup "Lean/Rust: generated families" do + let t ← compareMany (generatedCases 350) generatedModes + return judge "350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes" t true + +/-! ## TagN Share parity + +Lean and Rust serialize Share-bearing Constants to the same bytes, and Lean +decodes them back. Inputs: the tiered canonical sharing of every §2 fixture +and of generated inputs, plus synthetic tables whose roots reference the +indices at every TagN rung end (and indices beyond any table, which the codec +does not bound). -/ + +/-- A Constant with an `n`-entry table (`sharing[i] = app (var i) (Share (i-1))`) +whose root references the Share indices at the TagN rung ends below `n` (and +at the old byte-count boundaries), then +`n - 1`. -/ +def wideTable (n : Nat) : Constant := + let sharing := (Array.range n).map fun i => + if i == 0 then Ixon.Expr.var 0 else .app (.var i.toUInt64) (.share (i - 1).toUInt64) + let idxs := ([0, 7, 8, 255, 256, 1031, 1032, 65535, 65536, 66567, 66568].filter (· < n)) + ++ [n - 1] + let root := idxs.foldl (fun acc i => Ixon.Expr.app acc (.share i.toUInt64)) (.var 0) + { info := .axio ⟨false, 0, root⟩, sharing, refs := #[], univs := #[] } + +/-- Share indices in the 4-, 5- and 9-byte TagN rungs (no table backs them; the +codec does not bound Share indices). -/ +def farShares : Constant := + let root := [16843783, 16843784, 4294967296, 4311811079, 4311811080, 0xFFFFFFFFFFFFFFFF].foldl + (fun acc (i : UInt64) => Ixon.Expr.app acc (.share i)) (.var 0) + { info := .axio ⟨false, 0, root⟩, sharing := #[], refs := #[], univs := #[] } + +/-- Check one Constant: Rust writes Lean's bytes and Lean decodes them back. -/ +def codecCheck (label : String) (c : Constant) : Array String := Id.run do + let bytes := serConstant c + let mut errs : Array String := #[] + unless Tests.FFI.Ixon.rsEqConstantSerialization c bytes do + errs := errs.push s!"{label}: Rust bytes differ" + match deConstant bytes with + | .ok c' => unless c' == c do errs := errs.push s!"{label}: Lean decode differs" + | .error e => errs := errs.push s!"{label}: Lean decode failed: {e}" + return errs + +/-- The highest Share index of a Constant's table entries and roots. -/ +def maxShare (c : Constant) : Nat := + (c.sharing ++ constantInfoRoots c.info).foldl + (fun acc e => (shareIndices e #[]).foldl max acc) 0 + +/-- The tiered outputs of the fixtures and of 120 generated inputs that carry a +table, and the labels of the inputs whose normalization failed. -/ +def tieredOutputs : Array (String × Constant) × Array String := + (fixtures ++ generatedCases 120).foldl (init := (#[], #[])) fun (outs, errs) (label, c) => + match normalizeConstantSharingTiered .tagN c with + | .ok n => if n.sharing.isEmpty then (outs, errs) else (outs.push (s!"{label} [tiered-tagN]", n), errs) + | .error e => (outs, errs.push s!"{label}: tiered normalization failed: {reprStr e}") + +def codecTests : TestSeq := + ioGroup "Lean/Rust: TagN Share parity on Share-bearing Constants" do + let (normalized, failed) := tieredOutputs + let synthetic := #[("wide table 9", wideTable 9), ("wide table 300", wideTable 300), + ("wide table 1100", wideTable 1100), ("wide table 66600", wideTable 66600), + ("far Shares", farShares)] + let cases := normalized ++ synthetic + let mut errs : Array String := failed + for (label, c) in cases do + errs := errs ++ codecCheck label c + let ok := errs.isEmpty && normalized.size > 0 + let lines := (errs.toList.take 50).map (s!" DISAGREEMENT {·}") + return (ok, String.intercalate "\n" + (s!" {cases.size} Share-bearing Constants ({normalized.size} tiered-tagN outputs, max Share index {normalized.foldl (fun acc (_, c) => max acc (maxShare c)) 0}; {synthetic.size} synthetic); {errs.size} disagreements" :: lines)) + +/-! ## Inputs that carry a table + +Both constructions expand a stored table before sharing again. The tiered +outputs above are re-normalized by every mode on both sides, and must give +the same bytes; malformed tables (a forward, a self and two out-of-range +references) must be rejected by both sides as malformed. -/ + +def renormalizeTests : TestSeq := + ioGroup "Lean/Rust: re-normalization of stored tables" do + let t ← compareMany tieredOutputs.1 generatedModes + return judge s!"{tieredOutputs.1.size} tiered outputs (Share-bearing) × modes" t true + +/-- Constants whose stored table is malformed, with the expected Lean error. -/ +def malformedTables : Array (String × Constant × SharingError) := + let withTable (roots table : Array Ixon.Expr) : Constant := + { wrapRoots roots 0 with sharing := table } + #[("forward reference", withTable #[.share 0] #[.share 1, P], .nonBackwardShare 0 1), + ("self reference", withTable #[.share 0] #[.app (.share 0) P], .nonBackwardShare 0 0), + ("out-of-range root reference", withTable #[.share 3] #[], .shareOutOfRange none 3 0), + ("out-of-range entry reference", withTable #[P] #[.share 5], .shareOutOfRange (some 0) 5 1)] + +def malformedTests : TestSeq := + ioGroup "Lean/Rust: malformed stored tables" do + let mut errs : Array String := #[] + let mut checked := 0 + for (label, c, want) in malformedTables do + for m in allModes do + checked := checked + 1 + match leanNormalize m c {} with + | .error e => unless e == want do errs := errs.push s!"{label} [{m.name}]: Lean {reprStr e}" + | .ok _ => errs := errs.push s!"{label} [{m.name}]: Lean accepted it" + match compareOutcomes (leanSide m c) (rustSide m (serConstant c)) with + | .sameError "malformed" => pure () + | _ => errs := errs.push s!"{label} [{m.name}]: not rejected as malformed by both sides" + let ok := errs.isEmpty && checked == malformedTables.size * allModes.length + let lines := (errs.toList.take 50).map (s!" DISAGREEMENT {·}") + return (ok, String.intercalate "\n" + (s!" {malformedTables.size} malformed tables × {allModes.length} modes: {checked - errs.size} rejected as malformed by both sides with the expected Lean error" :: lines)) + +/-- The tiered scale inputs (`Tests.SharingTiered.scaleTests`): a table past +the 3-byte rung, a 1288-argument spine and 10000-deep inputs. -/ +def scaleCases : Array (String × Constant) := + let d := 10000 + let shared : Ixon.Expr := .ref 5 #[0, 0, 0, 0, 0] + #[("1040 fillers, 12 chains", wrapRoots (Tests.SharingTiered.scaleRoots 1040 12) 0), + ("1288-argument spine", wrapRoots (Tests.SharingTiered.spineRoots 1288) 0), + ("10000-deep inputs", wrapRoots #[ + (List.range d).foldl (fun acc i => .app (.var (i % 2).toUInt64) acc) shared, + (List.range d).foldl (fun acc i => .lam .many (.var (i % 3).toUInt64) acc) shared, + shared] 0)] + +def scaleParityTests : TestSeq := + ioGroup "Lean/Rust: the production path at scale" do + let t ← compareMany scaleCases fun _ => [.uniform 1, .uniform 2, .uniform 3, .tiered] + return judge "scale inputs (a table past the 3-byte rung, a long spine, deep inputs) × uniform-w1..3, tiered-tagN" t true + +/-! ## Compiler sharing route + +The compiler builds every block through `Ix.CompileM.buildConstantWithSharing` +(Lean, under `CompileEnv.sharingLimits`) and `apply_sharing_to_*` (Rust): the +canonical construction, roots derived from the payload. Both languages +must build the same bytes from the same unshared Constant, and exactly what +the library normalizer builds. -/ + +/-- Rust `apply_sharing_to_*_with_limits` on one unshared Constant, under the +default limits. -/ +@[extern "rs_compiler_sharing_build"] +opaque rsCompilerSharingBuild : @& ByteArray → Except String ByteArray + +/-- The Lean compiler route on an unshared Constant. -/ +def leanRoute (c : Constant) : Except Ix.CompileM.CompileError Constant := + Ix.CompileM.buildConstantWithSharing Ix.CompileM.compilerSharingLimits c.info c.refs c.univs + +def routeUnits : TestSeq := + let tiny : Limits := { Ix.CompileM.compilerSharingLimits with maxNodes := 2 } + test "compiler route: T2 → T2 in the 17-byte minimum" + (match leanRoute witness2 with + | .ok c => hexOf (serConstant c) == "d200009117b0b001921700170000000100" + | .error _ => false : Bool) ++ + test "compiler route fails closed on its limits (resourceLimit naming the limit and its override)" + (match Ix.CompileM.buildConstantWithSharing tiny witness2.info witness2.refs + witness2.univs with + | .error (.resourceLimit msg) => + (msg.splitOn "resource exhausted: nodes (limit 2)").length > 1 && + (msg.splitOn "--sharing-limits nodes=N (IX_SHARING_LIMITS)").length > 1 + | _ => false : Bool) ++ + test "compiler route on a projection: no sharing table" + (match leanRoute { witness2 with info := .cPrj ⟨0, 0, Address.blake3 ByteArray.empty⟩ } with + | .ok c => c.sharing.isEmpty + | .error _ => false : Bool) + +def routeTests : TestSeq := + ioGroup "Lean/Rust: compiler sharing route" do + let cases := (fixtures ++ generatedCases 140).filterMap fun (label, c) => + match expandConstantSharing c with + | .ok e => some (label, e) + | .error _ => none + let mut errs : Array String := #[] + let mut same := 0 + let mut kinds : Array String := #[] + for (label, c) in cases do + let kind := match c.info with + | .defn _ => "defn" | .recr _ => "recr" | .axio _ => "axio" | .quot _ => "quot" + | .muts _ => "muts" | _ => "prj" + unless kinds.contains kind do kinds := kinds.push kind + match leanRoute c, rsCompilerSharingBuild (serConstant c) with + | .ok l, .ok r => + if serConstant l == r then same := same + 1 + else errs := errs.push s!"{label}: Lean and Rust bytes differ" + match normalizeConstantSharingTiered .tagN c with + | .ok n => + unless serConstant n == serConstant l do + errs := errs.push s!"{label}: route differs from normalizeConstantSharingTiered" + | .error e => errs := errs.push s!"{label}: normalizer failed: {reprStr e}" + | .error e, _ => errs := errs.push s!"{label}: Lean route failed: {e}" + | _, .error e => errs := errs.push s!"{label}: Rust route failed: {e}" + let ok := errs.isEmpty && same > 0 && same == cases.size + let lines := (errs.toList.take 50).map (s!" DISAGREEMENT {·}") + return (ok, String.intercalate "\n" + (s!" {cases.size} unshared Constants (kinds {kinds.toList}): {same} same bytes; {errs.size} disagreements" :: lines)) + +/-! ## Corpus mode -/ + +def corpusTests (_ : Unit) : TestSeq := + .individualIO "init.ixe corpus (IX_SHARING_CORPUS)" none (do + let some path ← IO.getEnv "IX_SHARING_CORPUS" + | IO.println " [corpus: IX_SHARING_CORPUS not set; skipped]" + return (true, 0, 0, none) + let modeNames := ((← IO.getEnv "IX_SHARING_CORPUS_MODES").getD "tiered-tagN").splitOn "," + let modes := modeNames.filterMap Mode.parse + if modes.length != modeNames.length then + return (false, 0, 0, some s!"unknown mode in {modeNames}") + let limit := ((← IO.getEnv "IX_SHARING_CORPUS_LIMIT").bind String.toNat?) + let t0 ← IO.monoMsNow + let bytes ← IO.FS.readBinFile path + let env ← IO.ofExcept (Ixon.deEnvAnon bytes) + let entries := env.consts.toArray.qsort fun a b => Address.cmpBytes a.1 b.1 == .lt + -- Optional selection: a file of hex addresses, one per line. + let select ← match ← IO.getEnv "IX_SHARING_CORPUS_SELECT" with + | some p => do + let lines := (← IO.FS.readFile p).splitOn "\n" |>.map (String.trimAscii · |>.toString) |>.filter (· != "") + pure (some (lines.foldl (fun (s : Std.HashSet String) l => s.insert l) {})) + | none => pure none + let entries := match select with + | some s => entries.filter fun (e : Address × Ixon.LazyConstant) => s.contains (toString e.1) + | none => entries + let entries := match limit with + | some n => entries.extract 0 n + | none => entries + IO.println s!" [corpus: {path}, {env.consts.size} constants, comparing {entries.size} under {modes.map Mode.name}; loaded in {(← IO.monoMsNow) - t0} ms]" + let mut tallies : Array Tally := Array.replicate modes.length {} + let mut decodeFailures := 0 + let mut done := 0 + for (addr, lc) in entries do + let c ← match lc.get with + | .ok c => pure c + | .error _ => + decodeFailures := decodeFailures + 1 + continue + let raw := lc.rawBytes + let label := match env.addrToName.get? addr with + | some n => s!"{n} ({addr})" + | none => s!"{addr}" + for h : k in [0:modes.length] do + let m := modes[k] + let (v, ln, rn) ← compareOne m c raw + -- Lean-only exhaustion: find the limit that fires and the value that suffices. + let v ← match v with + | .resourceOnly true => do + let d := diagnose m c (rustSide m raw) + IO.println s!" DIAGNOSIS {label} [{m.name}]: {d}" + pure v + | _ => pure v + let t := tallies[k]! + tallies := tallies.set! k + { t.add label v with leanNs := t.leanNs + ln, rustNs := t.rustNs + rn } + done := done + 1 + if done % 5000 == 0 then + IO.println s!" [corpus progress: {done}/{entries.size}]" + let mut ok := decodeFailures == 0 + for h : k in [0:modes.length] do + let t := tallies[k]! + IO.println s!" [corpus {modes[k].name}: {done} constants; {t.summary}; Lean {t.leanNs / 1000000} ms, Rust {t.rustNs / 1000000} ms]" + for d in t.notes do + IO.println s!" NOTE {d}" + for d in t.differences do + IO.println s!" DISAGREEMENT {d}" + unless t.differences.isEmpty do ok := false + IO.println s!" [corpus: decode failures {decodeFailures}; total {(← IO.monoMsNow) - t0} ms]" + return (ok, 0, 0, if ok then none else some "corpus disagreements; see above")) .done + +public def suite : List TestSeq := [ + fixtureTests, + generatedTests, + codecTests, + renormalizeTests, + malformedTests, + scaleParityTests, + routeUnits, + routeTests, + corpusTests (), +] + +end Tests.SharingExactFFI + +end diff --git a/Tests/Ix/SharingTiered.lean b/Tests/Ix/SharingTiered.lean new file mode 100644 index 000000000..2d3ab6a2a --- /dev/null +++ b/Tests/Ix/SharingTiered.lean @@ -0,0 +1,425 @@ +/- + Tests for the tiered canonical construction (`Ix.Sharing.Exact.Tiered`): + §2 fixtures under the wire layout (TagN), inputs where slot allocation changes the + order, the "never longer than phase 1" guarantee, idempotence, a brute + force for the first-tier allocation, the production path at scale (the + parallel widths, a table past the 3-byte rung that makes the phase-2 guard + keep the phase-1 order, a long spine, deep inputs) and every production + limit reached through `canonicalSharingTiered` and the compiler's builder. +-/ +module + +public import Tests.Ix.SharingExact + +public section + +open LSpec Ixon Ix.Sharing.Exact Tests.SharingExact + +-- Groups are functions run from deferred IO actions. +set_option compiler.extract_closed false + +namespace Tests.SharingTiered + +/-- The pinned width selection: three candidates (w = 1, 2, 3), the result is +the first one with the fewest final layout bytes. -/ +def selectionOk (r : TieredSharingResult) : Bool := + let ls := r.stats.candidateLengths + let best := ls.foldl (fun m (_, b) => min m b) r.stats.phase3LayoutBytes + ls.map (·.1) == #[1, 2, 3] && r.stats.phase3LayoutBytes == best && + (ls.find? (·.2 == best)).map (·.1) == some r.stats.w + +/-- The candidate at phase-1 width `w` alone (`tieredAtWidth`) on the +expanded roots of `c`. -/ +def candidateAt (l : ShareLayout) (c : Constant) (w : Nat) : + Except SharingError TieredSharingResult := do + let ex ← expand {} c.sharing (constantInfoRoots c.info) true + tieredAtWidth l {} ex w + +/-- Every recorded candidate length is that of the candidate run alone, and +the result is byte-identical to the candidate at its winning width. -/ +def candidatesOk (l : ShareLayout) (c : Constant) (r : TieredSharingResult) : Bool := + r.stats.candidateLengths.all (fun (w, b) => + match candidateAt l c w with + | .ok cw => cw.stats.w == w && cw.stats.phase3LayoutBytes == b && + cw.stats.candidateLengths == #[(w, b)] + | .error _ => false) && + match candidateAt l c r.stats.w with + | .ok cw => cw.result.sharing == r.result.sharing && cw.result.roots == r.result.roots + | .error _ => false + +/-- `candidatesOk` for the canonical result of `c`. -/ +def sameAsCandidates (l : ShareLayout) (c : Constant) : Bool := + match canonicalSharingTieredTable l c.sharing (constantInfoRoots c.info) with + | .ok r => candidatesOk l c r + | .error _ => false + +def fixtureTests (_ : Unit) : TestSeq := + let (nine, hot) := nineRef + let w2 := witness2 + let w16 := axiomOf (arr (chain 16) (chain 16)) + let l := ShareLayout.tagN + group "fixtures, TagN layout" ( + withOk "T2" (normalizeConstantSharingTiered l w2) (fun n => + test s!"T2 → T2: {cbytes n} bytes = 17, d200009117b0b001921700170000000100" + (cbytes n == 17 && hexOf (serConstant n) == "d200009117b0b001921700170000000100" && + sameAsCandidates l w2)) ++ + withOk "T16" (normalizeConstantSharingTiered l w16) (fun n => + test s!"T16 → T16: {cbytes n} bytes = 46, the candidates run alone agree" + (cbytes n == 46 && sameAsCandidates l w16)) ++ + withOk "nine" (canonicalSharingTieredTable l #[] (constantInfoRoots nine.info)) (fun r => + withOk "nine" (normalizeConstantSharingTiered l nine) fun n => + test s!"nine Refs: {cbytes n} bytes = 578, the candidates run alone agree; w={r.stats.w} (candidates {r.stats.candidateLengths}); first tier {r.stats.firstTier} holds the hot atom; phase-1 layout {r.stats.phase1LayoutBytes}, final {r.stats.phase3LayoutBytes}" + (cbytes n == 578 && selectionOk r && sameAsCandidates l nine && + r.stats.firstTier.contains 2 && + (n.sharing.findIdx? (· == hot)).map (fun i => decide (i < 8)) == some true))) + +/-- A heavy parent `P` over two lighter children, next to more than eight +ready atoms used three times each. The pinned order fills the first tier +with atoms; the allocation puts `P` and its children there. -/ +def genHeavyParent : RGen (Array Ixon.Expr) := do + let nAtoms := 9 + (← rand 4) + let atoms : Array Ixon.Expr := (Array.range nAtoms).map fun j => + .ref (j + 10).toUInt64 (Array.replicate (1 + j % 3) 0) + let c1 : Ixon.Expr := .ref 1 #[0, 0, 0] + let c2 : Ixon.Expr := .ref 2 #[0, 0, 1] + let parent : Ixon.Expr := if (← rand 2) == 0 then .app c1 c2 else arr c1 c2 + let mut roots : Array Ixon.Expr := #[] + for a in atoms do + for _ in [0:2 + (← rand 3)] do roots := roots.push a + for _ in [0:8 + (← rand 15)] do roots := roots.push (.app (.var 1) parent) + roots := roots.push c1 + roots := roots.push c2 + return roots + +def allocationTests (_ : Unit) : TestSeq := + let (checked, changed, saved, beatOther, err) := runGen 71 do + let mut checked := 0 + let mut changed := 0 + let mut saved := 0 + let mut beatOther := 0 + let mut err : Option String := none + for i in [0:120] do + if err.isSome then break + let roots ← if i % 2 == 0 then genHeavyParent else genRoots 6 16 5 + let c := wrapRoots roots i + let l := ShareLayout.tagN + match canonicalSharingTieredTable l #[] (constantInfoRoots c.info), + normalizeConstantSharingTiered l c with + | .ok r, .ok n => + checked := checked + 1 + if r.stats.finalRefCost < r.stats.phase1RefCost then changed := changed + 1 + if r.stats.savings > 0 then saved := saved + 1 + let fixedOk := cbytes n == fixedConstantBytes c + r.result.variableBytes + let idem := (normalizeConstantSharingTiered l n).toOption.map serConstant == + some (serConstant n) + -- every candidate run alone has its recorded length, and the result + -- is the candidate at its winning width + let candOk := candidatesOk l c r + if r.stats.candidateLengths.any (·.2 > r.stats.phase3LayoutBytes) then + beatOther := beatOther + 1 + unless r.stats.phase3LayoutBytes ≤ r.stats.phase1LayoutBytes && + r.stats.finalRefCost ≤ r.stats.phase1RefCost && fixedOk && idem && + selectionOk r && candOk && + r.result.modelBytes == r.result.variableBytes do + err := some s!"case {i} {reprStr l}: phase1={r.stats.phase1LayoutBytes} final={r.stats.phase3LayoutBytes} refcost {r.stats.phase1RefCost}->{r.stats.finalRefCost} fixed={fixedOk} idem={idem} selection={selectionOk r} {r.stats.candidateLengths} candidates={candOk}" + | .error e, _ | _, .error e => err := some s!"case {i} {reprStr l}: error {reprStr e}" + return (checked, changed, saved, beatOther, err) + group "slot allocation and re-materialization" <| + test s!"{checked} runs (120 inputs, TagN layout): final ≤ phase 1 in layout bytes and in reference cost; serialized = fixed + variable; wire price = serialized; idempotent; the fewest bytes over w = 1, 2, 3 (lower w at a tie), each candidate as when run alone ({changed} runs where allocation lowered the reference cost, {saved} with positive savings, {beatOther} where another width was longer)" + (err.isNone && checked == 120 && changed > 0) ++ + (match err with | some m => test m false | none => .done) + + +/-- Brute force over all subsets: dependency-closed, at most `cap` terms, +maximum weight, ties by the greatest indicator vector in the order +(weight descending, ID ascending). -/ +def bruteTier (n : Nat) (weight : Array Nat) (deps : Array (Array Nat)) (cap : Nat) : + Array Nat := Id.run do + let items := (Array.range n).qsort fun a b => + weight[a]! > weight[b]! || (weight[a]! == weight[b]! && a < b) + let mut best : Option (Nat × Array Bool) := none + for mask in [0:2 ^ n] do + let inS (t : Nat) := (mask >>> t) % 2 == 1 + let members := (Array.range n).filter inS + if members.size > cap then continue + unless members.all (fun t => deps[t]!.all inS) do continue + let wsum := members.foldl (fun acc t => acc + weight[t]!) 0 + let vec := items.map inS + let better := match best with + | none => true + | some (bw, bv) => + wsum > bw || (wsum == bw && Id.run do + for h : i in [0:vec.size] do + if vec[i] != bv[i]! then return vec[i] + return false) + if better then best := some (wsum, vec) + match best with + | some (_, vec) => (items.zipIdx.filter (fun (_, i) => vec[i]!)).map (·.1) |>.qsort (· < ·) + | none => #[] + +def tierBruteTests (_ : Unit) : TestSeq := + let (checked, err) := runGen 73 do + let mut checked := 0 + let mut err : Option String := none + for i in [0:300] do + if err.isSome then break + let n := 1 + (← rand 12) + let mut weight : Array Nat := #[] + let mut deps : Array (Array Nat) := #[] + for t in [0:n] do + weight := weight.push (1 + (← rand 4)) + let mut ds : Array Nat := #[] + for u in [0:t] do + if (← rand 4) == 0 then ds := ds.push u + deps := deps.push ds + let cap := min 8 (1 + (← rand n)) + match firstTier (Array.range n) (weight[·]!) (fun t => deps[t]!.toList) cap {} with + | .ok (s, _) => + checked := checked + 1 + let expected := bruteTier n weight deps cap + unless s == expected do + err := some s!"case {i}: n={n} cap={cap} weights={weight} deps={deps} search={s} brute={expected}" + | .error e => err := some s!"case {i}: error {reprStr e}" + return (checked, err) + group "first-tier allocation vs brute force" <| + test s!"{checked} random dependency DAGs (≤ 12 terms, cap ≤ 8, weights 1–4): branch and bound = enumeration, including ties" + (err.isNone && checked == 300) ++ + (match err with | some m => test m false | none => .done) + +/-- Reference Kahn priority order: repeatedly the remaining term whose +dependencies in `rest` are all placed, of the largest weight, then the +smallest ID. -/ +def kahnRef (weight : Nat → Nat) (deps : Nat → List Nat) (rest : Array Nat) : Array Nat := + Id.run do + let mut out : Array Nat := #[] + let mut remaining := rest.toList + for _ in [0:rest.size] do + let ready := remaining.filter fun t => + (deps t).all fun d => !rest.contains d || out.contains d + match ready.foldl (fun acc t => match acc with + | none => some t + | some a => if tierOrder weight t a && t != a then some t else acc) none with + | none => break + | some t => + out := out.push t + remaining := remaining.erase t + return out + +def kahnTests (_ : Unit) : TestSeq := + let (checked, err) := runGen 91 do + let mut checked := 0 + let mut err : Option String := none + for i in [0:300] do + if err.isSome then break + let n := 1 + (← rand 30) + let mut weight : Array Nat := #[] + let mut deps : Array (List Nat) := #[] + let mut rest : Array Nat := #[] + for t in [0:n] do + weight := weight.push (1 + (← rand 5)) + let mut ds : List Nat := [] + for u in [0:t] do + if (← rand 5) == 0 then ds := u :: ds + -- occasional repeated references + if (← rand 4) == 0 then if let some d := ds.head? then ds := d :: ds + deps := deps.push ds + if (← rand 4) != 0 then rest := rest.push t + let got := kahnOrder (weight[·]!) (deps[·]!) rest + let want := kahnRef (weight[·]!) (deps[·]!) rest + checked := checked + 1 + unless got == want do + err := some s!"case {i}: weights={weight} deps={deps} rest={rest} kahn={got} reference={want}" + return (checked, err) + group "Kahn priority order" <| + test s!"{checked} random dependency DAGs (≤ 30 terms, weights 1–5, repeated references, dependencies outside the set): kahnOrder = the reference order" + (err.isNone && checked == 300) ++ + (match err with | some m => test m false | none => .done) + +/-- An application spine of `1 + apps` nodes over `u = app(var 0, var 1)` +(the spine's last term), next to hot references: 100 copies of the spine, 20 +of `u`, and 500 of each of eight references. With `apps = 1287` the phase-2 +order of one candidate stores the spine before `u`, so phase 3 cannot price +it from the whole dictionary; with `apps = 1286` every candidate's order +allows it. -/ +def spineWitness (apps : Nat) : Array Ixon.Expr := Id.run do + let u : Ixon.Expr := .app (.var 0) (.var 1) + let t := (List.range apps).foldl (fun acc i => .app acc (.var (2 + i).toUInt64)) u + let mut roots : Array Ixon.Expr := (Array.replicate 100 t) ++ Array.replicate 20 u + for h in [0:8] do + roots := roots ++ Array.replicate 500 (.ref (100 + h).toUInt64 #[0, 0]) + return roots + +/-- The phase-3 materialization against the per-prefix specification: the +same entries, roots, predicted length and work, or the same error. -/ +def sameMaterialization (p : Prep) (order roots : Array Nat) (widthAt : Nat → Nat) : Bool := + match materializeTableOnePass p order roots {} widthAt, materializeTable p order roots {} widthAt with + | .ok (e1, r1, p1, w1), .ok (e2, r2, p2, w2) => e1 == e2 && r1 == r2 && p1 == p2 && w1 == w2 + | .error e1, .error e2 => reprStr e1 == reprStr e2 + | _, _ => false + +/-- Per candidate width: whether its table order takes the per-prefix path, +and whether the one-pass materialization agrees with the specification. -/ +def candidatePaths (roots : Array Ixon.Expr) : + Except SharingError (Array (Nat × Bool × Bool)) := do + let ex ← expand {} #[] roots true + let p := Prep.ofDag ex.dag + [1, 2, 3].toArray.mapM fun w => do + let r ← tieredAtWidth .tagN {} ex w + let order := r.result.tableTerms + let onePass := onePassOrder ex.dag order ex.roots (indexOfPrefix ex.dag.size order order.size) + return (w, !onePass, sameMaterialization p order ex.roots ShareLayout.tagN.widthAt) + +def fallbackTests (_ : Unit) : TestSeq := + withOk "spine witness" (candidatePaths (spineWitness 1287)) (fun paths => + withOk "spine witness" (canonicalSharingTieredTable .tagN #[] (spineWitness 1287)) fun r => + let perPrefix := (paths.filter (·.2.1)).size + test s!"spine of 1288 nodes: {perPrefix} candidate takes the per-prefix path (expected 1), candidates {r.stats.candidateLengths} (expected #[(1, 7106), (2, 7106), (3, 7123)]), every candidate equal to the specification" + (perPrefix == 1 && paths.all (·.2.2) && + r.stats.candidateLengths == #[(1, 7106), (2, 7106), (3, 7123)])) ++ + withOk "spine control" (candidatePaths (spineWitness 1286)) fun paths => + let perPrefix := (paths.filter (·.2.1)).size + test s!"spine of 1287 nodes: {perPrefix} candidates take the per-prefix path (expected 0), every candidate equal to the specification" + (perPrefix == 0 && paths.all (·.2.2)) + +def layoutTests (_ : Unit) : TestSeq := + test "TagN widths: 1 below 8, 2 below 1032, 3 below 66568, 4 below 16843784, 5 below 4311811080, then 9" + ([7, 8, 1031, 1032, 66567, 66568, 16843783, 16843784, 4311811079, 4311811080].map + ShareLayout.tagN.widthAt == [1, 2, 2, 3, 3, 4, 4, 5, 5, 9] && + tagNRung2End == 1032 && tagNRung3End == 66568 && tagNRung4End == 16843784 && + tagNRung5End == 4311811080) + +/-! ## The production construction at scale -/ + +/-- `fillers` terms `X_i` (7-byte Refs), each used once directly and twice +inside each of the wrappers `app (var 0) X_i` and `app (var 1) X_i`, and +`chains` pairs: `A_j` (a 7-byte Ref used three times directly and once inside +`B_j`) and the binder `B_j`, used 40 times. + +With more than 1,032 fillers the table crosses the 3-byte TagN rung, and the +DAG (more than `tieredParMin` terms) takes the parallel-widths branch of +`tieredCandidates`. At phase-1 widths 2 and 3 the wrappers stay inline, so a +filler's Share count (5) exceeds its in-degree (3), while `A_j` has 4 of +each: the phase-1 order (in-degree first) places every chain early, the +phase-2 Kahn order (Share count first) places the chains outside the first +tier after every filler, beyond index 1,032, and the guard keeps the phase-1 +order. -/ +def scaleRoots (fillers chains : Nat) : Array Ixon.Expr := Id.run do + let mut roots : Array Ixon.Expr := #[] + for i in [0:fillers] do + let x : Ixon.Expr := .ref i.toUInt64 #[0, 0, 0, 0, 0] + roots := roots.push x + for _ in [0:2] do roots := roots.push (.app (.var 0) x) + for _ in [0:2] do roots := roots.push (.app (.var 1) x) + for j in [0:chains] do + let a : Ixon.Expr := .ref (fillers + 2 * j).toUInt64 #[0, 0, 0, 0, 0] + let b : Ixon.Expr := .lam .many a (.app (.var 0) (.ref (fillers + 2 * j + 1).toUInt64 #[0])) + for _ in [0:3] do roots := roots.push a + for _ in [0:40] do roots := roots.push b + return roots + +/-- An App spine of `n` arguments whose head is the repeated (stored) term +`s`, next to `s` itself: the spine's telescope count is in the 3-byte TagN +rung for `n ≥ 1032`. -/ +def spineRoots (n : Nat) : Array Ixon.Expr := + let s : Ixon.Expr := .ref 3 #[0, 0, 0, 0, 0] + #[(List.range n).foldl (fun acc i => .app acc (.var (i % 3).toUInt64)) s, s, s] + +/-- The checks of one production run on `c`: the result is the candidate at +its winning width with every candidate as when run alone +(`candidatesOk`, which runs the widths one after the other), the serialized +length is the fixed part plus the variable bytes, the wire price equals the +serialized length, and normalizing the output reproduces it. -/ +def productionOk (c : Constant) (r : TieredSharingResult) (n : Constant) : Bool := + selectionOk r && candidatesOk .tagN c r && + cbytes n == fixedConstantBytes c + r.result.variableBytes && + r.result.modelBytes == r.result.variableBytes && + (normalizeConstantSharingTiered .tagN n).toOption.map serConstant == some (serConstant n) + +def scaleTests (_ : Unit) : TestSeq := + let big := wrapRoots (scaleRoots 1040 12) 0 + let spine := wrapRoots (spineRoots 1288) 0 + let d := 10000 + let shared : Ixon.Expr := .ref 5 #[0, 0, 0, 0, 0] + let nested : Ixon.Expr := + (List.range d).foldl (fun acc i => .app (.var (i % 2).toUInt64) acc) shared + let telescope : Ixon.Expr := + (List.range d).foldl (fun acc i => .lam .many (.var (i % 3).toUInt64) acc) shared + let deep := wrapRoots #[nested, telescope, shared] 0 + group "the production construction at scale" <| + withOk "1040 fillers" (canonicalSharingTieredTable .tagN #[] (constantInfoRoots big.info)) + (fun r => withOk "1040 fillers" (normalizeConstantSharingTiered .tagN big) fun n => + test s!"{r.result.stats.distinctSubterms} terms (parallel widths, ≥ {tieredParMin}), {n.sharing.size} entries (> 1032: 3-byte Shares), the phase-2 guard keeps the phase-1 order (reference cost {r.stats.phase1RefCost}); widths run alone agree, idempotent, serialized = fixed + variable" + (r.result.stats.distinctSubterms ≥ tieredParMin && n.sharing.size > 1032 && + r.stats.keptPhase1Order && r.stats.finalRefCost == r.stats.phase1RefCost && + productionOk big r n)) ++ + withOk "spine" (canonicalSharingTieredTable .tagN #[] (constantInfoRoots spine.info)) + (fun r => withOk "spine" (normalizeConstantSharingTiered .tagN spine) fun n => + test s!"a 1288-argument App spine over a stored head: {cbytes n} bytes, {n.sharing.size} entries; widths run alone agree, idempotent, serialized = fixed + variable" + (n.sharing.size ≥ 1 && productionOk spine r n)) ++ + withOk "deep" (canonicalSharingTieredTable .tagN #[] (constantInfoRoots deep.info)) + (fun r => withOk "deep" (normalizeConstantSharingTiered .tagN deep) fun n => + test s!"{d}-deep argument nesting and a {d}-binder telescope over a shared Ref: {cbytes n} bytes, {n.sharing.size} entries; widths run alone agree, idempotent, serialized = fixed + variable" + (n.sharing.size ≥ 1 && productionOk deep r n)) + +/-! ## The production construction under its limits -/ + +/-- `canonicalSharingTiered` on `roots` under the default limits with one +limit changed fails with exactly `resourceExhausted r v`. -/ +def failsWith (roots : Array Ixon.Expr) (l : Limits) (r : Resource) (v : Nat) : Bool := + match canonicalSharingTiered .tagN roots l with + | .error (.resourceExhausted r' v') => r' == r && v' == v + | _ => false + +/-- The compiler's builder on `c` under `l` fails with the `resourceLimit` +error naming the limit `key`, its value and its override. -/ +def compilerFailsWith (c : Constant) (l : Limits) (key : String) (v : Nat) : Bool := + match Ix.CompileM.buildConstantWithSharing l c.info c.refs c.univs with + | .error (.resourceLimit msg) => + (msg.splitOn s!"resource exhausted: {key} (limit {v})").length > 1 && + (msg.splitOn s!"--sharing-limits {key}=N (IX_SHARING_LIMITS)").length > 1 + | _ => false + +def productionLimitTests (_ : Unit) : TestSeq := + let t16c := axiomOf (arr (chain 16) (chain 16)) + let t16 := constantInfoRoots t16c.info + -- 128 two-use atoms: 128 uncertain components and the table-count bracket + -- knapsack (`Tests.SharingUniform.bracketTests`). + let atomRoots : Array Ixon.Expr := (Array.range 128).foldl + (fun acc i => let a : Ixon.Expr := .ref i.toUInt64 #[0]; acc ++ #[a, a]) #[] + let atomsC := wrapRoots atomRoots 0 + let d : Limits := {} + let cases : List (String × Constant × Limits × Resource × Nat) := [ + ("T16", t16c, { d with maxExprVisits := 3 }, .exprVisits, 3), + ("T16", t16c, { d with maxDepth := 2 }, .depth, 2), + ("T16", t16c, { d with maxNodes := 2 }, .nodes, 2), + ("T16", t16c, { d with maxStates := 0 }, .states, 0), + ("128 atoms", atomsC, { d with maxStates := 50 }, .states, 50), + ("128 atoms", atomsC, { d with maxCostEvals := 10 }, .costEvals, 10), + ("T16", t16c, { d with maxOutputBytes := 10 }, .outputBytes, 10), + ("T16", t16c, { d with maxMaterialize := 3 }, .materialize, 3), + ("T16", t16c, { d with maxMaterializeWork := 3 }, .materializeWork, 3), + ("128 atoms", atomsC, { d with maxKnapsackCells := 10 }, .knapsackCells, 10)] + group "the production construction under its limits" <| + cases.foldl (init := .done) (fun acc (name, c, l, r, v) => + acc ++ test s!"{name}: {r.key} = {v} → canonicalSharingTiered fails with resourceExhausted {r.key} {v}; the compiler's builder with resourceLimit naming --sharing-limits {r.key}=N" + (failsWith (constantInfoRoots c.info) l r v && compilerFailsWith c l r.key v)) ++ + test "the transitions limit meters only the width-state oracle: maxTransitions = 0 leaves T16 and the 128 atoms unchanged" + ((canonicalSharingTiered .tagN t16 { d with maxTransitions := 0 }).toOption.map + (·.result.sharing) == (canonicalSharingTiered .tagN t16).toOption.map (·.result.sharing) && + (canonicalSharingTiered .tagN atomRoots { d with maxTransitions := 0 }).toOption.map + (·.result.variableBytes) == + (canonicalSharingTiered .tagN atomRoots).toOption.map (·.result.variableBytes) && + (canonicalSharingTiered .tagN t16).toOption.isSome) + +public def suite : List TestSeq := [ + deferred "tiered layouts" layoutTests, + deferred "tiered fixtures" fixtureTests, + deferred "tiered allocation" allocationTests, + deferred "first-tier brute force" tierBruteTests, + deferred "Kahn priority order" kahnTests, + deferred "phase-3 per-prefix fallback" fallbackTests, + deferred "tiered at scale" scaleTests, + deferred "tiered limits" productionLimitTests, +] + +end Tests.SharingTiered diff --git a/Tests/Ix/SharingUniform.lean b/Tests/Ix/SharingUniform.lean new file mode 100644 index 000000000..9dda176fa --- /dev/null +++ b/Tests/Ix/SharingUniform.lean @@ -0,0 +1,378 @@ +/- + Tests for the uniform-width exact optimizer (`Ix.Sharing.Exact.Uniform`). + + The reference is the width-state search run with every Share priced `w` + (`optimizeSharingUniformReference`), which explores all table orders and + subsets of the R1/R2 candidates. On every generated input we check: + * equal minimum model length; + * every certain-stored term is in the reference optimum, and no + certain-excluded term is (both classes are "every/no minimum" claims); + * model length ≤ unshared; the output re-expands to the input (checked + inside the optimizer). + Inputs include spine prefixes used only as prefixes, Apps with a 2-byte + payload, and parent/child pairs whose sharing interacts. +-/ +module + +public import Tests.Ix.SharingExact + +public section + +open LSpec Ixon Ix.Sharing.Exact Tests.SharingExact + +-- Groups are functions run from deferred IO actions. +set_option compiler.extract_closed false + +namespace Tests.SharingUniform + +/-- Independent uniform-model cost of independent atoms: choose a subset, +pay its entries and `w` per use, inline the rest. -/ +def atomsUniformBrute (w : Nat) (sizes occs : Array Nat) : Nat := Id.run do + let n := sizes.size + let mut best := 0 + for mask in [0:2 ^ n] do + let inS (i : Nat) := (mask >>> i) % 2 == 1 + let mut cost := tag0Size ((List.range n).filter inS).length + for i in [0:n] do + cost := cost + (if inS i then sizes[i]! + occs[i]! * w else occs[i]! * sizes[i]!) + if mask == 0 || cost < best then best := cost + return best + +/-- Spine prefixes `f a` that only occur as prefixes of longer spines. -/ +def genPrefixes : RGen (Array Ixon.Expr) := do + let f ← genLeaf + let a ← genLeaf + let b ← genLeaf + let pre : Ixon.Expr := if (← rand 2) == 0 then .app f a else .app (.app f a) b + let mut roots : Array Ixon.Expr := #[] + for i in [0:2 + (← rand 4)] do + let x : Ixon.Expr := .var (i % 3).toUInt64 + let y ← genLeaf + roots := roots.push (if (← rand 2) == 0 then .app pre x else .app (.app pre x) y) + return roots + +/-- Apps with a 2-byte payload used in several head positions. -/ +def genSmallPayload : RGen (Array Ixon.Expr) := do + let e : Ixon.Expr := .app (.var (← rand 2).toUInt64) (.var 1) + let mut roots : Array Ixon.Expr := #[] + for _ in [0:2 + (← rand 5)] do + roots := roots.push <| match ← rand 3 with + | 0 => .app (.ref 1 #[]) e + | 1 => .lam .many e (.var 0) + | _ => arr e (.sort 0) + return roots + +/-- A child `c` inside a parent `p`, each used a few times. -/ +def genPairs : RGen (Array Ixon.Expr) := do + let pool ← (List.range 3).toArray.mapM fun _ => genLeaf + let c ← genNode pool + let p : Ixon.Expr := match ← rand 3 with + | 0 => .app c pool[0]! + | 1 => arr pool[1]! c + | _ => .prj 0 1 c + let mut roots : Array Ixon.Expr := #[] + for _ in [0:1 + (← rand 4)] do roots := roots.push (.app (.var 2) p) + for _ in [0:1 + (← rand 4)] do roots := roots.push (.lam .many c (.var 0)) + return roots + +/-- A nested App chain `u₁ = f a₁`, `uᵢ₊₁ = uᵢ aᵢ₊₁` whose prefixes are also +used on their own, so uncertain terms connect along the chain. -/ +def genChain : RGen (Array Ixon.Expr) := do + let leaves ← (List.range 3).toArray.mapM fun _ => genLeaf + let mut u : Ixon.Expr := .app leaves[0]! leaves[1]! + let mut roots : Array Ixon.Expr := #[] + for _ in [0:3 + (← rand 6)] do + for _ in [0:1 + (← rand 2)] do + roots := roots.push (if (← rand 2) == 0 then .app (.var 7) u else arr u (.sort 0)) + u := .app u leaves[← rand 3]! + roots := roots.push u + return roots + +def genUniformRoots : RGen (Array Ixon.Expr) := do + match ← rand 6 with + | 0 => genPrefixes + | 1 => genSmallPayload + | 2 => genPairs + | 3 => genChain + | _ => genRoots 5 12 4 + +/-- Check one input at width `w` against the reference. Returns +`(checked?, stats)` or an error message. -/ +def checkUniform (w : Nat) (roots : Array Ixon.Expr) : + Except String (Nat × Nat × Nat × Nat) := + match optimizeSharingUniform w roots, optimizeSharingUniformReference w roots, + optimizeSharingUniformReference w roots {} (minInDegree2 := true) with + | .ok u, .ok r, .ok rr => + let refSet := r.tableTerms + if u.result.modelBytes != r.modelBytes || rr.modelBytes != r.modelBytes then + .error s!"w={w}: uniform={u.result.modelBytes} reference={r.modelBytes} restricted={rr.modelBytes} stored={u.stored} ref={refSet} roots={reprStr roots}" + else if !u.certainStored.all rr.tableTerms.contains then + .error s!"w={w}: certain-stored {u.certainStored} not in restricted reference optimum {rr.tableTerms} roots={reprStr roots}" + else if u.certainExcluded.any refSet.contains || u.certainExcluded.any rr.tableTerms.contains then + .error s!"w={w}: certain-excluded {u.certainExcluded} in reference optimum {refSet} roots={reprStr roots}" + else if u.result.modelBytes > u.result.unsharedBytes then + .error s!"w={w}: model {u.result.modelBytes} > unshared {u.result.unsharedBytes}" + else + let maxComp := u.components.foldl (fun acc c => max acc c.size) 0 + .ok (u.certainStored.size, u.certainExcluded.size, u.uncertain.size, maxComp) + | .error e, _, _ => .error s!"w={w}: uniform error {reprStr e} roots={reprStr roots}" + | _, .error e, _ | _, _, .error e => .error s!"w={w}: reference error {reprStr e} roots={reprStr roots}" + +def agreementTests (_ : Unit) : TestSeq := + let (checked, cs, ce, un, maxComp, withUncertain, err) := runGen 61 do + let mut checked := 0 + let mut cs := 0 + let mut ce := 0 + let mut un := 0 + let mut maxComp := 0 + let mut withUncertain := 0 + let mut err : Option String := none + for i in [0:3000] do + if checked ≥ 400 || err.isSome then break + let roots ← genUniformRoots + let w := [1, 2, 3, 5][← rand 4]! + -- Keep the reference search small. + let refCands := match sharingProfile (wrapRoots roots 0) with + | .ok p => p.candidates + | .error _ => 100 + if refCands > 11 then continue + match checkUniform w roots with + | .ok (a, b, c, m) => + checked := checked + 1 + cs := cs + a + ce := ce + b + un := un + c + maxComp := max maxComp m + if c > 0 then withUncertain := withUncertain + 1 + | .error m => err := some s!"case {i}: {m}" + return (checked, cs, ce, un, maxComp, withUncertain, err) + group "uniform optimizer vs width-state reference (uniform widths)" <| + test s!"{checked} generated inputs (w ∈ 1,2,3,5; prefixes, 2-byte payloads, parent/child pairs, App chains, general): equal minimum (also = in-degree-≥2 reference); certain-stored ⊆ restricted optimum; certain-excluded in neither optimum; ≤ unshared ({cs} certain-stored, {ce} certain-excluded, {un} uncertain terms; {withUncertain} inputs with uncertain terms; largest component {maxComp})" + (err.isNone && checked == 400) ++ + (match err with | some m => test m false | none => .done) + +def witnessTests (_ : Unit) : TestSeq := + let roots := constantInfoRoots witness2.info + let run (w : Nat) := optimizeSharingUniform w roots + group "uniform witness T2 → T2 (ids P=0 T1=1 T2=2 R=3)" <| + withOk "w=1" (run 1) (fun u => + test s!"w=1: T2 certain-stored, stores only T2, model {u.result.modelBytes} = 11" + (u.certainStored == #[2] && u.stored == #[2] && u.result.modelBytes == 11 && + u.result.variableBytes == 11)) ++ + withOk "w=2" (run 2) (fun u => + test s!"w=2: T2 has gain 1, certain-stored at threshold 1 (no count bracket within reach), stores only T2, model {u.result.modelBytes} = 13" + (u.certainStored == #[2] && u.stored == #[2] && u.result.modelBytes == 13)) ++ + withOk "w=3" (run 3) (fun u => + test s!"w=3: T2 uncertain, search stores nothing, model {u.result.modelBytes} = 14 (unshared); T1 certain-excluded" + (u.uncertain == #[2] && u.stored.isEmpty && u.result.modelBytes == 14 && + u.certainExcluded.contains 1)) ++ + test "w=1,2,3 agree with the reference search" + ([1, 2, 3].all fun w => (checkUniform w roots).toOption.isSome) ++ + test "w=0 is rejected" (isErr (optimizeSharingUniform 0 roots) fun + | .formatBound _ _ => true + | _ => false) + +def t16Tests (_ : Unit) : TestSeq := + let roots := constantInfoRoots (axiomOf (arr (chain 16) (chain 16))).info + group "uniform T16 → T16" <| + withOk "w=1" (optimizeSharingUniform 1 roots) (fun u => + withOk "reference" (optimizeSharingUniformReference 1 roots) fun r => + test s!"w=1: model {u.result.modelBytes} = reference {r.modelBytes}; classes {u.certainStored.size} stored / {u.uncertain.size} uncertain / {u.certainExcluded.size} excluded; {u.statesVisited} states vs reference {r.stats.statesReached}" + (u.result.modelBytes == r.modelBytes && (checkUniform 1 roots).toOption.isSome)) + +/-- 128 and 129 independent atoms whose sharing saves exactly one byte each: +the table count crosses 128. -/ +def bracketTests (_ : Unit) : TestSeq := + let atoms (n : Nat) : Array Ixon.Expr := (Array.range n).map fun i => .ref i.toUInt64 #[0] + let rootsOf (n : Nat) := (atoms n).foldl (fun acc a => acc ++ #[a, a]) #[] + let sizes (n : Nat) := (atoms n).map exprSize + group "table-count bracket coupling" <| + withOk "128 atoms" (optimizeSharingUniform 1 (rootsOf 128)) (fun u => + test s!"128 atoms: all uncertain; storing 127 ties storing 128 (one count byte); the tie order leaves out the smallest ID; model {u.result.modelBytes} = 642" + (u.uncertain.size == 128 && u.stored.size == 127 && !u.stored.contains 0 && + u.lowerBracket && u.result.modelBytes == 1 + 127 * 5 + 6 && + u.result.modelBytes == 2 + 128 * 5)) ++ + withOk "129 atoms" (optimizeSharingUniform 1 (rootsOf 129)) (fun u => + test s!"129 atoms (the last, Ref(128), is 4 bytes and certain-stored): keeps all 129, model {u.result.modelBytes} = 648" + (u.stored.size == 129 && !u.lowerBracket && u.certainStored == #[128] && + u.result.modelBytes == 2 + 128 * 5 + 6)) ++ + test "atom brute force agrees on 10 atoms with mixed sizes and uses" + (let as : Array Ixon.Expr := (Array.range 10).map fun i => + .ref i.toUInt64 (Array.replicate (i % 3) 0) + let occs := (Array.range 10).map fun i => 1 + i % 4 + let roots := (Array.range 10).foldl (fun acc i => acc ++ Array.replicate occs[i]! as[i]!) #[] + [1, 2, 3].all fun w => + (optimizeSharingUniform w roots).toOption.map (·.result.modelBytes) == + some (atomsUniformBrute w (as.map exprSize) occs)) ++ + test "sizes" ((sizes 3).all (· == 3)) + +def propertyTests (_ : Unit) : TestSeq := + let (checked, err) := runGen 67 do + let mut checked := 0 + let mut err : Option String := none + for i in [0:200] do + if err.isSome then break + let roots ← genRoots 6 16 4 + let c := wrapRoots roots i + let w := [1, 2, 4][← rand 3]! + match normalizeConstantSharingUniform w c with + | .ok n => + checked := checked + 1 + let again := (normalizeConstantSharingUniform w n).toOption.map serConstant + let fresh := match deConstant (serConstant c) with + | .ok c' => (normalizeConstantSharingUniform w c').toOption.map serConstant + | .error _ => none + unless again == some (serConstant n) && fresh == some (serConstant n) do + err := some s!"case {i}: not idempotent or representation dependent" + | .error e => err := some s!"case {i}: error {reprStr e}" + return (checked, err) + group "uniform properties" <| + test s!"{checked} constants: normalize is idempotent and independent of pointer layout" (err.isNone && checked == 200) ++ + (match err with | some m => test m false | none => .done) + +/-- `mk a₁ … aₙ`-style prefix chains: `uₖ = uₖ₋₁ aₖ`, each prefix also +used once as the head of a longer spine with other arguments (the shape of +the `injEq` components), plus a few repeated arguments. -/ +def genPrefixChain : RGen (Array Ixon.Expr) := do + let pool ← (List.range 4).toArray.mapM fun _ => genLeaf + let len := 3 + (← rand 14) + let mut u : Ixon.Expr := pool[0]! + let mut roots : Array Ixon.Expr := #[] + for k in [0:len] do + let a : Ixon.Expr ← if (← rand 3) == 0 then do pure pool[← rand pool.size]! + else pure (.var (k % 5).toUInt64) + u := .app u a + let mut x : Ixon.Expr := .app u (.sort 1) + for _ in [0:(← rand 4)] do x := .app x pool[← rand pool.size]! + roots := roots.push (if (← rand 2) == 0 then x else arr x (.sort 0)) + roots := roots.push u + return roots + +/-- Nested binder telescopes whose prefixes and bodies repeat. -/ +def genTelescopes : RGen (Array Ixon.Expr) := do + let pool ← (List.range 4).toArray.mapM fun _ => genLeaf + let mut body : Ixon.Expr := pool[0]! + let mut roots : Array Ixon.Expr := #[] + for _ in [0:2 + (← rand 10)] do + let ty := pool[← rand pool.size]! + body ← match ← rand 3 with + | 0 => do pure (.lam (← genBinder) ty body) + | 1 => pure (arr ty body) + | _ => pure (.app body ty) + if (← rand 2) == 0 then roots := roots.push (.app (.var 3) body) + roots := roots.push body + return roots + +def genSearchRoots : RGen (Array Ixon.Expr) := do + match ← rand 7 with + | 0 => genPrefixChain + | 1 => genTelescopes + | 2 => genChain + | 3 => genSpines + | 4 => genPrefixes + | _ => genRoots 6 24 5 + +/-- The reclassifying branch and bound returns exactly what the subset +enumeration returns (same set, so the same tie-break), on inputs with larger +uncertain components. -/ +def searchTests (_ : Unit) : TestSeq := + let (checked, skipped, maxComp, err) := runGen 71 do + let mut checked := 0 + let mut skipped := 0 + let mut maxComp := 0 + let mut err : Option String := none + for i in [0:4000] do + if checked ≥ 600 || err.isSome then break + let roots ← genSearchRoots + let w := [1, 2, 3, 5][← rand 4]! + match optimizeSharingUniform w roots, + optimizeSharingUniform w roots { maxStates := 1 <<< 16, uniformSubsetSearch := true } with + | .ok u, .ok r => + let comp := u.components.foldl (fun acc c => max acc c.size) 0 + if comp < 2 then continue + checked := checked + 1 + maxComp := max maxComp comp + unless u.stored == r.stored && u.result.modelBytes == r.result.modelBytes && + u.lowerBracket == r.lowerBracket do + err := some s!"case {i} w={w}: branch and bound stored {u.stored} model {u.result.modelBytes}, subset enumeration stored {r.stored} model {r.result.modelBytes} roots={reprStr roots}" + | .ok _, .error (.resourceExhausted ..) => skipped := skipped + 1 + | .error e, _ => err := some s!"case {i} w={w}: branch and bound error {reprStr e} roots={reprStr roots}" + | _, .error e => err := some s!"case {i} w={w}: subset enumeration error {reprStr e}" + return (checked, skipped, maxComp, err) + group "uniform branch and bound vs subset enumeration" <| + test s!"{checked} generated inputs with a component of ≥ 2 uncertain terms (prefix chains, telescopes, App chains, long spines, prefixes, general; w ∈ 1,2,3,5; largest component {maxComp}; {skipped} skipped where the enumeration exceeded 2^16 states): identical stored set, model length and bracket choice" + (err.isNone && checked == 600) ++ + (match err with | some m => test m false | none => .done) + +/-- Search agreement across the 128-entry table-count bracket: 120 one-byte +atoms used twice (uncertain, gain 1) plus an App prefix chain. -/ +def searchBracketTests (_ : Unit) : TestSeq := + let atoms : Array Ixon.Expr := (Array.range 120).map fun i => .ref i.toUInt64 #[0] + let chain := runGen 5 genPrefixChain + let roots := atoms.foldl (fun acc a => acc ++ #[a, a]) #[] ++ chain + group "uniform branch and bound across a count bracket" <| + test "w=1,2,3: the branch and bound and the subset enumeration store the same set" + ([1, 2, 3].all fun w => + match optimizeSharingUniform w roots, + optimizeSharingUniform w roots { uniformSubsetSearch := true } with + | .ok u, .ok r => u.stored == r.stored && u.result.modelBytes == r.result.modelBytes + | _, _ => false) + +/-- The imperative tie order that `setPrec` replaced (kept as a reference). -/ +def setPrecLoop (a b : Array Nat) : Bool := Id.run do + let mut i := 0 + let mut j := 0 + for _ in [0:a.size + b.size + 1] do + match a[i]?, b[j]? with + | some x, some y => + if x == y then + i := i + 1 + j := j + 1 + else return y < x + | some _, none => return false + | none, some _ => return true + | none, none => return false + return false + +/-- All arrays of length at most 3 over `0..3`, sorted or not. -/ +def smallArrays : List (Array Nat) := + let step (acc : List (Array Nat)) : List (Array Nat) := + acc.flatMap fun a => (List.range 4).map a.push + let l1 := step [#[]] + let l2 := step l1 + [#[]] ++ l1 ++ l2 ++ step l2 + +/-- All subsets of `0..4` as sorted arrays. -/ +def smallSets : List (Array Nat) := + (List.range 32).map fun m => ((Array.range 5).filter fun i => (m >>> i) % 2 == 1) + +/-- Smallest element of the symmetric difference lies in `b`. -/ +def symmDiffMinIn (a b : Array Nat) : Bool := + let d := (a.filter (!b.contains ·)) ++ (b.filter (!a.contains ·)) + match d.toList.min? with + | some m => b.contains m + | none => false + +def tieOrderTests (_ : Unit) : TestSeq := + group "uniform tie order" <| + test "setPrec agrees with the imperative loop on all arrays of length ≤ 3 over 0..3" + (smallArrays.all fun a => smallArrays.all fun b => setPrec a b == setPrecLoop a b) ++ + test "on sets, setPrec a b iff the least element of the symmetric difference is in b" + (smallSets.all fun a => smallSets.all fun b => setPrec a b == symmDiffMinIn a b) ++ + test "setPrec is a strict total order on the subsets of 0..4" + (smallSets.all fun a => !setPrec a a && smallSets.all fun b => + (a == b || setPrec a b != setPrec b a) && + smallSets.all fun c => !(setPrec a b && setPrec b c) || setPrec a c) + +public def suite : List TestSeq := [ + deferred "uniform tie order" tieOrderTests, + deferred "uniform witness" witnessTests, + deferred "uniform vs reference" agreementTests, + deferred "uniform T16" t16Tests, + deferred "uniform table-count brackets" bracketTests, + deferred "uniform properties" propertyTests, + deferred "uniform search vs enumeration" searchTests, + deferred "uniform search across a bracket" searchBracketTests, +] + +end Tests.SharingUniform diff --git a/Tests/Ix/Tc/ParityEnv.lean b/Tests/Ix/Tc/ParityEnv.lean index 9b2afb0bf..98e68d2c4 100644 --- a/Tests/Ix/Tc/ParityEnv.lean +++ b/Tests/Ix/Tc/ParityEnv.lean @@ -20,7 +20,17 @@ namespace Tests.Tc.ParityEnv open Lean -/-- Path to the parity `.ixe`, compiling it from the seed closure if absent. +/-- The format version in the `.ixe` header at `path`, or `none` when the file +does not start with an env header. -/ +def headerVersion? (path : System.FilePath) : IO (Option UInt64) := do + let head ← (← IO.FS.Handle.mk path .read).read 16 + return match Ixon.runGet (Ixon.getTagN 4) head with + | .ok tag => if tag.flag == Ixon.Env.FLAG then some tag.value else none + | .error _ => none + +/-- Path to the parity `.ixe`, compiling it from the seed closure if absent or +written under another `.ixe` format version (a cached file from before a format +change is unreadable, so it is rebuilt rather than failing every reader). `buildFile` first: the test suite only builds what `IxTests` needs, not the rest of `Ix.lean`'s closure (e.g. the benchmarks it also imports), and `getFileEnv` needs every olean present. Then it loads the env and hands the transitive seed @@ -28,9 +38,17 @@ closure to the same FFI compile step `ix compile` uses. A seed that no longer resolves is a hard error, not a skip. -/ public def ensure : IO System.FilePath := do let out : System.FilePath := "tc-parity.ixe" - if ← out.pathExists then return out let constsFile := ".github/fixtures/tc-parity-consts.txt" - IO.println s!"tc-parity: {out} not found — compiling from {constsFile}" + if ← out.pathExists then + match ← headerVersion? out with + | some version => + if version == Ixon.Env.VERSION then return out + IO.println s!"tc-parity: {out} has .ixe format version {version}, expected \ + {Ixon.Env.VERSION} — recompiling from {constsFile}" + | none => + IO.println s!"tc-parity: {out} has no .ixe header — recompiling from {constsFile}" + else + IO.println s!"tc-parity: {out} not found — compiling from {constsFile}" buildFile "Ix.lean" let leanEnv ← getFileEnv "Ix.lean" let raw ← Ix.Cli.ConstsFile.read constsFile diff --git a/Tests/IxonV3Main.lean b/Tests/IxonV3Main.lean deleted file mode 100644 index 005803403..000000000 --- a/Tests/IxonV3Main.lean +++ /dev/null @@ -1,53 +0,0 @@ -import Tests.Ix.IxonV3 -import Tests.Ix.IxonV3FFI -import Tests.Ix.IxonV3VM -import Tests.Ix.IxonV3Text -import Tests.Ix.ResourceAdmit -import Tests.Ix.ResourceAddressed -import Tests.Ix.ResourceValidate -import Tests.Ix.ContractTransport -import Tests.Ix.ContractPipeline -import Tests.Ix.ContractDecompile -import Tests.Ix.ClaimsV3 -import Tests.Ix.Catalog -import Tests.Ix.Kernel.PrimAddrs -import Tests.Ix.SourceContract -import Tests.Ix.SourceContract.ImportCheck -import Tests.Ix.SourceContract.SyntaxCheck -import Tests.Ix.SourceContract.Driver -import Tests.IxonV3Handoff - -def main (args : List String) : IO Unit := do - if args.contains "--export-handoff" then - Tests.IxonV3Handoff.writeArtifacts "/tmp/ixon-v3-handoff" - else - Tests.IxonV3Handoff.check "Tests/Fixtures/ixon-v3/handoff" - let cases ← Tests.IxonV3.readExprCases - let checks ← Tests.IxonV3.runGolden cases - IO.println s!"Ixon v3: {checks} golden byte and rejection checks passed" - let ffiChecks ← Tests.IxonV3.runFFI cases - IO.println s!"Ixon v3: {ffiChecks} FFI, byte parity, and sharing hash checks passed" - let vmChecks ← Tests.IxonV3.runVM cases - IO.println s!"Ixon v3: {vmChecks} VM execution, interpretation, and proof checks passed" - let textChecks ← Tests.IxonV3.runText - IO.println s!"Ixon v3: {textChecks} text contract and rejection checks passed" - Tests.Resource.run - Tests.Resource.runAdmission - Tests.ResourceAddressed.run - Tests.ResourceValidate.run - Tests.ContractTransport.run - Tests.ContractPipeline.run - Tests.ContractDecompile.run - Tests.ClaimsV3.run - let result ← LSpec.lspecIO (.ofList [ - ("v3 catalogs", Tests.Ix.Catalog.suite), - ("primitive addresses", Tests.Ix.Kernel.PrimAddrs.suite), - ("source contracts", Tests.Ix.SourceContract.suite ++ - Tests.Ix.SourceContract.Driver.suite)]) [] - unless result == 0 do throw <| IO.userError "primitive or source contract regression" - if args.contains "--primitives" then - let bytes ← IO.FS.readBinFile "/tmp/ixon-v3-primitives.ixe" - let env ← IO.ofExcept (Ixon.runGetExact Ixon.Env.getEnv bytes) - IO.println s!"Validating {env.consts.size} constants from the primitive closure" - let resolved ← IO.ofExcept (Ix.Resource.validate env (Ix.Resource.standardProfile env)) - IO.println s!"Validated {resolved.addresses.size} addressed interfaces" diff --git a/Tests/IxonV3Primitives.lean b/Tests/IxonV3Primitives.lean deleted file mode 100644 index 48676c282..000000000 --- a/Tests/IxonV3Primitives.lean +++ /dev/null @@ -1,22 +0,0 @@ -import Tests.Ix.Kernel.BuildPrimitives - -open Tests.Ix.Kernel.BuildPrimitives - -def main : IO Unit := do - let leanEnv ← get_env! - let needed := collectDeps leanEnv (kernelPrimitives.map parseNameToLean) - let constants := leanEnv.constants.toList.filter fun (name, _) => needed.contains name - IO.println s!"Compiling {constants.length} primitive dependency declarations" - let raw ← Ix.CompileM.rsCompileEnvFFI constants - let env := raw.toEnv - let mut text := "# Ixon v3 canonical primitive addresses\n" - for name in kernelPrimitives do - let some named := env.named[parseIxName name]? - | throw <| IO.userError s!"missing primitive {name}" - text := text ++ s!"{name}\t{named.addr}\n" - IO.FS.writeFile "/tmp/ixon-v3-primitives.tsv" text - let bytes ← match Ixon.serEnv env with - | .ok bytes => pure bytes - | .error error => throw <| IO.userError error - IO.FS.writeBinFile "/tmp/ixon-v3-primitives.ixe" bytes - IO.println s!"Exported {kernelPrimitives.size} primitive addresses and {env.consts.size} constants" diff --git a/Tests/IxonV3Handoff.lean b/Tests/IxonV4Handoff.lean similarity index 93% rename from Tests/IxonV3Handoff.lean rename to Tests/IxonV4Handoff.lean index 61f0c276c..504e7043b 100644 --- a/Tests/IxonV3Handoff.lean +++ b/Tests/IxonV4Handoff.lean @@ -5,7 +5,7 @@ public import Ix.Resource.Claim public section -namespace Tests.IxonV3Handoff +namespace Tests.IxonV4Handoff /-- A complete anonymous environment and its native resource admission claim. The rejected fixture differs only in the escaping result contract. -/ @@ -26,8 +26,8 @@ def artifacts : Except String (Array (String × ByteArray)) := do ("profile.bin", profile.bytes), ("accepted.claim", Ix.Claim.ser claim) ] let manifest := Lean.Json.mkObj [ - ("schema", .str "ixon-v3-handoff-1"), - ("objectFormat", .str "ixon-v3"), + ("schema", .str "ixon-v4-handoff-1"), + ("objectFormat", .str Ixon.wireFormatId), ("validator", .str Ix.Resource.validatorId), ("subject", .str (toString accepted.merkleRoot.get!)), ("profile", .str (toString profileAddress)), @@ -47,6 +47,6 @@ def check (directory : System.FilePath) : IO Unit := do unless (← IO.FS.readBinFile (directory / name)) == bytes do throw <| IO.userError s!"handoff fixture differs: {name}" -end Tests.IxonV3Handoff +end Tests.IxonV4Handoff end diff --git a/Tests/IxonV4Main.lean b/Tests/IxonV4Main.lean new file mode 100644 index 000000000..f7ba03c4f --- /dev/null +++ b/Tests/IxonV4Main.lean @@ -0,0 +1,91 @@ +import Tests.Ix.IxonV4 +import Tests.Ix.IxonV4FFI +import Tests.Ix.IxonV4VM +import Tests.Ix.IxonText +import Tests.Ix.ResourceAdmit +import Tests.Ix.ResourceAddressed +import Tests.Ix.ResourceValidate +import Tests.Ix.ContractTransport +import Tests.Ix.ContractPipeline +import Tests.Ix.ContractDecompile +import Tests.Ix.ClaimsV4 +import Tests.Ix.Catalog +import Tests.Ix.Kernel.PrimAddrs +import Tests.Ix.SourceContract +import Tests.Ix.SourceContract.ImportCheck +import Tests.Ix.SourceContract.SyntaxCheck +import Tests.Ix.SourceContract.Driver +import Tests.IxonV4Handoff +import Tests.Ix.IxonV4Paths + +def usage : String := + s!"usage: lake exe ixon-v4-tests [--export-fixtures] [--export-handoff] [--primitives] + +Run the Ixon v4 codec, locality, claim, resource and cross-language transport +checks, and check the generated fixtures of Tests/Fixtures/ixon-v4/. + + --export-fixtures write the generated text fixtures (claims, addressed + resources, resource cases) to ixon-v4-fixtures/ in the + scratch directory + --export-handoff write the handoff artifacts to ixon-v4-handoff/ in the + scratch directory instead of checking the checked-in ones + --primitives also validate the primitive closure that + `lake exe ixon-v4-primitives` wrote + +{Tests.IxonV4.scratchUsage}" + +/-- Write every generated text fixture of `Tests/Fixtures/ixon-v4/` (claims, +addressed resources, resource cases) from the producer its check compares +against, to `ixon-v4-fixtures/` in the scratch directory. `expressions.txt` +(independently specified bytes), `text.tsv` (text grammar sources) and +`primitives.tsv` (`ixon-v4-primitives`) are not generated here. -/ +def exportFixtures (dir : System.FilePath) : IO Unit := do + let out := Tests.IxonV4.fixtureExportDir dir + IO.FS.createDirAll out + IO.FS.writeFile (out / "claims.tsv") Tests.ClaimsV4.fixtureText + IO.FS.writeFile (out / "addressed.tsv") + (← IO.ofExcept Tests.ResourceAddressed.fixtureText) + IO.FS.writeFile (out / "resource.tsv") Tests.Resource.fixtureText + IO.println s!"Exported claims.tsv, addressed.tsv and resource.tsv to {out}" + +def main (args : List String) : IO Unit := do + if args.contains "--help" then + IO.println usage + return + let dir ← Tests.IxonV4.scratchDir + if args.contains "--export-fixtures" then + exportFixtures dir + if args.contains "--export-handoff" then + Tests.IxonV4Handoff.writeArtifacts (Tests.IxonV4.handoffExportDir dir) + else + Tests.IxonV4Handoff.check "Tests/Fixtures/ixon-v4/handoff" + let cases ← Tests.IxonV4.readExprCases + let checks ← Tests.IxonV4.runGolden cases + 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" + Tests.Resource.run + Tests.Resource.runAdmission + Tests.ResourceAddressed.run + Tests.ResourceValidate.run + Tests.ContractTransport.run + Tests.ContractPipeline.run + Tests.ContractDecompile.run + Tests.ClaimsV4.run + let result ← LSpec.lspecIO (.ofList [ + ("catalogs", Tests.Ix.Catalog.suite), + ("primitive addresses", Tests.Ix.Kernel.PrimAddrs.suite), + ("source contracts", Tests.Ix.SourceContract.suite ++ + Tests.Ix.SourceContract.Driver.suite)]) [] + unless result == 0 do throw <| IO.userError "primitive or source contract regression" + if args.contains "--primitives" then + let bytes ← IO.FS.readBinFile (Tests.IxonV4.primitivesIxe dir) + let env ← IO.ofExcept (Ixon.runGetExact Ixon.Env.getEnv bytes) + IO.println s!"Validating {env.consts.size} constants from the primitive closure" + let resolved ← IO.ofExcept (Ix.Resource.validate env (Ix.Resource.standardProfile env)) + IO.println s!"Validated {resolved.addresses.size} addressed interfaces" diff --git a/Tests/IxonV4Primitives.lean b/Tests/IxonV4Primitives.lean new file mode 100644 index 000000000..cfe3a158a --- /dev/null +++ b/Tests/IxonV4Primitives.lean @@ -0,0 +1,44 @@ +import Tests.Ix.Kernel.BuildPrimitives +import Tests.Ix.IxonV4Paths + +open Tests.Ix.Kernel.BuildPrimitives + +def usage : String := + s!"usage: lake exe ixon-v4-primitives + +Compile the primitive dependency closure of the installed Lean environment, +write its canonical primitive addresses and the compiled closure to the scratch +directory, and check the addresses against Tests/Fixtures/ixon-v4/primitives.tsv. + +{Tests.IxonV4.scratchUsage}" + +def main (args : List String) : IO Unit := do + if args.contains "--help" then + IO.println usage + return + let dir ← Tests.IxonV4.scratchDir + IO.FS.createDirAll dir + let tsvPath := Tests.IxonV4.primitivesTsv dir + let leanEnv ← get_env! + let needed := collectDeps leanEnv (kernelPrimitives.map parseNameToLean) + let constants := leanEnv.constants.toList.filter fun (name, _) => needed.contains name + IO.println s!"Compiling {constants.length} primitive dependency declarations" + let raw ← Ix.CompileM.rsCompileEnvFFI constants + let env := raw.toEnv + let mut text := s!"# Ixon v{Ixon.Env.VERSION} canonical primitive addresses\n" + for name in kernelPrimitives do + let some named := env.named[parseIxName name]? + | throw <| IO.userError s!"missing primitive {name}" + text := text ++ s!"{name}\t{named.addr}\n" + IO.FS.writeFile tsvPath text + let bytes ← match Ixon.serEnv env with + | .ok bytes => pure bytes + | .error error => throw <| IO.userError error + IO.FS.writeBinFile (Tests.IxonV4.primitivesIxe dir) bytes + 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. + 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 478b6af50..de82bd63f 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -6,6 +6,7 @@ import Tests.Ix.IxonSyntax import Tests.Ix.IxVM import Tests.Ix.IxVM.Exploits import Tests.Ix.IxVM.DefinitionDependencies +import Tests.Ix.IxVM.TagN import Tests.Ix.Claim import Tests.Ix.Merkle import Tests.Ix.AssumptionTree @@ -34,7 +35,10 @@ import Tests.Ix.Kernel.Arena import Tests.Ix.Kernel.PrimAddrs import Tests.Ix.RustSerialize import Tests.Ix.RustDecompile -import Tests.Ix.Sharing +import Tests.Ix.SharingExact +import Tests.Ix.SharingUniform +import Tests.Ix.SharingTiered +import Tests.Ix.SharingExactFFI import Tests.Ix.SourceContract import Tests.Ix.SourceContract.ImportCheck import Tests.Ix.SourceContract.SyntaxCheck @@ -101,7 +105,8 @@ def primarySuites : Std.HashMap String (List LSpec.TestSeq) := .ofList [ ("commit", Tests.Commit.suite), ("canon", [Tests.CanonM.suite]), ("keccak", Tests.Keccak.suite), - ("sharing", Tests.Sharing.suite), + ("exact-sharing", Tests.SharingExact.suite ++ Tests.SharingUniform.suite ++ Tests.SharingTiered.suite), + ("exact-sharing-ffi", Tests.SharingExactFFI.suite), ("source-contract", Tests.Ix.SourceContract.suite ++ Tests.Ix.SourceContract.Driver.suite), ("graph-unit", Tests.Ix.GraphM.suite), ("condense-unit", Tests.Ix.CondenseM.suite), @@ -167,10 +172,12 @@ def ignoredSuites : Std.HashMap String (List LSpec.TestSeq) := .ofList [ `primarySuites`, but kept as deferred `IO` actions (not `TestSeq` values) so their setup — Aiur system builds, STARK proofs — does not execute at module initialization for unrelated invocations. All are -seconds-scale (measured 2026-08-05: aiur-prove ~11s, the rest 2-4s -each). -/ +seconds-scale: ixvm-tagn about 16 s (measured 2026-10-01), aiur-prove +about 11 s and the rest 2-4 s each (measured 2026-08-05). -/ def primaryRunners : List (String × IO UInt32) := [ ("aiur-rust-syntax", AiurTests.RustSyntax.run), + -- The circuit TagN codec against the host codec (about 16 s). + ("ixvm-tagn", Tests.Ix.IxVM.TagN.runSuite), ("aiur-prove", do IO.println "aiur-prove" match AiurTestEnv.build (pure toplevel) with @@ -293,8 +300,8 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [ let actual := (Aiur.computeStats vmEnv.compiled qc vmEnv.shapes).totalFftCost.round.toUInt64.toNat pure (LSpec.test - s!"Shard pipeline FFT matches: expected 7_189_745_580, got {actual}" - (actual = 7_189_745_580)) + s!"Shard pipeline FFT matches: expected 6_236_673_618, got {actual}" + (actual = 6_236_673_618)) LSpec.lspecIO (.ofList [("ixvm", [fullSeq, aiurSeq, arenaSeq, exploitSeq, dependencySeq, paritySeq, shardSeq])]) []), diff --git a/crates/common/src/prim_addrs.rs b/crates/common/src/prim_addrs.rs index 5b5e40729..20d079f71 100644 --- a/crates/common/src/prim_addrs.rs +++ b/crates/common/src/prim_addrs.rs @@ -155,52 +155,52 @@ impl PrimAddrs { "42d6ed31536f0958176f1dc973383808ac8583223746ebca78dbe389b65321a6", ), nat_add: h( - "724db797e1817545a08371432fd1fa6428a37dcf9c1671df7e464849db0a81ac", + "3e8aadcc611c4d8677cadf00c78506561d33738ee3d571f7a4196e260580c9b8", ), nat_pred: h( - "76afa254a8bbf2ac4327d7b94be0c63bd708836b5f7384ce990388adb0a1d3cf", + "3244687301d779ec757274761d903def3eb3135177327b709bcbd854ef496f79", ), nat_sub: h( - "9de2d2c60e7d421a2fdfb8706e91e0e6d8576c3bd46ec00405c65875cb9b5a26", + "03b3a041285b0fe202d90b227d405c4cec252df18ba7616acd6dae2792e672bb", ), nat_mul: h( - "566a3c2249bc2076543d9bc561a841f6fd35ffb5bdbbc5c991a9c64feccbd5d4", + "373b7d74f6b40da11b7ed79603a45ec7011a8831b720b57d2efe92e82a3d57f0", ), nat_pow: h( - "5ba43ac3e5d29fe5ce81f18a18178a2705c37ee674b9b6ee50e9466a86593b15", + "5baaf05c969d2cf377312111be51bb64c600c13fa164ee722e92243b0f771bab", ), nat_gcd: h( - "76007dcf8b285cdbd6f779012290fe2e6afd221ce8821082a7e2ef81e8d815cf", + "aba94bfb41351d4db36172c379a512f04219ef21dc5454d71590967d4e8f913f", ), nat_mod: h( - "e6ffe78713d4b974a82d0187538f1a0cf5c4b260f0fd99264fab263b1af847f9", + "11abbf986481c53a21c8cb21ee2581ae6238aedbec15f972959d086bef1a1985", ), nat_div: h( - "c075ed976f1702f364fb0bb34aa8bbc166adace573f2ce914b43dc4f4aab6219", + "824d1c53d8c1c3cf0a27f24639ec2be1ecc13d4a01c993171595edccf6949737", ), nat_bitwise: h( - "aaf7df6a1f024f580fde236cba16235f071d1b796cc279faf43178d22b5ae36d", + "6eff55f72c856bd08aa02896fb78d93c28e11aae2be05c318b9d1f9fab8d7a53", ), nat_beq: h( - "ffd3f02a19fda649aa5608ed818db382e160231b76d5b09176d7dd1a8d5b1ec5", + "d3d8ff924af9dc4b5cd869760615b3e7ee80916bb617259d45890c69f4128337", ), nat_ble: h( - "68a3643ec69816aec107302ddbfa054cebcd3ec173cd5f7e6d883638631afe65", + "9e445b9d5f8252772347872e909b5db4e7eca7086cedf4fec6de840f6b7b5f92", ), nat_land: h( - "c61fad46a102dbff5922312d4fbe6e704ec3c62c6c6f64b3d481b78c77cf315d", + "d98bed1e14cda0eea470a5a49ff7926c80eb4bc7bfbdd0c3e14d4baa5c2dd0d7", ), nat_lor: h( - "cb7dccc020a530fed7c622b100ee52c1078b5018159ba4682f817e3776789ee8", + "88ff34dd42e57766beefc229d8b62dabba9cef6aadcc85c88ad67323d02bbf21", ), nat_xor: h( - "d8a6b05a1a4e5cadc69c53792e8e130314745e76e32bb30a9ce0272fa079e8a6", + "1b0acdd4080abe5bc4acb5f06527cb62ad92792eb429c2b3bcb6f471d7945085", ), nat_shift_left: h( - "5c15f98e2bd9c257bcdfac62b0043a2e3e2bbdff8b210f104b5c3739e862ac0c", + "05bb657e8b9d5dc224e7ef3d53e54153ce3ac26da8d1f1b1d61069a3726566cd", ), nat_shift_right: h( - "3f92725324b09fa75c6fcd16da863671428ff33b7db667eb760e1cd503a2bcad", + "25019ff485fcf5709597cd1e07fcc3ce796776ef3f715a6d187eb5831c63b4be", ), bool_type: h( "e6eba3c8b4d19f6a1076b39fa89aec61dccbb960f83d9a62e6acf35a69c9a0a4", @@ -212,32 +212,32 @@ impl PrimAddrs { "dda12bcb330727f6dfb816bc9752aabd0520e6515b79fc8a5a9e713866f4c63e", ), string: h( - "9d6ae43429ec02a9338bbcd0db0ac193d75ebd46f884bfcbd2c42bf7faea150d", + "221625a00ee2d6b96297e34d7e05bf7e4fd38d8d99d3e1d64a7cd2e06ca0752d", ), string_mk: h( - "272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2", + "45dcb3c5e5ada3bc0ca52d62a66f7f9dda3507df71061a5c200adea0cf241014", ), char_type: h( - "4c59bc4eac82d31ebed59bb206909dbded65b92fd56de2518fcdadb0a42c11a0", + "065fc8b41393f525c1e541b9d4bc97c20c13bf23a7209a2093b6f4527330114a", ), char_mk: h( - "82e09601422cae23b0b6df9922abb9f0b014e20047a00a7ab96871dd7da3e5ac", + "60cc6cfe4577b99a30113d09e9921f2253fac15fe3d5ad976b9dc3626edc6822", ), char_of_nat: h( - "caf51b039d71cfce7063e106064f9435f5337bbc42567c8c78b5f66c7f087920", + "cff875914f3f8b4f0014d1eaa223c6b9da7201239bc5976e140b69d99cd1f357", ), // NOTE: `String.ofList` and `String.mk` share the canonical content-hash // because both compile to the same Ixon form (a one-constructor `String` // built from `List Char`). The Lean-side deprecation of `String.mk` in // favor of `String.ofList` is orthogonal to the compiled representation. string_of_list: h( - "272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2", + "45dcb3c5e5ada3bc0ca52d62a66f7f9dda3507df71061a5c200adea0cf241014", ), string_to_byte_array: h( - "79862acfbc2e37b7b6122143f0a6a51114c34fa483ff14146483de18835d4209", + "de013024c598e5f0c3dcd067f506e1d2e32749573522acb539b61400627cf897", ), byte_array_empty: h( - "bf58e6cb3aa0f746850629041635cd30c0ad66262b6617660f2290241f08b08b", + "4da661917a58152f5ca974d2256d98efa9d722c4f16382e9cdf016df4c574368", ), list: h( "4fb6b41c30532e6ab4acb4eefe01da1314ee7f2129af8989fd63f7ec277aaf01", @@ -278,25 +278,25 @@ impl PrimAddrs { "ff00000000000000000000000000000000000000000000000000000000000003", ), system_platform_num_bits: h( - "6f620654d341990a301387b80ef75b1e0b6130ddf19164025b6dc37bf3c3dc18", + "57a31c1e34cf3993b20939dd29ba27263f24fbbeede2f6a6d089b8051fe32c3c", ), system_platform_get_num_bits: h( - "00c266834f9039931b4be2fac5584cd176a0ae7ee4cb4064ddb5e04dd12b6cbb", + "236e46bde1f59309c2cc685a7379bc5294a9817e597915ddcc4b3d933284cd70", ), subtype_val: h( - "ea65f517457fae9b705299da08b0d3c8cf9a476f16470cca5cae5ea7bd238230", + "d1bfec8df908c887e4f489adc2eec77a53e8ff28b5bd9a4c21a56da6381eed8f", ), nat_dec_le: h( - "f0f15ed079822f06e82e36664bf61e797e5b1e7b0b4155152762c513274bfee1", + "7bb659876671e03d0731c456e894ce9e6f7de8250ab4ae70113dc08e24532127", ), nat_dec_eq: h( - "8a5d5eee414a2fa5956b74e8323a20508d774ed1b5603f55e774ad896bd3e6e7", + "f1de7103802ebc5309041bdaadea4a65652d54af37e66aaaf41787b1d8919557", ), nat_dec_lt: h( - "7c4977196e95be2a759fc9c6d1533db8da49592f06419b155d888333c8dd8931", + "af586b07546e1fca9ab0780d1c236af8d360c4c6bb32bb0cd03ec9ca63d3da96", ), decidable_rec: h( - "16cfddda9c274660f391b10eefe066275afffae1ccd49c6daf43afb8a80aea85", + "3ea7e18fcbb7c498b2a45237bda659c0edc97b3d54a4ad0d11bc2ebec80cfa17", ), decidable_is_true: h( "363d071182be414e1a58599b83f5e19f9b873723054f4287ba69705aafef27da", @@ -305,22 +305,22 @@ impl PrimAddrs { "8cc0e1360c1b29108dab3d6172e7fce8a9aa9640daa4bbe99ba1305d9623624b", ), nat_le_of_ble_eq_true: h( - "ad25bfd207bae832c73d5ce614bead22ef9862e110f8d17a5064ffb7603eee3d", + "5c99dc61889e4a1e06ff6f24d184dc6553028cc62b89fa61bc23115b6a762068", ), nat_not_le_of_not_ble_eq_true: h( - "e3658f50dc5123efff213588dee3d4c6063f5edb18950850ac0490c937819009", + "93c0ea70c5c33f7bcecd405dfdee5c5471f74aee61f8bb610b2552d7ffe28183", ), nat_eq_of_beq_eq_true: h( - "9c91e79de732226ba2e73cbdd330851baec40668eb40c6f32aa2f8dac5a04b51", + "c44c528578dab3903088d064cc9b679d2c0eb3fe73da3c1ce1cc9d1b8f2cadd3", ), nat_ne_of_beq_eq_false: h( - "a07db532747e65ee77a7ba015069bdbaf1f709ce0d60b83c94f40d0e5e57595a", + "6a7739ca74fd0033ddcb1c4d98cde41920f173d3b8a6fade75a49b7496ec8cad", ), fin: h( - "3d79797bc572d8f33eb7cff5aa13f8dc73bcf21026bf05d03888c9aa0369dcef", + "1e1a2bbb1920ed4a1281a3deca646ad313ca9c7bf7eabdc3655987797ccc0c55", ), bool_no_confusion: h( - "de7b523cc4470e15328a01d935988861dadf9bd012240400464dea8c79a9dfe2", + "55b3bf142fb5a8078ad3b7515f90ab239c32ae0443dfe383b67dae6f4ba17fc5", ), // Int primitives — canonical content-hashes from // `lake test -- rust-kernel-build-primitives`. @@ -334,43 +334,43 @@ impl PrimAddrs { "f7130d5864e1ba77b0f6a7338f92159c35bd5147e0febcf1ebed456e513538cc", ), int_add: h( - "9db0177e4e8b6a0e7323069509c2457de9598a7e38e72ffe19ad34617256e10d", + "b666925b10473fbe1a7630ec496fe07d799c5248667db1e2302fca5fe4c50cb6", ), int_sub: h( - "85621387ef3027028d835287f3cc1461ef041def1fd91e28e87f669cc04a5eea", + "7c60043d6016e2f0ef5d764e1ab7923968d43d5c388186ddf6c83c28f024017a", ), int_mul: h( - "b05459623d23299d3a849eb7fb75badbc1547a1cd9ee560c15067fbd985c6cea", + "9dff949e4d0282393213042a36a69af4b71a58709096eaa3de5130bae0af84f3", ), int_neg: h( - "6701d765ff10bfa3a6c347df15194e0db862ee25b54f25a59f7cf21951a3997e", + "19c87649f9a17809f248beff7bc37f569f548e24a98d8a7cddd5b82eb808e5a6", ), int_emod: h( - "e29cfa7921bb57f4782b021c977596a4fae04e94f7b07955fe2814fc48de90e7", + "13c97e84fb8ac3ee8120e923d61fca6f7e6bb9241ec3aa5d359ba5dce542aa11", ), int_ediv: h( - "9c952d45a3bd43161529fcfb5e276beab0cf4fd64a01ba9bc2c7cda376cb8f54", + "53e404f5dd3c53693bc3b5bfae582b0496ec3c05af0cee0a46c38ab662c57fdf", ), int_bmod: h( - "0b1564dea6ffcd204ebcd1aa69d29ee6f3acccd87bd146ff674556ac9cc8ccb3", + "d0380dc9b63afeeb3235a77adeb355a8b52b0730971595093741ec2c6d57cd49", ), int_bdiv: h( - "6d35dc43660f6c509a13f2824c027ed99ab070a08f058ff0a5f46a759250797d", + "209aca62cc1f9dd2c0a928cd84d72bb41570aa97c1fd833e5fffc567c1c6401f", ), int_nat_abs: h( - "261ae54edb66e900784a64350bc01e8b3fe1332a47caeab58e0361dffc7ea008", + "01e7c724508897e01e5d0b8f72e2cfa2607cea5ff0d352d008d0e7512aab2f46", ), int_pow: h( - "87266415982bbdec50c61dec5b73cc0ccd5c997445997a9724a1cc5c2e39d3a4", + "a28958d747e87b5a60e4fa07ef7ed8d949f69adcbc44afe2958482d3ee9b3365", ), int_dec_eq: h( - "fc8c44cc970cfc183ccd10a2d1cdeb2c849307760e91f5cd29a2b02f706d83da", + "35a9ed7202e3c43857cdc4063eac123fe7b77f0631154ac540dba2c997bdf224", ), int_dec_le: h( - "fcdf1860ad4cd672239392e60e7b49e024af0475739c3a40195a914eaec42c04", + "1710034a517f249f5c8265e8e2783be60619f0c8e85f4eab625e85983abd722e", ), int_dec_lt: h( - "1d54806ab1ebc791e1db96e88d0407cef3523927d60ba669689b92a8eeb36445", + "5318877ae61e1da37980d80c11e3e47a36d850c3e43e99716122f1e6eff01e9f", ), punit: h( "2dfc16af01b82b3b91c2ff704409d76236a83f956c0c6e6659a64fe21d76695b", @@ -384,55 +384,55 @@ impl PrimAddrs { // Names previously matched via `is_const_named` in whnf.rs. // Canonical content-hashes from `lake test -- rust-kernel-build-primitives`. nat_rec: h( - "d1053449c217e5cc6fc29b2cb59cfd5ead385d392d00ada2221d4000dda7def3", + "c8322e03d558f85a8edc7fe68524013880ad0bbcb7dc890136d247154b230992", ), nat_cases_on: h( - "c575abb02efd158091356aa793c809c0570f8a24a8a777f206a95b9ce0b88855", + "937374ed09b8b62f36ef75f06f1ee46dd487c7a9f3e74db919bde48bb76b2cc6", ), bit_vec: h( - "7f0f5feda1828072123f242a46a40549e85934f7395e4f93f65dda4e4809f325", + "90022ae4c5d52ad28acd80051dd41f27f51c9c4afbab1bb391773c19ef0dc1e9", ), bit_vec_to_nat: h( - "c110d614b441c6cca69ecd7c1c2c76f3bc21fd40c4001e6a1a7d1cf481e23cdd", + "fade2dbfb1d7f77c30c247d52df128bf516eedce01f817d363ce88da13cfac2b", ), bit_vec_of_nat: h( - "29b9f24086b1b1f88211358866139fdb7dcdfc97b5f6c77fc495bf8c77639982", + "67160b97679306d2820445383a6d740e6fe9839c2545ea48680ff2a77b0be986", ), bit_vec_ult: h( - "9301d850bde246940b7b3e81e786f7f12bae8e5cea6b3f4040060b3a7f59557c", + "2f9c9c369045036d9a35ff7b38285dca3b976426c81a8f366fce1161b090d60d", ), decidable_decide: h( - "20e8906280b4dcd74a7a78e06d580e6f00eebba9fc40789262e95cacb6f0d699", + "11157bc3898f06e3e6f2ca83411efd0d43b8846b57d2f6088e18f3447ddc3b28", ), lt_lt: h( - "4802b183f4d6dcccacba57721824a7bb67daeb2725da17239271c135952caa61", + "061c2658c76a68d90978859824993bbbe15dbf9b9968619325420e7c839b05c7", ), of_nat_of_nat: h( - "a99dedbb1676866aed829c3d4bba86a37e98ec62a35834389c32937e4e2b1a4a", + "cb84bffa6d7092a309630214af29d9ec4e35cd5e0003eb9cdf75ee484e24925b", ), unit: h( "9232498667f765f437dedaac828e555f6cc67a20e6db28f614fdf3c262710feb", ), punit_size_of_1: h( - "e85bf516c76cadd8ce1fdab3cc94ed685e47be3c7a8b52f53fe2b3502e6f70c7", + "523699b6e827b74a950d4718bdf5b13c193e3c7c371aaad4d635667be74b05fa", ), size_of_size_of: h( - "402b71bcccf0be0315f1bda6bdbb20e559e31704617d3eaccb05d5c5fe03b53d", + "ea81aee4a7d154faa8211a2594406dfdc7442020c0f29d2d0f79b4e62314da51", ), string_back: h( - "32104b03348d11acb2437fda24966dc58cc8c8bcca96582614e644d319a42c62", + "b052e814120ea6299aecf4e9bb2b656d67c1f9537e8f0e9f16479c98a04fde93", ), string_legacy_back: h( - "37ef5fee765dc2e5c7425c180cd42007db7d29ae0d5c091789f462f2805b0e09", + "10af1decd5d2cd085adff8ae7fb44cfc5d22a89bbc40b81b809d3d556fda3e8f", ), string_utf8_byte_size: h( - "52b0226ea14c94b1f9334c9957f5589399a86bcdae111f2847c9b0c2fb0a2261", + "4c086826cc679df3b6aa57a29f3d093a8a92d0de4edecef46a908d8398733dc0", ), string_append: h( - "132f1175cc3cac5a3e3d74e8797f9ba67f2e467b8004a3f28bb5dfd16a3647b1", + "0eae69f3f8b198d1ffac67b9e88d39526b1b039ff519cd87eec106f63974860c", ), string_dec_eq: h( - "19134fdc188e8377d0173857e15d3b5065ed76da981397107e5c404db3f3b718", + "da7bb331e098f9bf5cdabcb9609a7e953dffc609ad9d90871a14c016c52a3011", ), } } diff --git a/crates/compile/src/compile.rs b/crates/compile/src/compile.rs index d4dc74ed6..9d61323c0 100644 --- a/crates/compile/src/compile.rs +++ b/crates/compile/src/compile.rs @@ -8,10 +8,7 @@ use dashmap::{DashMap, DashSet}; use rustc_hash::{FxHashMap, FxHashSet}; -use std::{ - cmp::Ordering, - sync::{Arc, atomic::Ordering as AtomicOrdering}, -}; +use std::{cmp::Ordering, sync::Arc}; use bignat::Nat; @@ -27,7 +24,7 @@ use ix_common::env::{ use ix_common::strong_ordering::SOrd; use ixon::{ - CompileError, Tag0, + CompileError, TagN, canon_univ::canon_univ, constant::{ Axiom, Constant, ConstantInfo, Constructor, Definition, Inductive, @@ -41,7 +38,9 @@ use ixon::{ ConstantMeta, ConstantMetaInfo, DataValue, ExprMeta, ExprMetaData, KVMap, UnivPatch, }, - sharing::{self, analyze_block, build_sharing_vec, decide_sharing}, + sharing_exact::{ + ExactSharingLimits, ShareLayout, SharingError, canonical_sharing_tiered, + }, univ::Univ, }; @@ -50,17 +49,6 @@ use crate::{ mutual::{Def, Ind, MutConst, MutCtx, Rec, ctx_to_all}, }; -/// Whether to track hash-consed sizes during compilation. -/// This adds overhead to sharing analysis and can be disabled for production. -/// Set to `true` to enable hash-consed vs serialized size comparison. -pub static TRACK_HASH_CONSED_SIZE: std::sync::atomic::AtomicBool = - std::sync::atomic::AtomicBool::new(false); - -/// Whether to output verbose sharing analysis for pathological blocks. -/// Set via IX_ANALYZE_SHARING=1 environment variable. -pub static ANALYZE_SHARING: std::sync::atomic::AtomicBool = - std::sync::atomic::AtomicBool::new(false); - /// Whether to output timing diagnostics for slow blocks and aux_gen phases. /// Set via IX_TIMING=1 environment variable. pub static IX_TIMING: std::sync::LazyLock = @@ -91,17 +79,6 @@ pub struct CompileOptions { pub max_workers: Option, } -/// Size statistics for a compiled block. -#[derive(Clone, Debug, Default)] -pub struct BlockSizeStats { - /// Hash-consed size: sum of unique subterm sizes (theoretical minimum with perfect sharing) - pub hash_consed_size: usize, - /// Serialized Ixon size: actual bytes when serialized - pub serialized_size: usize, - /// Number of constants in the block - pub const_count: usize, -} - /// Worker-local kernel context for aux_gen sort-level inference. pub struct KernelCtx { /// Worker-local **canonical** kernel environment. Populated incrementally by @@ -147,8 +124,6 @@ pub struct CompileState { /// block. Each entry is the list of equivalence classes (in `sort_consts` order), /// where each class is a list of names. pub blocks: DashMap>>, - /// Per-block size statistics (keyed by low-link name) - pub block_stats: DashMap, /// Constants that couldn't be compiled (name -> error description). /// /// Populated in two phases: @@ -223,6 +198,13 @@ pub struct CompileState { /// registered, so [`Self::finalize_hints`] resolves this map through /// `env.named` into `env.anon_hints` once compilation completes. pub def_hints: DashMap, + /// Resource limits of every canonical sharing construction run against + /// this state: compilation, and the decompiler's recompile check. + /// `compile_env` sets them once, from [`SHARING_LIMITS_ENV`], before it + /// schedules any block; an entry point that builds a state from a + /// deserialized environment sets them with [`compiler_sharing_limits`]. + /// The default is [`ExactSharingLimits::default`]. + pub sharing_limits: ExactSharingLimits, } /// Cached compiled expression with arena root index. @@ -303,7 +285,6 @@ impl Default for CompileState { env: Default::default(), name_to_addr: Default::default(), blocks: Default::default(), - block_stats: Default::default(), ungrounded: Default::default(), aux_gen_extra_names: Default::default(), aux_gen_pending: std::sync::Mutex::new(Vec::new()), @@ -314,6 +295,7 @@ impl Default for CompileState { below_call_site_plans: Default::default(), aux_perms: Default::default(), def_hints: Default::default(), + sharing_limits: ExactSharingLimits::default(), } } } @@ -2339,7 +2321,7 @@ fn serialize_syntax_inner( bytes.push(1); serialize_source_info(info, stt, bytes); bytes.extend_from_slice(compile_name(kind, stt).as_bytes()); - Tag0::new(args.len() as u64).put(bytes); + TagN::put(0, 0, args.len() as u64, bytes); for arg in args { serialize_syntax_inner(arg, stt, bytes); } @@ -2354,7 +2336,7 @@ fn serialize_syntax_inner( serialize_source_info(info, stt, bytes); serialize_substring(raw_val, stt, bytes); bytes.extend_from_slice(compile_name(val, stt).as_bytes()); - Tag0::new(preresolved.len() as u64).put(bytes); + TagN::put(0, 0, preresolved.len() as u64, bytes); for pr in preresolved { serialize_preresolved(pr, stt, bytes); } @@ -2372,14 +2354,14 @@ fn serialize_source_info( bytes.push(0); serialize_substring(leading, stt, bytes); // u64::MAX sentinel for positions that overflow u64 (should never happen in practice) - Tag0::new(leading_pos.to_u64().unwrap_or(u64::MAX)).put(bytes); + TagN::put(0, 0, leading_pos.to_u64().unwrap_or(u64::MAX), bytes); serialize_substring(trailing, stt, bytes); - Tag0::new(trailing_pos.to_u64().unwrap_or(u64::MAX)).put(bytes); + TagN::put(0, 0, trailing_pos.to_u64().unwrap_or(u64::MAX), bytes); }, LeanSourceInfo::Synthetic(start, end, canonical) => { bytes.push(1); - Tag0::new(start.to_u64().unwrap_or(u64::MAX)).put(bytes); - Tag0::new(end.to_u64().unwrap_or(u64::MAX)).put(bytes); + TagN::put(0, 0, start.to_u64().unwrap_or(u64::MAX), bytes); + TagN::put(0, 0, end.to_u64().unwrap_or(u64::MAX), bytes); bytes.push(if *canonical { 1 } else { 0 }); }, LeanSourceInfo::None => bytes.push(2), @@ -2392,8 +2374,8 @@ fn serialize_substring( bytes: &mut Vec, ) { bytes.extend_from_slice(store_string(&ss.str, stt).as_bytes()); - Tag0::new(ss.start_pos.to_u64().unwrap_or(u64::MAX)).put(bytes); - Tag0::new(ss.stop_pos.to_u64().unwrap_or(u64::MAX)).put(bytes); + TagN::put(0, 0, ss.start_pos.to_u64().unwrap_or(u64::MAX), bytes); + TagN::put(0, 0, ss.stop_pos.to_u64().unwrap_or(u64::MAX), bytes); } fn serialize_preresolved( @@ -2409,7 +2391,7 @@ fn serialize_preresolved( SyntaxPreresolved::Decl(n, fields) => { bytes.push(1); bytes.extend_from_slice(compile_name(n, stt).as_bytes()); - Tag0::new(fields.len() as u64).put(bytes); + TagN::put(0, 0, fields.len() as u64, bytes); for f in fields { bytes.extend_from_slice(store_string(f, stt).as_bytes()); } @@ -2418,189 +2400,158 @@ fn serialize_preresolved( } // =========================================================================== -// Sharing analysis helper +// Canonical sharing // =========================================================================== -/// Result of sharing analysis including size statistics. -struct SharingResult { - /// Rewritten expressions with Share nodes - rewritten: Vec>, - /// Shared subexpressions - sharing: Vec>, - /// Hash-consed size: sum of unique subterm base_sizes - hash_consed_size: usize, +// The compiler shares every block with the canonical tiered construction +// (`canonical_sharing_tiered`, TagN layout). Every construction error, +// resource exhaustion included, is a compile error: there is no fallback. +// Mirrors `Ix.CompileM.buildConstantWithSharing`. + +/// Environment variable carrying a sharing-limit override in the format of +/// [`ExactSharingLimits::with_overrides`] (for example +/// `states=2^44,height=2^34` or `unbounded`). `ix compile --sharing-limits` +/// and `ix compile-lean --sharing-limits` set it. Mirrors Lean +/// `Ix.CompileM.sharingLimitsEnvVar`. +pub const SHARING_LIMITS_ENV: &str = "IX_SHARING_LIMITS"; + +/// The [`ExactSharingLimits`] defaults with the override `spec` applied. +pub fn compiler_sharing_limits_with( + spec: Option<&str>, +) -> Result { + let limits = ExactSharingLimits::default(); + match spec { + None => Ok(limits), + Some(spec) => limits + .with_overrides(spec) + .map_err(|e| format!("{SHARING_LIMITS_ENV}: {e}")), + } } -/// Compute the hash-consed size from the info_map. -/// This is the theoretical size if each unique subterm were stored once in a content-addressed store. -/// Each unique expression = 32-byte key + value (with 32-byte hash references for children/externals). -fn compute_hash_consed_size( - info_map: &FxHashMap, -) -> usize { - info_map.values().map(|info| info.hash_consed_size).sum() +/// Resource limits of the compiler's canonical sharing construction: the +/// [`ExactSharingLimits`] defaults (a safety net far above every corpus +/// maximum) with the [`SHARING_LIMITS_ENV`] override. Each entry point reads +/// it once and carries the result ([`CompileState::sharing_limits`]), so an +/// invalid override fails the run once, before any block is shared. Mirrors +/// `Ix.CompileM.compilerSharingLimitsFromEnv`. +pub fn compiler_sharing_limits() -> Result { + compiler_sharing_limits_with( + std::env::var(SHARING_LIMITS_ENV).ok().as_deref(), + ) } -/// Apply sharing analysis to a set of expressions. -/// Returns the rewritten expressions, sharing vector, and hash-consed size. -/// -/// Hash-consed size tracking is controlled by the global `TRACK_HASH_CONSED_SIZE` flag. -fn apply_sharing_with_stats( - exprs: Vec>, - block_name: Option<&str>, -) -> SharingResult { - let track = TRACK_HASH_CONSED_SIZE.load(AtomicOrdering::Relaxed); - let analyze = ANALYZE_SHARING.load(AtomicOrdering::Relaxed); - let (info_map, ptr_to_hash, topo_order) = analyze_block(&exprs, track); - - // Compute hash-consed size (sum from info_map, which is 0 if tracking disabled) - let hash_consed_size = compute_hash_consed_size(&info_map); - - // Output detailed analysis if requested and this is a large block - // Use threshold to catch pathological cases - if analyze && info_map.len() > 5000 { - let name = block_name.unwrap_or(""); - let stats = sharing::analyze_sharing_stats(&info_map, &topo_order); - eprintln!( - "\n=== Sharing analysis for block {:?} with {} unique subterms ===", - name, - info_map.len() - ); - eprintln!("{}", stats); - eprintln!( - "hash_consed_size from analysis: {} bytes (tracking={})", - hash_consed_size, track - ); - } - - // Early exit if no sharing opportunities (< 2 repeated subterms) - let has_candidates = info_map.values().any(|info| info.usage_count >= 2); - if !has_candidates { - return SharingResult { - rewritten: exprs, - sharing: Vec::new(), - hash_consed_size, - }; - } - - let shared_hashes = decide_sharing(&info_map, &topo_order); - - // Early exit if nothing to share - if shared_hashes.is_empty() { - return SharingResult { - rewritten: exprs, - sharing: Vec::new(), - hash_consed_size, - }; +/// A sharing-construction failure as a compile error: resource exhaustion is +/// `ResourceLimit` (naming the limit and how to raise it), every other kind +/// `SharingConstruction`. Mirrors `Ix.CompileM.sharingCompileError`. +fn sharing_compile_error(e: SharingError) -> CompileError { + match e { + SharingError::ResourceExhausted(r) => CompileError::ResourceLimit { + reason: format!( + "canonical sharing: {e}; raise it with --sharing-limits {}=N \ + ({SHARING_LIMITS_ENV})", + r.resource.key() + ), + }, + other => CompileError::SharingConstruction { + reason: format!("canonical sharing: {other}"), + }, } - - let (rewritten, sharing) = build_sharing_vec( - &exprs, - &shared_hashes, - &ptr_to_hash, - &info_map, - &topo_order, - ); - SharingResult { rewritten, sharing, hash_consed_size } } -/// Apply sharing analysis to a set of expressions (without stats). -/// Returns the rewritten expressions and the sharing vector. -#[cfg(test)] -fn apply_sharing(exprs: Vec>) -> (Vec>, Vec>) { - let result = apply_sharing_with_stats(exprs, None); - (result.rewritten, result.sharing) -} - -/// Result of applying sharing to a singleton constant. -pub struct SingletonSharingResult { - /// The compiled Constant - pub constant: Constant, - /// Hash-consed size of expressions - pub hash_consed_size: usize, +/// Share the ordered roots of one block: the rewritten roots (same order and +/// count) and the sharing table. +fn share_roots( + limits: &ExactSharingLimits, + exprs: &[Arc], +) -> Result<(Vec>, Vec>), CompileError> { + let res = canonical_sharing_tiered(ShareLayout::TagN, exprs, limits) + .map_err(sharing_compile_error)?; + if res.roots.len() != exprs.len() { + return Err(CompileError::SharingConstruction { + reason: format!( + "canonical sharing returned {} roots for {}", + res.roots.len(), + exprs.len() + ), + }); + } + Ok((res.roots, res.sharing)) } -/// Apply sharing to a Definition and return a Constant with stats. +/// Apply the compiler's sharing under `limits` (a compile passes +/// [`CompileState::sharing_limits`]) to a definition payload. #[allow(clippy::needless_pass_by_value)] -pub fn apply_sharing_to_definition_with_stats( +pub fn apply_sharing_to_definition_with_limits( + limits: &ExactSharingLimits, def: Definition, refs: Vec
, univs: Vec>, - block_name: Option<&str>, -) -> SingletonSharingResult { - let result = apply_sharing_with_stats( - vec![def.typ.clone(), def.value.clone()], - block_name, - ); +) -> Result { + let (roots, sharing) = + share_roots(limits, &[def.typ.clone(), def.value.clone()])?; let def = Definition { kind: def.kind, safety: def.safety, lvls: def.lvls, - typ: result.rewritten[0].clone(), - value: result.rewritten[1].clone(), + typ: roots[0].clone(), + value: roots[1].clone(), }; let constant = - Constant::with_tables(ConstantInfo::Defn(def), result.sharing, refs, univs); - SingletonSharingResult { constant, hash_consed_size: result.hash_consed_size } + Constant::with_tables(ConstantInfo::Defn(def), sharing, refs, univs); + Ok(constant) } -/// Apply sharing to an Axiom and return a Constant with stats. +/// Apply the compiler's sharing under `limits` to an axiom payload. #[allow(clippy::needless_pass_by_value)] -pub fn apply_sharing_to_axiom_with_stats( +pub fn apply_sharing_to_axiom_with_limits( + limits: &ExactSharingLimits, ax: Axiom, refs: Vec
, univs: Vec>, -) -> SingletonSharingResult { - let result = apply_sharing_with_stats(vec![ax.typ.clone()], None); - let ax = Axiom { - is_unsafe: ax.is_unsafe, - lvls: ax.lvls, - typ: result.rewritten[0].clone(), - }; +) -> Result { + let (roots, sharing) = share_roots(limits, std::slice::from_ref(&ax.typ))?; + let ax = + Axiom { is_unsafe: ax.is_unsafe, lvls: ax.lvls, typ: roots[0].clone() }; let constant = - Constant::with_tables(ConstantInfo::Axio(ax), result.sharing, refs, univs); - SingletonSharingResult { constant, hash_consed_size: result.hash_consed_size } + Constant::with_tables(ConstantInfo::Axio(ax), sharing, refs, univs); + Ok(constant) } -/// Apply sharing to a Quotient and return a Constant with stats. +/// Apply the compiler's sharing under `limits` to a quotient payload. #[allow(clippy::needless_pass_by_value)] -pub fn apply_sharing_to_quotient_with_stats( +pub fn apply_sharing_to_quotient_with_limits( + limits: &ExactSharingLimits, quot: Quotient, refs: Vec
, univs: Vec>, -) -> SingletonSharingResult { - let result = apply_sharing_with_stats(vec![quot.typ.clone()], None); - let quot = Quotient { - kind: quot.kind, - lvls: quot.lvls, - typ: result.rewritten[0].clone(), - }; - let constant = Constant::with_tables( - ConstantInfo::Quot(quot), - result.sharing, - refs, - univs, - ); - SingletonSharingResult { constant, hash_consed_size: result.hash_consed_size } +) -> Result { + let (roots, sharing) = share_roots(limits, std::slice::from_ref(".typ))?; + let quot = + Quotient { kind: quot.kind, lvls: quot.lvls, typ: roots[0].clone() }; + let constant = + Constant::with_tables(ConstantInfo::Quot(quot), sharing, refs, univs); + Ok(constant) } -/// Apply sharing to a Recursor and return a Constant with stats. -pub fn apply_sharing_to_recursor_with_stats( +/// Apply the compiler's sharing under `limits` to a recursor payload. +pub fn apply_sharing_to_recursor_with_limits( + limits: &ExactSharingLimits, rec: Recursor, refs: Vec
, univs: Vec>, -) -> SingletonSharingResult { - // Collect all expressions: typ + all rule rhs +) -> Result { + // The roots: typ, then every rule rhs. let mut exprs = vec![rec.typ.clone()]; for rule in &rec.rules { exprs.push(rule.rhs.clone()); } - let result = apply_sharing_with_stats(exprs, None); - let typ = result.rewritten[0].clone(); + let (roots, sharing) = share_roots(limits, &exprs)?; + let typ = roots[0].clone(); let rules: Vec = rec .rules .into_iter() - .zip(result.rewritten.into_iter().skip(1)) + .zip(roots.into_iter().skip(1)) .map(|(r, rhs)| RecursorRule { fields: r.fields, rhs }) .collect(); @@ -2616,26 +2567,19 @@ pub fn apply_sharing_to_recursor_with_stats( rules, }; let constant = - Constant::with_tables(ConstantInfo::Recr(rec), result.sharing, refs, univs); - SingletonSharingResult { constant, hash_consed_size: result.hash_consed_size } -} - -/// Result of applying sharing to a mutual block. -pub struct MutualBlockSharingResult { - /// The compiled Constant - pub constant: Constant, - /// Hash-consed size of all expressions in the block - pub hash_consed_size: usize, + Constant::with_tables(ConstantInfo::Recr(rec), sharing, refs, univs); + Ok(constant) } -/// Apply sharing to a mutual block and return a Constant with stats. -pub fn apply_sharing_to_mutual_block( +/// Apply the compiler's sharing under `limits` to a mutual block: one sharing +/// table for the roots of every member, in member order. +pub fn apply_sharing_to_mutual_block_with_limits( + limits: &ExactSharingLimits, mut_consts: Vec, refs: Vec
, univs: Vec>, - block_name: Option<&str>, -) -> MutualBlockSharingResult { - // Collect all expressions from all constants in the block +) -> Result { + // The roots of every member, in member order. let mut all_exprs: Vec> = Vec::new(); let mut layout: Vec<(MutConstKind, Vec)> = Vec::new(); @@ -2671,49 +2615,8 @@ pub fn apply_sharing_to_mutual_block( layout.push((kind, indices)); } - // Apply sharing analysis to all expressions at once (with stats) - let sharing_result = apply_sharing_with_stats(all_exprs, block_name); - let rewritten = sharing_result.rewritten; - let sharing = sharing_result.sharing; - let expr_hash_consed_size = sharing_result.hash_consed_size; - - // Compute structural overhead for hash-consed store. - // In a hash-consed store, each unique node = 32-byte key + value (with 32-byte refs for children). - // This accounts for Inductive/Constructor/Recursor/Definition structures, not just expressions. - let mut structural_overhead: usize = 0; - for mc in &mut_consts { - match mc { - IxonMutConst::Defn(_) => { - // Definition: 32-byte key + (kind + safety + lvls + typ_ref + value_ref) - // = 32 + (1 + 1 + 8 + 32 + 32) = 106 bytes - structural_overhead += 106; - }, - IxonMutConst::Indc(ind) => { - // Inductive: 32-byte key + (flags + lvls + params + indices + nested + typ_ref + ctors_array_ref) - // = 32 + (3 + 8 + 8 + 8 + 8 + 32 + 32) = 131 bytes - structural_overhead += 131; - // Each Constructor: 32-byte key + (flags + lvls + cidx + params + fields + typ_ref) - // = 32 + (1 + 8 + 8 + 8 + 8 + 32) = 97 bytes - structural_overhead += ind.ctors.len() * 97; - // Ctors array: 32-byte key + N * 32-byte refs - structural_overhead += 32 + ind.ctors.len() * 32; - }, - IxonMutConst::Recr(rec) => { - // Recursor: 32-byte key + (k + flags + lvls + params + indices + motives + minors + typ_ref + rules_array_ref) - // = 32 + (1 + 1 + 8 + 8 + 8 + 8 + 8 + 32 + 32) = 138 bytes - structural_overhead += 138; - // Each RecursorRule: 32-byte key + (fields + rhs_ref) = 32 + (8 + 32) = 72 bytes - structural_overhead += rec.rules.len() * 72; - // Rules array: 32-byte key + N * 32-byte refs - structural_overhead += 32 + rec.rules.len() * 32; - }, - } - } - // Refs: each is a 32-byte address (already content-addressed, no extra overhead) - // Univs: each unique univ needs storage. Estimate 32 + 8 bytes per univ. - structural_overhead += univs.len() * 40; - - let hash_consed_size = expr_hash_consed_size + structural_overhead; + // One sharing table for the whole block. + let (rewritten, sharing) = share_roots(limits, &all_exprs)?; // Rebuild the constants with rewritten expressions let mut new_consts = Vec::with_capacity(mut_consts.len()); @@ -2781,7 +2684,7 @@ pub fn apply_sharing_to_mutual_block( let constant = Constant::with_tables(ConstantInfo::Muts(new_consts), sharing, refs, univs); - MutualBlockSharingResult { constant, hash_consed_size } + Ok(constant) } /// Helper enum for tracking mutual constant layout during sharing. @@ -3193,33 +3096,25 @@ pub struct CompiledMutualBlock { pub constant: Constant, /// Content-addressed hash pub addr: Address, - /// Hash-consed size (theoretical minimum with perfect DAG sharing) - pub hash_consed_size: usize, - /// Serialized size (actual bytes) - pub serialized_size: usize, } -/// Compile a mutual block with block-level sharing. -/// Returns the Constant, its content-addressed hash, and size statistics. +/// Compile a mutual block with block-level sharing under `limits`. +/// Returns the Constant and its content-addressed hash. pub fn compile_mutual_block( + limits: &ExactSharingLimits, mut_consts: Vec, refs: Vec
, univs: Vec>, - block_name: Option<&str>, -) -> CompiledMutualBlock { - // Apply sharing analysis across all expressions in the mutual block - let result = - apply_sharing_to_mutual_block(mut_consts, refs, univs, block_name); - let constant = result.constant; - let hash_consed_size = result.hash_consed_size; - - // Compute content address and serialized size +) -> Result { + // One sharing table across all expressions of the mutual block. + let constant = + apply_sharing_to_mutual_block_with_limits(limits, mut_consts, refs, univs)?; + let mut bytes = Vec::new(); constant.put(&mut bytes); - let serialized_size = bytes.len(); let addr = Address::hash(&bytes); - CompiledMutualBlock { constant, addr, hash_consed_size, serialized_size } + Ok(CompiledMutualBlock { constant, addr }) } /// Create Inductive from InductiveVal and Env. @@ -4158,25 +4053,24 @@ fn compile_const_inner( let n_unique_exprs = cache.exprs.len(); let refs: Vec
= cache.refs.iter().cloned().collect(); let univs: Vec> = cache.univs.iter().cloned().collect(); - let name_str = name.pretty(); let _t1 = std::time::Instant::now(); - let result = apply_sharing_to_definition_with_stats( + let constant = apply_sharing_to_definition_with_limits( + &stt.sharing_limits, data, refs, univs, - Some(&name_str), - ); + )?; let _t_sharing = _t1.elapsed(); let _t2 = std::time::Instant::now(); let mut bytes = Vec::new(); - result.constant.put(&mut bytes); + constant.put(&mut bytes); let serialized_size = bytes.len(); let addr = Address::hash(&bytes); let _t_serial = _t2.elapsed(); if *IX_TIMING && _t0.elapsed().as_secs_f32() > 1.0 { eprintln!( "[slow_single] {:?} compile={:.2}s sharing={:.2}s serial={:.2}s unique_exprs={} refs={} bytes={}", - name_str, + name.pretty(), _t_compile.as_secs_f32(), _t_sharing.as_secs_f32(), _t_serial.as_secs_f32(), @@ -4186,18 +4080,10 @@ fn compile_const_inner( ); } if aux { - stt.env.store_const(addr.clone(), result.constant); + stt.env.store_const(addr.clone(), constant); stt .env .register_name(name.clone(), Named::new(addr.clone(), meta.clone())); - stt.block_stats.insert( - name.clone(), - BlockSizeStats { - hash_consed_size: result.hash_consed_size, - serialized_size, - const_count: 1, - }, - ); } else { // Non-aux (compile_const_no_aux): promote aux_gen entry, storing the // original (addr, meta) in Named.original for decompilation metadata. @@ -4245,22 +4131,18 @@ fn compile_const_inner( let (data, meta) = compile_axiom(val, cache, stt)?; let refs: Vec
= cache.refs.iter().cloned().collect(); let univs: Vec> = cache.univs.iter().cloned().collect(); - let result = apply_sharing_to_axiom_with_stats(data, refs, univs); + let constant = apply_sharing_to_axiom_with_limits( + &stt.sharing_limits, + data, + refs, + univs, + )?; let mut bytes = Vec::new(); - result.constant.put(&mut bytes); - let serialized_size = bytes.len(); + constant.put(&mut bytes); let addr = Address::hash(&bytes); if aux { - stt.env.store_const(addr.clone(), result.constant); + stt.env.store_const(addr.clone(), constant); stt.env.register_name(name.clone(), Named::new(addr.clone(), meta)); - stt.block_stats.insert( - name.clone(), - BlockSizeStats { - hash_consed_size: result.hash_consed_size, - serialized_size, - const_count: 1, - }, - ); } addr }, @@ -4276,22 +4158,18 @@ fn compile_const_inner( let (data, meta) = compile_quotient(val, cache, stt)?; let refs: Vec
= cache.refs.iter().cloned().collect(); let univs: Vec> = cache.univs.iter().cloned().collect(); - let result = apply_sharing_to_quotient_with_stats(data, refs, univs); + let constant = apply_sharing_to_quotient_with_limits( + &stt.sharing_limits, + data, + refs, + univs, + )?; let mut bytes = Vec::new(); - result.constant.put(&mut bytes); - let serialized_size = bytes.len(); + constant.put(&mut bytes); let addr = Address::hash(&bytes); if aux { - stt.env.store_const(addr.clone(), result.constant); + stt.env.store_const(addr.clone(), constant); stt.env.register_name(name.clone(), Named::new(addr.clone(), meta)); - stt.block_stats.insert( - name.clone(), - BlockSizeStats { - hash_consed_size: result.hash_consed_size, - serialized_size, - const_count: 1, - }, - ); } addr }, @@ -4314,25 +4192,21 @@ fn compile_const_inner( compile_recursor(val, &mut_ctx, &ctx_addrs, cache, stt)?; let refs: Vec
= cache.refs.iter().cloned().collect(); let univs: Vec> = cache.univs.iter().cloned().collect(); - let result = apply_sharing_to_recursor_with_stats(data, refs, univs); + let constant = apply_sharing_to_recursor_with_limits( + &stt.sharing_limits, + data, + refs, + univs, + )?; let mut bytes = Vec::new(); - result.constant.put(&mut bytes); - let serialized_size = bytes.len(); + constant.put(&mut bytes); let addr = Address::hash(&bytes); if aux { - stt.env.store_const(addr.clone(), result.constant); + stt.env.store_const(addr.clone(), constant); stt.env.register_name( name.clone(), Named::new(addr.clone(), meta.clone()), ); - stt.block_stats.insert( - name.clone(), - BlockSizeStats { - hash_consed_size: result.hash_consed_size, - serialized_size, - const_count: 1, - }, - ); } else { stt.promote_aux(name, addr.clone(), meta)?; } @@ -4482,8 +4356,6 @@ fn compile_mutual( // Create mutual block with sharing let refs: Vec
= cache.refs.iter().cloned().collect(); let univs: Vec> = cache.univs.iter().cloned().collect(); - let const_count = ixon_mutuals.len(); - let name_str = name.pretty(); // Singleton non-inductive: emit as a standalone `Defn`/`Recr` // Constant instead of wrapping in `Muts(vec![one])`. Self-reference @@ -4499,31 +4371,22 @@ fn compile_mutual( && !matches!(&ixon_mutuals[0], IxonMutConst::Indc(_)) { let single = ixon_mutuals.pop().unwrap(); - let result = match single { - IxonMutConst::Defn(def) => apply_sharing_to_definition_with_stats( - def, - refs, - univs, - Some(&name_str), - ), + let limits = &stt.sharing_limits; + let standalone_constant = match single { + IxonMutConst::Defn(def) => { + apply_sharing_to_definition_with_limits(limits, def, refs, univs)? + }, IxonMutConst::Recr(rec) => { - apply_sharing_to_recursor_with_stats(rec, refs, univs) + apply_sharing_to_recursor_with_limits(limits, rec, refs, univs)? }, IxonMutConst::Indc(_) => unreachable!(), }; - let standalone_constant = result.constant; - let hash_consed_size = result.hash_consed_size; let mut bytes = Vec::new(); standalone_constant.put(&mut bytes); - let serialized_size = bytes.len(); let addr = Address::hash(&bytes); if aux { stt.env.store_const(addr.clone(), standalone_constant); - stt.block_stats.insert( - name.clone(), - BlockSizeStats { hash_consed_size, serialized_size, const_count: 1 }, - ); for class in &sorted_classes { for cnst in class { let n = cnst.name(); @@ -4547,7 +4410,7 @@ fn compile_mutual( } let compiled = - compile_mutual_block(ixon_mutuals, refs, univs, Some(&name_str)); + compile_mutual_block(&stt.sharing_limits, ixon_mutuals, refs, univs)?; let block_addr = compiled.addr.clone(); if aux { @@ -4562,16 +4425,6 @@ fn compile_mutual( stt.blocks.insert(cnst.name(), class_ordering.clone()); } } - - // Store block size statistics (keyed by low-link name) - stt.block_stats.insert( - name.clone(), - BlockSizeStats { - hash_consed_size: compiled.hash_consed_size, - serialized_size: compiled.serialized_size, - const_count, - }, - ); } // Create projections for each constant. @@ -6014,7 +5867,13 @@ mod tests { value: Expr::var(1), }); - let compiled = compile_mutual_block(vec![def1, def2], vec![], vec![], None); + let compiled = compile_mutual_block( + &ExactSharingLimits::default(), + vec![def1, def2], + vec![], + vec![], + ) + .unwrap(); let constant = compiled.constant; let addr = compiled.addr; @@ -6040,6 +5899,13 @@ mod tests { // Constant-level sharing tests // ========================================================================= + /// The compiler's sharing (the canonical construction) of `exprs` under + /// the default limits: the rewritten roots and the table. + #[allow(clippy::needless_pass_by_value)] + fn apply_sharing(exprs: Vec>) -> (Vec>, Vec>) { + share_roots(&ExactSharingLimits::default(), &exprs).unwrap() + } + #[test] fn test_apply_sharing_basic() { // Test the apply_sharing helper function with a repeated subterm @@ -7482,4 +7348,142 @@ mod tests { _ => panic!("Expected RecInfo"), } } + + // ========================================================================== + // The canonical sharing route + // ========================================================================== + + /// The `T2 → T2` witness of `docs/sharing-minimum.md` §2 as an axiom + /// payload (with univs `[Zero]` and no refs). + fn t2_arrow_t2() -> Axiom { + let p = Expr::sort(0); + let t1 = Expr::all(p.clone(), p.clone()); + let t2 = Expr::all(p, t1); + Axiom { is_unsafe: false, lvls: 0, typ: Expr::all(t2.clone(), t2) } + } + + fn constant_hex(c: &Constant) -> String { + let mut buf = Vec::new(); + c.put(&mut buf); + buf.iter().map(|b| format!("{b:02x}")).collect() + } + + /// The compiler route is the canonical construction: it reaches the + /// 17-byte minimum of the witness. + #[test] + fn compiler_route_reaches_the_17_byte_minimum() { + let r = apply_sharing_to_axiom_with_limits( + &ExactSharingLimits::default(), + t2_arrow_t2(), + vec![], + vec![Univ::zero()], + ) + .unwrap(); + assert_eq!(constant_hex(&r), "d200009117b0b001921700170000000100"); + } + + /// The compiler route builds exactly what the library normalizer builds + /// from the unshared Constant, for every payload kind it dispatches on. + #[test] + fn compiler_route_matches_the_normalizer() { + use ixon::constant::{DefKind, Definition, MutConst as IxonMutConst}; + use ixon::sharing_exact::normalize_constant_sharing_tiered; + let ax = t2_arrow_t2(); + let def = Definition { + kind: DefKind::Definition, + safety: ix_common::env::DefinitionSafety::Safe, + lvls: 0, + typ: ax.typ.clone(), + value: Expr::app(ax.typ.clone(), ax.typ.clone()), + }; + let limits = ExactSharingLimits::default(); + let univs = vec![Univ::zero()]; + let cases = [ + ( + ConstantInfo::Axio(ax.clone()), + apply_sharing_to_axiom_with_limits( + &limits, + ax.clone(), + vec![], + univs.clone(), + ) + .unwrap(), + ), + ( + ConstantInfo::Defn(def.clone()), + apply_sharing_to_definition_with_limits( + &limits, + def.clone(), + vec![], + univs.clone(), + ) + .unwrap(), + ), + ( + ConstantInfo::Muts(vec![ + IxonMutConst::Defn(def.clone()), + IxonMutConst::Defn(def.clone()), + ]), + apply_sharing_to_mutual_block_with_limits( + &limits, + vec![IxonMutConst::Defn(def.clone()), IxonMutConst::Defn(def)], + vec![], + univs.clone(), + ) + .unwrap(), + ), + ]; + for (info, routed) in cases { + let unshared = Constant::with_tables(info, vec![], vec![], univs.clone()); + let (normalized, _) = normalize_constant_sharing_tiered( + ShareLayout::TagN, + &unshared, + &limits, + ) + .unwrap(); + assert_eq!(routed, normalized); + } + } + + /// A construction that runs out of its limits is a compile error; there is + /// no fallback. + #[test] + fn compiler_route_fails_closed() { + let limits = ExactSharingLimits { + max_distinct_nodes: 2, + ..ExactSharingLimits::default() + }; + let err = apply_sharing_to_axiom_with_limits( + &limits, + t2_arrow_t2(), + vec![], + vec![Univ::zero()], + ) + .expect_err("the route must fail under these limits"); + assert!(matches!(err, CompileError::ResourceLimit { .. }), "{err}"); + // The error names the limit and how to raise it. + let msg = format!("{err}"); + assert!( + msg.contains("resource exhausted: distinct_nodes (limit 2)") + && msg.contains("--sharing-limits distinct_nodes=N") + && msg.contains(SHARING_LIMITS_ENV), + "{msg}" + ); + } + + /// The compiler limits are the library defaults plus the override, and an + /// invalid override is an error that names the variable. + #[test] + fn compiler_sharing_limits_override() { + assert_eq!( + compiler_sharing_limits_with(None).unwrap(), + ExactSharingLimits::default() + ); + let l = compiler_sharing_limits_with(Some("states=2^10, work=7,depth=3")) + .unwrap(); + assert_eq!((l.max_states, l.max_work), (1024, 7)); + assert_eq!(l.max_height, ExactSharingLimits::default().max_height); + let err = compiler_sharing_limits_with(Some("bogus=1")).unwrap_err(); + assert!(err.starts_with("IX_SHARING_LIMITS: unknown sharing limit bogus")); + } } diff --git a/crates/compile/src/compile/env.rs b/crates/compile/src/compile/env.rs index 604b3187f..0cf9c652b 100644 --- a/crates/compile/src/compile/env.rs +++ b/crates/compile/src/compile/env.rs @@ -157,6 +157,11 @@ pub fn compile_env_with_profile( profile: Option<&ixon::resource::addressed::Profile>, ) -> Result { let _memory_sampler = crate::diag::memory_sampler("compile_env"); + // The sharing limits of the whole run, read once: an invalid + // `IX_SHARING_LIMITS` fails the compile here, before any block is + // scheduled (Lean `compileEnvParallelAux` does the same). + let sharing_limits = crate::compile::compiler_sharing_limits() + .map_err(|reason| CompileError::SharingConstruction { reason })?; let setup_start = Instant::now(); // Whole-env scan: ref graph + immediate groundedness + inductive // groups in one decode per constant — the env decodes lazily, so @@ -281,6 +286,7 @@ pub fn compile_env_with_profile( let stt = CompileState { lean_env: Some(lean_env.clone()), ungrounded: ungrounded_map, + sharing_limits, ..Default::default() }; @@ -1190,19 +1196,32 @@ fn precompile_aux_gen_prereqs( let mut cache = BlockCache::default(); let mut prereq_kctx = crate::compile::KernelCtx::new(); compile_const(&rep, &all, lean_env, &mut cache, stt, &mut prereq_kctx) - .map_err(|e| CompileError::InvalidMutualBlock { - reason: format!( - "aux_gen prereq pre-compile failed for SCC '{}' ({} members): \ - {:?}. The SCC closure is traversed in reverse-topological \ - order starting from the aux_gen seed names (see \ - `aux_gen_seed_names`), so all transitive deps *should* be \ - compiled before this — if you're hitting this, a dep \ - relationship isn't captured in the ref graph, or the source \ - env is inconsistent.", - rep.pretty(), - all.len(), - e, - ), + .map_err(|e| match e { + // A sharing failure is about this block, not the dependency + // order: keep its category (and the limit to raise) and name the + // block. + CompileError::ResourceLimit { reason } => CompileError::ResourceLimit { + reason: format!("aux_gen prereq '{}': {reason}", rep.pretty()), + }, + CompileError::SharingConstruction { reason } => { + CompileError::SharingConstruction { + reason: format!("aux_gen prereq '{}': {reason}", rep.pretty()), + } + }, + e => CompileError::InvalidMutualBlock { + reason: format!( + "aux_gen prereq pre-compile failed for SCC '{}' ({} members): \ + {:?}. The SCC closure is traversed in reverse-topological \ + order starting from the aux_gen seed names (see \ + `aux_gen_seed_names`), so all transitive deps *should* be \ + compiled before this — if you're hitting this, a dep \ + relationship isn't captured in the ref graph, or the source \ + env is inconsistent.", + rep.pretty(), + all.len(), + e, + ), + }, })?; // Move compiled names → aux_name_to_addr. The scheduler can still // re-encounter this SCC later; the entries will just be no-ops. diff --git a/crates/compile/src/compile/mutual.rs b/crates/compile/src/compile/mutual.rs index e62050590..a42e96edf 100644 --- a/crates/compile/src/compile/mutual.rs +++ b/crates/compile/src/compile/mutual.rs @@ -193,7 +193,6 @@ pub fn compile_aux_block_with_rename( // Compile the mutual block. let block_refs: Vec
= cache.refs.iter().cloned().collect(); let block_univs: Vec> = cache.univs.iter().cloned().collect(); - let name_str = aux_consts[0].name().pretty(); // Singleton non-inductive aux blocks: emit as a standalone // `Defn`/`Recr` Constant instead of `Muts(vec![one])`. Same @@ -204,24 +203,28 @@ pub fn compile_aux_block_with_rename( && !matches!(&ixon_mutuals[0], IxonMutConst::Indc(_)) { use crate::compile::{ - apply_sharing_to_definition_with_stats, - apply_sharing_to_recursor_with_stats, + apply_sharing_to_definition_with_limits, + apply_sharing_to_recursor_with_limits, }; + let limits = &stt.sharing_limits; let single = ixon_mutuals.pop().unwrap(); let result = match single { - IxonMutConst::Defn(def) => apply_sharing_to_definition_with_stats( + IxonMutConst::Defn(def) => apply_sharing_to_definition_with_limits( + limits, def, block_refs, block_univs, - Some(&name_str), - ), - IxonMutConst::Recr(rec) => { - apply_sharing_to_recursor_with_stats(rec, block_refs, block_univs) - }, + )?, + IxonMutConst::Recr(rec) => apply_sharing_to_recursor_with_limits( + limits, + rec, + block_refs, + block_univs, + )?, IxonMutConst::Indc(_) => unreachable!(), }; - let standalone_addr = content_address(&result.constant); - stt.env.store_const(standalone_addr.clone(), result.constant); + let standalone_addr = content_address(&result); + stt.env.store_const(standalone_addr.clone(), result); let mut pending_names: Vec = Vec::new(); for cnst in &sorted_classes[0] { @@ -251,11 +254,11 @@ pub fn compile_aux_block_with_rename( } let compiled = compile_mutual_block( + &stt.sharing_limits, ixon_mutuals, block_refs, block_univs, - Some(&name_str), - ); + )?; let block_addr = compiled.addr.clone(); stt.env.store_const(block_addr.clone(), compiled.constant); diff --git a/crates/compile/src/decompile.rs b/crates/compile/src/decompile.rs index 296034bbf..ca38f2faf 100644 --- a/crates/compile/src/decompile.rs +++ b/crates/compile/src/decompile.rs @@ -30,7 +30,7 @@ use ix_common::env::{ }; use ixon::{ - DecompileError, Tag0, + CompileError, DecompileError, TagN, constant::{ Axiom, Constant, ConstantInfo, Constructor, DefKind, Definition, DefinitionProj, Inductive, InductiveProj, MutConst, Quotient, Recursor, @@ -310,7 +310,7 @@ pub struct BlockCache { /// Mutual context for resolving Rec references pub ctx: MutCtx, /// Block-level sharing table: target of `Expr::Share(idx)` in - /// post-`apply_sharing` body exprs. Initialized from + /// the block body exprs. Initialized from /// `Constant.sharing`. pub sharing: Vec>, /// Per-constant surgery sharing table: target of @@ -318,6 +318,8 @@ pub struct BlockCache { /// metadata arena nodes. Populated by `load_meta_extensions` from /// `ConstantMeta.meta_sharing`. Empty for constants without surgery /// (non-aux_gen singleton defs and all `roundtrip_block` callers). + /// `Share` nodes inside these expressions are read in the extended + /// index space (`ShareScope::Meta`). pub meta_sharing: Vec>, /// Reference table for resolving Ref indices to addresses pub refs: Vec
, @@ -342,10 +344,13 @@ pub struct BlockCache { pub primary_univ_len: Option, /// Cache for decompiled universes pub univ_cache: FxHashMap<*const Univ, Level>, - /// Cache for decompiled expressions keyed by (Ixon pointer, arena index). + /// Cache for decompiled expressions keyed by (Ixon pointer, arena index, + /// share scope). /// Same Ixon expression at same arena index → same metadata → same result. /// Same Ixon expression at different arena index → different metadata → different cache key. - pub expr_cache: FxHashMap<(*const Expr, u64), LeanExpr>, + /// The scope is part of the key because an expression valid in a + /// metadata scope may be invalid in the primary scope. + pub expr_cache: FxHashMap<(*const Expr, u64, ShareScope), LeanExpr>, /// Current constant being decompiled (for error messages) pub current_const: String, } @@ -368,8 +373,19 @@ impl BlockCache { /// indices map (overwrite semantics, like `meta_sharing`). /// /// Call at most once per cache, immediately after the primary tables - /// are installed — `primary_univ_len` is captured here. - pub fn load_meta_extensions(&mut self, meta: &ConstantMeta) { + /// are installed — `primary_univ_len` is captured here, and + /// `meta_sharing` is checked against the primary `sharing` length + /// (`validate_meta_sharing`): a malformed table is rejected here even + /// where decompilation never reads it. + pub fn load_meta_extensions( + &mut self, + meta: &ConstantMeta, + ) -> Result<(), DecompileError> { + validate_meta_sharing( + self.sharing.len(), + &meta.meta_sharing, + &self.current_const, + )?; self.meta_sharing = meta.meta_sharing.clone(); self.refs.extend(meta.meta_refs.iter().cloned()); self.primary_univ_len = Some(self.univ_table.len()); @@ -379,9 +395,123 @@ impl BlockCache { .iter() .map(|p| (p.arena_idx, p.univ_idxs.clone())) .collect(); + Ok(()) + } + + /// Resolve `Share(idx)` read in `scope` (see [`ShareScope`]): the target + /// expression and the scope its own `Share` nodes are read in. Mirrors + /// Lean `Ix.DecompileM.resolveShareIn`. + pub fn resolve_share( + &self, + scope: ShareScope, + idx: u64, + ) -> Result<(Arc, ShareScope), DecompileError> { + let p = self.sharing.len(); + let i = usize::try_from(idx).ok(); + if let Some(e) = i.and_then(|i| self.sharing.get(i)) { + // `i < p`: a primary entry in either scope; its own shares are + // primary again. + return Ok((e.clone(), ShareScope::Primary)); + } + match scope { + ShareScope::Primary => Err(DecompileError::InvalidShareIndex { + idx, + max: p, + constant: self.current_const.clone(), + }), + ShareScope::Meta { entry } => { + // `i >= p` here; only `p <= i < p + entry` (an EARLIER metadata + // entry) is valid. + let target = i + .map(|i| i - p) + .filter(|m| *m < entry) + .and_then(|m| self.meta_sharing.get(m).map(|e| (m, e))); + match target { + Some((m, e)) => Ok((e.clone(), ShareScope::Meta { entry: m })), + None => Err(DecompileError::InvalidMetaShareIndex { + idx, + entry: entry as u64, + primary_len: p, + meta_len: self.meta_sharing.len(), + constant: self.current_const.clone(), + }), + } + }, + } } } +/// The index space a `Share(i)` node is read in: the extended index space +/// of `ConstantMeta::meta_sharing`. With `p = sharing.len()` primary and +/// `q = meta_sharing.len()` metadata entries: +/// +/// - `Primary`: a primary expression (a root or a primary table entry). +/// `Share(i)` is `sharing[i]`; `i >= p` is `InvalidShareIndex`. Metadata +/// never changes how a primary expression decodes. +/// - `Meta { entry: j }`: an expression of `meta_sharing[j]`. `Share(i)` is +/// primary entry `i` when `i < p` (read in `Primary`: shares nested in a +/// primary entry stay primary) and `meta_sharing[i - p]` when +/// `p <= i < p + j` (read in `Meta { entry: i - p }`). Any other index is +/// `InvalidMetaShareIndex`: `i >= p + q` is out of range, +/// `p + j <= i < p + q` a forward or self reference. The entry strictly +/// decreases along metadata-to-metadata resolution, so expansion is well +/// founded. +/// +/// Call-site references (`CallSiteEntry::Collapsed.sharing_idx`, +/// `orig_head = Some((sharing_idx, _))`) index `meta_sharing` directly (no +/// offset by `p`) and read the entry in `Meta { entry: sharing_idx }`. +/// Mirrors Lean `Ix.DecompileM.ShareScope`. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum ShareScope { + Primary, + Meta { entry: usize }, +} + +/// Well-foundedness of a `meta_sharing` table against `primary_len` +/// primary entries: every `Share(i)` occurring in `meta_sharing[j]` must +/// have `i < primary_len + j` (a primary entry, or a metadata entry BEFORE +/// `j`). Reports the first violation in entry order, then in left-to-right +/// pre-order, as `InvalidMetaShareIndex` (Lean `validateMetaSharing` walks +/// in the same order). Iterative; `Share` nodes are not expanded. +/// +/// Each shared node (`Arc`) is visited once across the whole table, so the +/// walk is linear in the DAG size: in-memory tables share subterms through +/// the compiler's expression memo, and a tree walk is exponential in the +/// depth of such sharing. Skipping a node seen before keeps the first +/// violation: its whole subterm passed then, under a bound no larger than +/// the current one (the bound grows with the entry). +pub fn validate_meta_sharing( + primary_len: usize, + meta_sharing: &[Arc], + constant: &str, +) -> Result<(), DecompileError> { + let mut stack: Vec<&Arc> = Vec::new(); + let mut seen: FxHashSet<*const Expr> = FxHashSet::default(); + for (j, root) in meta_sharing.iter().enumerate() { + let bound = primary_len.saturating_add(j); + stack.push(root); + while let Some(e) = stack.pop() { + if !seen.insert(Arc::as_ptr(e)) { + continue; + } + if let Expr::Share(i) = e.as_ref() { + if !matches!(usize::try_from(*i), Ok(i) if i < bound) { + return Err(DecompileError::InvalidMetaShareIndex { + idx: *i, + entry: j as u64, + primary_len, + meta_len: meta_sharing.len(), + constant: constant.to_string(), + }); + } + } else { + stack.extend(e.children().into_iter().rev()); + } + } + } + Ok(()) +} + // =========================================================================== // Blob reading utilities // =========================================================================== @@ -472,12 +602,10 @@ fn deserialize_int(bytes: &[u8]) -> Result { } } -/// Read a Tag0-encoded u64 from a byte slice, advancing the cursor. -fn read_tag0(buf: &mut &[u8]) -> Result { - Tag0::get(buf).map(|t| t.size).map_err(|_| { - DecompileError::BadConstantFormat { - msg: "read_tag0: unexpected EOF".into(), - } +/// Read a TagN (f = 0) u64 from a byte slice, advancing the cursor. +fn read_tagn0(buf: &mut &[u8]) -> Result { + TagN::get(0, buf).map(|t| t.value).map_err(|e| { + DecompileError::BadConstantFormat { msg: format!("read_tagn0: {e}") } }) } @@ -502,8 +630,8 @@ fn deserialize_substring( ) -> Result { let str_addr = read_addr_bytes(buf)?; let s = read_string(&str_addr, stt)?; - let start_pos = Nat::from(read_tag0(buf)?); - let stop_pos = Nat::from(read_tag0(buf)?); + let start_pos = Nat::from(read_tagn0(buf)?); + let stop_pos = Nat::from(read_tagn0(buf)?); Ok(Substring { str: s, start_pos, stop_pos }) } @@ -522,14 +650,14 @@ fn deserialize_source_info( match tag { 0 => { let leading = deserialize_substring(buf, stt)?; - let leading_pos = Nat::from(read_tag0(buf)?); + let leading_pos = Nat::from(read_tagn0(buf)?); let trailing = deserialize_substring(buf, stt)?; - let trailing_pos = Nat::from(read_tag0(buf)?); + let trailing_pos = Nat::from(read_tagn0(buf)?); Ok(SourceInfo::Original(leading, leading_pos, trailing, trailing_pos)) }, 1 => { - let start = Nat::from(read_tag0(buf)?); - let end = Nat::from(read_tag0(buf)?); + let start = Nat::from(read_tagn0(buf)?); + let end = Nat::from(read_tagn0(buf)?); if buf.is_empty() { return Err(DecompileError::BadConstantFormat { msg: "source_info: missing canonical".into(), @@ -567,7 +695,7 @@ fn deserialize_preresolved( 1 => { let name_addr = read_addr_bytes(buf)?; let name = decompile_name(&name_addr, stt)?; - let count = read_tag0(buf)? as usize; + let count = read_tagn0(buf)? as usize; let mut fields = Vec::with_capacity(count); for _ in 0..count { let field_addr = read_addr_bytes(buf)?; @@ -609,7 +737,7 @@ fn deserialize_syntax_inner( let info = deserialize_source_info(buf, stt)?; let kind_addr = read_addr_bytes(buf)?; let kind = decompile_name(&kind_addr, stt)?; - let arg_count = read_tag0(buf)? as usize; + let arg_count = read_tagn0(buf)? as usize; let mut args = Vec::with_capacity(arg_count); for _ in 0..arg_count { args.push(deserialize_syntax_inner(buf, stt)?); @@ -627,7 +755,7 @@ fn deserialize_syntax_inner( let raw_val = deserialize_substring(buf, stt)?; let val_addr = read_addr_bytes(buf)?; let val = decompile_name(&val_addr, stt)?; - let pr_count = read_tag0(buf)? as usize; + let pr_count = read_tagn0(buf)? as usize; let mut preresolved = Vec::with_capacity(pr_count); for _ in 0..pr_count { preresolved.push(deserialize_preresolved(buf, stt)?); @@ -804,27 +932,26 @@ pub fn decompile_expr( }) } + /// Collect the canonical App telescope of `expr` (read in `scope`), + /// expanding `Share` nodes along the spine. Each argument carries the + /// scope it is read in: a spine `Share` can lead from a metadata + /// expression into a primary entry. + #[allow(clippy::type_complexity)] fn collect_ixon_telescope_expanding_shares( expr: &Arc, + scope: ShareScope, cache: &BlockCache, - ) -> Result<(Arc, Vec>), DecompileError> { - let mut args: Vec> = Vec::new(); + ) -> Result<(Arc, Vec<(Arc, ShareScope)>), DecompileError> { + let mut args: Vec<(Arc, ShareScope)> = Vec::new(); let mut cur = expr.clone(); + let mut scope = scope; loop { while let Expr::Share(share_idx) = cur.as_ref() { - cur = cache - .sharing - .get(*share_idx as usize) - .ok_or_else(|| DecompileError::InvalidShareIndex { - idx: *share_idx, - max: cache.sharing.len(), - constant: cache.current_const.clone(), - })? - .clone(); + (cur, scope) = cache.resolve_share(scope, *share_idx)?; } match cur.as_ref() { Expr::App(f, a) => { - args.push(a.clone()); + args.push((a.clone(), scope)); cur = f.clone(); }, _ => break, @@ -835,7 +962,8 @@ pub fn decompile_expr( } enum Frame { - Decompile(Arc, u64), + /// Decompile an Ixon expression read in a share scope at an arena index. + Decompile(Arc, u64, ShareScope), BuildApp(LeanMdata), BuildLam(Name, BinderInfo, LeanMdata), BuildAll(Name, BinderInfo, LeanMdata), @@ -844,7 +972,7 @@ pub fn decompile_expr( /// Undo the BVar lift applied when an existing source argument was moved /// underneath a synthesized eta telescope. LowerVars(usize), - CacheResult(*const Expr, u64), + CacheResult(*const Expr, u64, ShareScope), /// Assemble a source-order App spine from head + N decompiled args. BuildTelescope { n_args: usize, @@ -852,29 +980,26 @@ pub fn decompile_expr( }, } - let mut stack: Vec = vec![Frame::Decompile(expr.clone(), arena_idx)]; + // The root is a primary expression; metadata scopes are entered only + // through call-site references into `meta_sharing`. + let mut stack: Vec = + vec![Frame::Decompile(expr.clone(), arena_idx, ShareScope::Primary)]; let mut results: Vec = Vec::new(); while let Some(frame) = stack.pop() { match frame { - Frame::Decompile(e, idx) => { - // Expand Share transparently with the SAME arena_idx + Frame::Decompile(e, idx, scope) => { + // Expand Share transparently with the SAME arena_idx, in the + // target's scope. if let Expr::Share(share_idx) = e.as_ref() { - let shared_expr = cache - .sharing - .get(*share_idx as usize) - .ok_or_else(|| DecompileError::InvalidShareIndex { - idx: *share_idx, - max: cache.sharing.len(), - constant: cache.current_const.clone(), - })? - .clone(); - stack.push(Frame::Decompile(shared_expr, idx)); + let (shared_expr, shared_scope) = + cache.resolve_share(scope, *share_idx)?; + stack.push(Frame::Decompile(shared_expr, idx, shared_scope)); continue; } - // Cache check: (Ixon pointer, arena index) - let cache_key = (Arc::as_ptr(&e), idx); + // Cache check: (Ixon pointer, arena index, share scope) + let cache_key = (Arc::as_ptr(&e), idx, scope); if let Some(cached) = cache.expr_cache.get(&cache_key) { results.push(cached.clone()); continue; @@ -902,14 +1027,14 @@ pub fn decompile_expr( let node = arena_lookup(arena, current_idx, &cache.current_const)?; // Push CacheResult frame - stack.push(Frame::CacheResult(Arc::as_ptr(&e), idx)); + stack.push(Frame::CacheResult(Arc::as_ptr(&e), idx, scope)); if matches!( node, ExprMetaData::CallSite { .. } | ExprMetaData::EtaCallSite { .. } - ) && crate::semantic_contract::contains_ixon(&e, &cache.sharing) - .map_err(|msg| DecompileError::BadConstantFormat { msg })? - { + ) && crate::semantic_contract::contains_ixon(&e, scope, |s, i| { + cache.resolve_share(s, i) + })? { return Err(DecompileError::BadConstantFormat { msg: "optional call-site replay would rewrite a semantic contract" .into(), @@ -1101,17 +1226,11 @@ pub fn decompile_expr( } })?; let mut body = e.clone(); + let mut body_scope = scope; for _ in 0..n_synth { while let Expr::Share(share_idx) = body.as_ref() { - body = cache - .sharing - .get(*share_idx as usize) - .ok_or_else(|| DecompileError::InvalidShareIndex { - idx: *share_idx, - max: cache.sharing.len(), - constant: cache.current_const.clone(), - })? - .clone(); + (body, body_scope) = + cache.resolve_share(body_scope, *share_idx)?; } match body.as_ref() { Expr::Lam(_, _, b) => body = b.clone(), @@ -1127,7 +1246,9 @@ pub fn decompile_expr( } let (head_ixon, canonical_args) = - collect_ixon_telescope_expanding_shares(&body, cache)?; + collect_ixon_telescope_expanding_shares( + &body, body_scope, cache, + )?; if canon_meta.len() != canonical_args.len() { return Err(DecompileError::BadConstantFormat { msg: format!( @@ -1168,7 +1289,7 @@ pub fn decompile_expr( stack.push(Frame::LowerVars(n_synth)); match entry { CallSiteEntry::Kept { canon_idx, meta } => { - let arg_ixon = canonical_args + let (arg_ixon, arg_scope) = canonical_args .get(*canon_idx as usize) .ok_or_else(|| DecompileError::BadConstantFormat { msg: format!( @@ -1179,9 +1300,16 @@ pub fn decompile_expr( canonical_args.len() ), })?; - stack.push(Frame::Decompile(arg_ixon.clone(), *meta)); + stack.push(Frame::Decompile( + arg_ixon.clone(), + *meta, + *arg_scope, + )); }, CallSiteEntry::Collapsed { sharing_idx, meta } => { + // Direct `meta_sharing` index (no offset by the primary + // length); the entry's own shares are read in its + // metadata scope. let arg_ixon = cache .meta_sharing .get(*sharing_idx as usize) @@ -1191,7 +1319,11 @@ pub fn decompile_expr( constant: cache.current_const.clone(), })? .clone(); - stack.push(Frame::Decompile(arg_ixon, *meta)); + stack.push(Frame::Decompile( + arg_ixon, + *meta, + ShareScope::Meta { entry: *sharing_idx as usize }, + )); }, } } @@ -1204,7 +1336,7 @@ pub fn decompile_expr( ) => { // Collect the canonical Ixon App telescope let (head_ixon, canonical_args) = - collect_ixon_telescope_expanding_shares(&e, cache)?; + collect_ixon_telescope_expanding_shares(&e, scope, cache)?; // Most CallSites have one Kept entry per canonical arg. Split-SCC // minor adaptation is the exception: the canonical arg is a @@ -1244,7 +1376,11 @@ pub fn decompile_expr( constant: cache.current_const.clone(), })? .clone(); - Some(Frame::Decompile(head_share, *meta)) + Some(Frame::Decompile( + head_share, + *meta, + ShareScope::Meta { entry: *sharing_idx as usize }, + )) } else { // Decompile head: resolve name from CallSite. This must // succeed — a CallSite metadata node without a resolvable @@ -1308,7 +1444,7 @@ pub fn decompile_expr( for entry in entries.iter().rev() { match entry { CallSiteEntry::Kept { canon_idx, meta } => { - let arg_ixon = canonical_args + let (arg_ixon, arg_scope) = canonical_args .get(*canon_idx as usize) .ok_or_else(|| DecompileError::BadConstantFormat { msg: format!( @@ -1319,16 +1455,22 @@ pub fn decompile_expr( canonical_args.len() ), })?; - stack.push(Frame::Decompile(arg_ixon.clone(), *meta)); + stack.push(Frame::Decompile( + arg_ixon.clone(), + *meta, + *arg_scope, + )); }, CallSiteEntry::Collapsed { sharing_idx, meta } => { // `sharing_idx` addresses `ConstantMeta.meta_sharing` - // (per-constant, 0-based), NOT the block's primary - // sharing table — see `BlockCache` docs. Reading it - // from `cache.sharing` silently returned the wrong - // subtree whenever the block had any `apply_sharing` - // output, producing the "Binder arena vs Expr::Ref" - // mismatch on surgered `_sizeOf_N` constants. + // (per-constant, 0-based, no offset by the primary + // length), NOT the block's primary sharing table — see + // `BlockCache` docs. Reading it from `cache.sharing` + // silently returned the wrong subtree whenever the block + // had any `apply_sharing` output, producing the "Binder + // arena vs Expr::Ref" mismatch on surgered `_sizeOf_N` + // constants. The entry's own shares are read in its + // metadata scope. let arg_ixon = cache .meta_sharing .get(*sharing_idx as usize) @@ -1338,7 +1480,11 @@ pub fn decompile_expr( constant: cache.current_const.clone(), })? .clone(); - stack.push(Frame::Decompile(arg_ixon, *meta)); + stack.push(Frame::Decompile( + arg_ixon, + *meta, + ShareScope::Meta { entry: *sharing_idx as usize }, + )); }, } } @@ -1357,15 +1503,15 @@ pub fn decompile_expr( // App: follow arena children (ExprMetaData::App { children }, Expr::App(f, a)) => { stack.push(Frame::BuildApp(mdata_layers)); - stack.push(Frame::Decompile(a.clone(), children[1])); - stack.push(Frame::Decompile(f.clone(), children[0])); + stack.push(Frame::Decompile(a.clone(), children[1], scope)); + stack.push(Frame::Decompile(f.clone(), children[0], scope)); }, (_, Expr::App(f, a)) => { // No App metadata — use dummy indices (Leaf fallback) stack.push(Frame::BuildApp(mdata_layers)); - stack.push(Frame::Decompile(a.clone(), u64::MAX)); - stack.push(Frame::Decompile(f.clone(), u64::MAX)); + stack.push(Frame::Decompile(a.clone(), u64::MAX, scope)); + stack.push(Frame::Decompile(f.clone(), u64::MAX, scope)); }, // Lam: extract binder name/info from arena @@ -1384,8 +1530,8 @@ pub fn decompile_expr( info.clone(), mdata_layers, )); - stack.push(Frame::Decompile(body.clone(), children[1])); - stack.push(Frame::Decompile(ty.clone(), children[0])); + stack.push(Frame::Decompile(body.clone(), children[1], scope)); + stack.push(Frame::Decompile(ty.clone(), children[0], scope)); }, (_, Expr::Lam(_, ty, body)) => { @@ -1394,8 +1540,8 @@ pub fn decompile_expr( BinderInfo::Default, mdata_layers, )); - stack.push(Frame::Decompile(body.clone(), u64::MAX)); - stack.push(Frame::Decompile(ty.clone(), u64::MAX)); + stack.push(Frame::Decompile(body.clone(), u64::MAX, scope)); + stack.push(Frame::Decompile(ty.clone(), u64::MAX, scope)); }, // All: extract binder name/info from arena @@ -1410,8 +1556,8 @@ pub fn decompile_expr( info.clone(), mdata_layers, )); - stack.push(Frame::Decompile(body.clone(), children[1])); - stack.push(Frame::Decompile(ty.clone(), children[0])); + stack.push(Frame::Decompile(body.clone(), children[1], scope)); + stack.push(Frame::Decompile(ty.clone(), children[0], scope)); }, (_, Expr::All(_, _, ty, body)) => { @@ -1420,8 +1566,8 @@ pub fn decompile_expr( BinderInfo::Default, mdata_layers, )); - stack.push(Frame::Decompile(body.clone(), u64::MAX)); - stack.push(Frame::Decompile(ty.clone(), u64::MAX)); + stack.push(Frame::Decompile(body.clone(), u64::MAX, scope)); + stack.push(Frame::Decompile(ty.clone(), u64::MAX, scope)); }, // Let: extract name from arena @@ -1436,9 +1582,9 @@ pub fn decompile_expr( non_dep.non_dep, mdata_layers, )); - stack.push(Frame::Decompile(body.clone(), children[2])); - stack.push(Frame::Decompile(val.clone(), children[1])); - stack.push(Frame::Decompile(ty.clone(), children[0])); + stack.push(Frame::Decompile(body.clone(), children[2], scope)); + stack.push(Frame::Decompile(val.clone(), children[1], scope)); + stack.push(Frame::Decompile(ty.clone(), children[0], scope)); }, (_, Expr::Let(non_dep, ty, val, body)) => { @@ -1447,9 +1593,9 @@ pub fn decompile_expr( non_dep.non_dep, mdata_layers, )); - stack.push(Frame::Decompile(body.clone(), u64::MAX)); - stack.push(Frame::Decompile(val.clone(), u64::MAX)); - stack.push(Frame::Decompile(ty.clone(), u64::MAX)); + stack.push(Frame::Decompile(body.clone(), u64::MAX, scope)); + stack.push(Frame::Decompile(val.clone(), u64::MAX, scope)); + stack.push(Frame::Decompile(ty.clone(), u64::MAX, scope)); }, // Prj: extract struct name from arena @@ -1463,7 +1609,7 @@ pub fn decompile_expr( Nat::from(*field_idx), mdata_layers, )); - stack.push(Frame::Decompile(struct_val.clone(), *child)); + stack.push(Frame::Decompile(struct_val.clone(), *child, scope)); }, (_, Expr::Prj(type_ref_idx, _field_idx, _struct_val)) => { @@ -1610,9 +1756,9 @@ pub fn decompile_expr( results.push(apply_mdata(expr, mdata)); }, - Frame::CacheResult(e_ptr, arena_idx) => { + Frame::CacheResult(e_ptr, arena_idx, scope) => { if let Some(result) = results.last() { - cache.expr_cache.insert((e_ptr, arena_idx), result.clone()); + cache.expr_cache.insert((e_ptr, arena_idx, scope), result.clone()); } }, } @@ -2085,7 +2231,13 @@ fn decompile_inductive( // own `meta_sharing` table, and any constructor can carry its own // `univ_patches` (canonicity §10.6). Install those extensions only while // walking this constructor so they do not leak across sibling - // constructor arenas. + // constructor arenas. The constructor's `meta_sharing` is checked + // against the block's primary table, as `load_meta_extensions` does. + validate_meta_sharing( + cache.sharing.len(), + &ctor_meta.meta_sharing, + &cache.current_const, + )?; let saved_meta_sharing = std::mem::replace( &mut cache.meta_sharing, ctor_meta.meta_sharing.clone(), @@ -2205,7 +2357,7 @@ fn decompile_projection( // every `_sizeOf_N` — which is a DPrj into its mutual block and // whose body's `.rec` surgery produces `Collapsed` entries under // alpha-collapse — would fail with shape mismatches on decompile. - cache.load_meta_extensions(&named_meta); + cache.load_meta_extensions(&named_meta)?; // Each projection variant must land on the matching `MutConst` kind // at its block index. A silent fall-through would leave `name` @@ -2331,7 +2483,7 @@ fn decompile_const( current_const: current_const.clone(), ..Default::default() }; - cache.load_meta_extensions(&named_meta); + cache.load_meta_extensions(&named_meta)?; let info = decompile_definition(def, &named_meta, &mut cache, stt, dstt)?; dstt.insert_interned(name.clone(), info); }, @@ -2350,7 +2502,7 @@ fn decompile_const( // Defn branch above — omitting this desyncs // `CallSiteEntry::Collapsed.sharing_idx` from the intended // `meta_sharing` slot. - cache.load_meta_extensions(&named_meta); + cache.load_meta_extensions(&named_meta)?; let info = decompile_recursor(rec, &named_meta, &mut cache, stt, dstt)?; dstt.insert_interned(name.clone(), info); }, @@ -2366,7 +2518,7 @@ fn decompile_const( }; // Axioms have only a type (no body), so no surgery today — but // load extensions for consistency with the other branches. - cache.load_meta_extensions(&named_meta); + cache.load_meta_extensions(&named_meta)?; let info = decompile_axiom(ax, &named_meta, &mut cache, stt, dstt)?; dstt.insert_interned(name.clone(), info); }, @@ -2382,7 +2534,7 @@ fn decompile_const( }; // Quotient types have only a type signature — same story as // axioms. Load extensions for consistency. - cache.load_meta_extensions(&named_meta); + cache.load_meta_extensions(&named_meta)?; let info = decompile_quotient(quot, &named_meta, &mut cache, stt, dstt)?; dstt.insert_interned(name.clone(), info); }, @@ -2984,13 +3136,50 @@ fn ixon_mut_const_summary( } } +/// A failure recorded by the aux_gen pass of [`decompile_env`]. +/// +/// Recompiling a regenerated block (`roundtrip_block`, Phase A) is a compile +/// step: its failure keeps the compile error, and with it the category (a +/// sharing `ResourceLimit` stays a resource limit), together with the +/// constant and the step that failed. Recompile must reproduce +/// `Named.original`, so a sharing failure has no fallback. Every other +/// failure is a decompile error. +#[derive(Clone, Debug)] +enum AuxGenError { + Recompile { constant: String, step: &'static str, err: CompileError }, + Decompile(DecompileError), +} + +impl AuxGenError { + fn recompile(constant: &Name, step: &'static str, err: CompileError) -> Self { + AuxGenError::Recompile { constant: constant.pretty(), step, err } + } +} + +impl From for AuxGenError { + fn from(e: DecompileError) -> Self { + AuxGenError::Decompile(e) + } +} + +impl std::fmt::Display for AuxGenError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + AuxGenError::Recompile { constant, step, err } => { + write!(f, "recompile of '{constant}' ({step}): {err}") + }, + AuxGenError::Decompile(e) => write!(f, "{e}"), + } + } +} + fn roundtrip_block( consts: &[LeanMutConst], generated_consts: &FxHashMap, orig_env: Option<&LeanEnv>, stt: &CompileState, dstt: &DecompileState, -) -> Result, DecompileError> { +) -> Result, AuxGenError> { use crate::compile::{ BlockCache as CompileBlockCache, collect_mut_const_exprs, compile_definition, compile_inductive, compile_mutual_block, compile_name, @@ -3008,12 +3197,10 @@ fn roundtrip_block( // ------------------------------------------------------------------ let mut cache = CompileBlockCache::default(); + let first_name = consts[0].name(); let refs: Vec<&LeanMutConst> = consts.iter().collect(); - let sorted_classes = sort_consts(&refs, &mut cache, stt).map_err(|e| { - DecompileError::BadConstantFormat { - msg: format!("roundtrip sort_consts: {e}"), - } - })?; + let sorted_classes = sort_consts(&refs, &mut cache, stt) + .map_err(|e| AuxGenError::recompile(&first_name, "sort_consts", e))?; let mut_ctx = LeanMutConst::ctx(&sorted_classes); // Mirror the production compile paths (`compile_single_def`, the @@ -3035,9 +3222,7 @@ fn roundtrip_block( } } preseed_expr_tables(&exprs, &mut_ctx, &mut cache, stt, "roundtrip_block") - .map_err(|e| DecompileError::BadConstantFormat { - msg: format!("roundtrip preseed {}: {e}", consts[0].name().pretty()), - })?; + .map_err(|e| AuxGenError::recompile(&first_name, "preseed", e))?; } // Map from name → (class_idx, MutConst kind) for projection construction. @@ -3055,11 +3240,8 @@ fn roundtrip_block( LeanMutConst::Recr(rec) => { let (data, meta) = compile_recursor(rec, &mut_ctx, &ctx_addrs, &mut cache, stt) - .map_err(|e| DecompileError::BadConstantFormat { - msg: format!( - "roundtrip compile_rec {}: {e}", - rec.cnst.name.pretty() - ), + .map_err(|e| { + AuxGenError::recompile(&rec.cnst.name, "compile_rec", e) })?; if !rep_pushed { ixon_mutuals.push(MutConst::Recr(data)); @@ -3070,11 +3252,8 @@ fn roundtrip_block( LeanMutConst::Defn(def) => { let (data, meta) = compile_definition(def, &mut_ctx, &ctx_addrs, &mut cache, stt) - .map_err(|e| DecompileError::BadConstantFormat { - msg: format!( - "roundtrip compile_def {}: {e}", - def.name.pretty() - ), + .map_err(|e| { + AuxGenError::recompile(&def.name, "compile_def", e) })?; if !rep_pushed { ixon_mutuals.push(MutConst::Defn(data)); @@ -3085,11 +3264,8 @@ fn roundtrip_block( LeanMutConst::Indc(ind) => { let (data, meta, ctor_metas) = compile_inductive(ind, &mut_ctx, &ctx_addrs, &mut cache, stt) - .map_err(|e| DecompileError::BadConstantFormat { - msg: format!( - "roundtrip compile_indc {}: {e}", - ind.ind.cnst.name.pretty() - ), + .map_err(|e| { + AuxGenError::recompile(&ind.ind.cnst.name, "compile_indc", e) })?; if !rep_pushed { ixon_mutuals.push(MutConst::Indc(data)); @@ -3105,7 +3281,7 @@ fn roundtrip_block( } } - // Singleton non-inductive: use apply_sharing_to_definition/recursor_with_stats + // Singleton non-inductive: use apply_sharing_to_{definition,recursor} // (matching compile_single_def/recursor) instead of compile_mutual_block. // This ensures the sharing analysis and arena match the original compilation. let singleton = sorted_classes.len() == 1 @@ -3113,7 +3289,6 @@ fn roundtrip_block( let block_refs: Vec
= cache.refs.iter().cloned().collect(); let block_univs: Vec> = cache.univs.iter().cloned().collect(); - let name_str = consts[0].name().pretty(); // Precompute (debug-gated) component-level summaries of the compiled // class representatives BEFORE `ixon_mutuals` is moved into the block @@ -3130,38 +3305,42 @@ fn roundtrip_block( .collect() }); + // The recompile shares under the state's limits; a failure (a resource + // limit included) keeps its compile error and names the block. + let limits = &stt.sharing_limits; + let sharing_err = |e| AuxGenError::recompile(&first_name, "sharing", e); let (block_constant, block_addr) = if singleton && ixon_mutuals.len() == 1 { // Singleton: compile as bare constant (no Muts wrapper). let result = match &ixon_mutuals[0] { MutConst::Defn(def) => { - crate::compile::apply_sharing_to_definition_with_stats( + crate::compile::apply_sharing_to_definition_with_limits( + limits, def.clone(), block_refs, block_univs, - Some(&name_str), ) + .map_err(sharing_err)? }, MutConst::Recr(rec) => { - crate::compile::apply_sharing_to_recursor_with_stats( + crate::compile::apply_sharing_to_recursor_with_limits( + limits, rec.clone(), block_refs, block_univs, ) + .map_err(sharing_err)? }, MutConst::Indc(_) => unreachable!("singleton guard excludes inductives"), }; let mut bytes = Vec::new(); - result.constant.put(&mut bytes); + result.put(&mut bytes); let addr = Address::hash(&bytes); - (result.constant, addr) + (result, addr) } else { // Multi-class or inductive: compile as mutual block (Muts wrapper). - let compiled = compile_mutual_block( - ixon_mutuals, - block_refs, - block_univs, - Some(&name_str), - ); + let compiled = + compile_mutual_block(limits, ixon_mutuals, block_refs, block_univs) + .map_err(sharing_err)?; let addr = compiled.addr.clone(); (compiled.constant, addr) }; @@ -3175,7 +3354,6 @@ fn roundtrip_block( // so we compare the block_addr against the original block stored in the // first member's projection metadata. { - let first_name = consts[0].name(); let orig_addr = if singleton { // Singleton: compare directly against the constant's original address. stt.env.named.get(&first_name).map(|named| { @@ -3343,31 +3521,35 @@ fn roundtrip_block( }, LeanMutConst::Indc(_) => unreachable!("probe is Defn/Recr only"), }); + let compiled = compiled.and_then(|data| { + let prefs: Vec
= pcache.refs.iter().cloned().collect(); + let punivs: Vec> = + pcache.univs.iter().cloned().collect(); + let result = match &data { + MutConst::Defn(def) => { + crate::compile::apply_sharing_to_definition_with_limits( + limits, + def.clone(), + prefs, + punivs, + ) + }, + MutConst::Recr(rec) => { + crate::compile::apply_sharing_to_recursor_with_limits( + limits, + rec.clone(), + prefs, + punivs, + ) + }, + MutConst::Indc(_) => unreachable!(), + }?; + Ok((data, result)) + }); match compiled { - Ok(data) => { - let prefs: Vec
= pcache.refs.iter().cloned().collect(); - let punivs: Vec> = - pcache.univs.iter().cloned().collect(); - let result = match &data { - MutConst::Defn(def) => { - crate::compile::apply_sharing_to_definition_with_stats( - def.clone(), - prefs, - punivs, - Some(&name_str), - ) - }, - MutConst::Recr(rec) => { - crate::compile::apply_sharing_to_recursor_with_stats( - rec.clone(), - prefs, - punivs, - ) - }, - MutConst::Indc(_) => unreachable!(), - }; + Ok((data, result)) => { let mut pbytes = Vec::new(); - result.constant.put(&mut pbytes); + result.put(&mut pbytes); let paddr = Address::hash(&pbytes); eprintln!( " -- probe original-form recompile: addr={:.12} vs orig {:.12} => {}", @@ -3396,14 +3578,14 @@ fn roundtrip_block( // is a regression, not an expected divergence. Callers record it // in `aux_gen_errors` (recovery keeps the Lean-facing env // populated for diagnosis, but the error is never silent). - return Err(DecompileError::BadConstantFormat { + return Err(AuxGenError::Decompile(DecompileError::BadConstantFormat { msg: format!( "roundtrip recompile hash mismatch for '{}': recompiled={:.12} original={:.12}", first_name.pretty(), block_addr.hex(), orig.hex(), ), - }); + })); } } @@ -3471,7 +3653,7 @@ fn roundtrip_block( // surgery of `.below`/`.brecOn` calls. Load the per-constant metadata // extensions so Collapsed entries have their source-order arguments // available during binder-name restoration. - dec_cache.load_meta_extensions(&orig_meta); + dec_cache.load_meta_extensions(&orig_meta)?; // Find the Ixon data for this constant. let class_idx = name_to_class.get(&name).copied().unwrap_or(0); @@ -3615,14 +3797,16 @@ fn roundtrip_block( generated_consts.get(&n), orig_env, ); - return Err(DecompileError::BadConstantFormat { - msg: format!( - "roundtrip hash mismatch for '{}' (decompiled={} original={})", - n.pretty(), - ci_kind(&ci), - ci_kind(lean_ci), - ), - }); + return Err(AuxGenError::Decompile( + DecompileError::BadConstantFormat { + msg: format!( + "roundtrip hash mismatch for '{}' (decompiled={} original={})", + n.pretty(), + ci_kind(&ci), + ci_kind(lean_ci), + ), + }, + )); } // Validate Ixon projection hash for the primary constant // (not constructors — they have CPrj addresses that depend on @@ -3700,18 +3884,20 @@ fn roundtrip_block( format!("{:?}", std::mem::discriminant(other)) }, }); - return Err(DecompileError::BadConstantFormat { - msg: format!( - "[roundtrip ixon] {} proj mismatch: orig={:.12} [{:?}] \ + return Err(AuxGenError::Decompile( + DecompileError::BadConstantFormat { + msg: format!( + "[roundtrip ixon] {} proj mismatch: orig={:.12} [{:?}] \ recomp={:.12} [idx={}, block={:.12}]", - n.pretty(), - orig_addr.hex(), - orig_detail, - proj_addr.hex(), - class_idx, - block_addr.hex(), - ), - }); + n.pretty(), + orig_addr.hex(), + orig_detail, + proj_addr.hex(), + class_idx, + block_addr.hex(), + ), + }, + )); } } } @@ -3728,7 +3914,7 @@ fn roundtrip_block( name.pretty() ); } - return Err(e); + return Err(e.into()); }, } } @@ -4526,7 +4712,7 @@ fn regen_one_cases_on( orig_env: Option<&LeanEnv>, stt: &CompileState, dstt: &DecompileState, - aux_gen_errors: &mut Vec<(Name, DecompileError)>, + aux_gen_errors: &mut Vec<(Name, AuxGenError)>, ) { use crate::compile::aux_gen::cases_on::generate_cases_on; if let Some(aux_def) = generate_cases_on(co_name, rec_val, gen_env) { @@ -4607,7 +4793,7 @@ fn decompile_block_aux_gen( stt: &CompileState, dstt: &DecompileState, muts_index: &MutsPlanIndex, -) -> Vec<(Name, DecompileError)> { +) -> Vec<(Name, AuxGenError)> { use crate::compile::aux_gen::{ below::{BelowConstant, generate_below_constants}, brecon::generate_brecon_constants, @@ -4618,7 +4804,7 @@ fn decompile_block_aux_gen( let orig_env: Option<&LeanEnv> = stt.lean_env.as_ref().map(|arc| arc.as_ref()); - let mut aux_gen_errors: Vec<(Name, DecompileError)> = Vec::new(); + let mut aux_gen_errors: Vec<(Name, AuxGenError)> = Vec::new(); // Map from name -> raw generated LeanConstantInfo (before roundtrip). // Used for three-way diagnostic: generated vs decompiled vs original. @@ -4706,13 +4892,13 @@ fn decompile_block_aux_gen( Err(e) => { aux_gen_errors.push(( all_names[0].clone(), - DecompileError::BadConstantFormat { + AuxGenError::Decompile(DecompileError::BadConstantFormat { msg: format!( "aux_gen rec failed for {}: {}", all_names[0].pretty(), e ), - }, + }), )); return aux_gen_errors; }, @@ -4797,7 +4983,7 @@ fn decompile_block_aux_gen( stt, muts_index, ) { - aux_gen_errors.push((all_names[0].clone(), e)); + aux_gen_errors.push((all_names[0].clone(), e.into())); } // Phase 1b: Generate .casesOn definitions. @@ -4945,13 +5131,13 @@ fn decompile_block_aux_gen( Err(e) => { aux_gen_errors.push(( all_names[0].clone(), - DecompileError::BadConstantFormat { + AuxGenError::Decompile(DecompileError::BadConstantFormat { msg: format!( "aux_gen below failed for {}: {}", all_names[0].pretty(), e ), - }, + }), )); vec![] }, @@ -5261,13 +5447,13 @@ fn decompile_block_aux_gen( Err(e) => { aux_gen_errors.push(( all_names[0].clone(), - DecompileError::BadConstantFormat { + AuxGenError::Decompile(DecompileError::BadConstantFormat { msg: format!( "aux_gen below.rec failed for {}: {}", all_names[0].pretty(), e ), - }, + }), )); }, } @@ -5377,13 +5563,13 @@ fn decompile_block_aux_gen( Err(e) => { aux_gen_errors.push(( all_names[0].clone(), - DecompileError::BadConstantFormat { + AuxGenError::Decompile(DecompileError::BadConstantFormat { msg: format!( "aux_gen brecOn failed for {}: {}", all_names[0].pretty(), e ), - }, + }), )); }, } @@ -5398,7 +5584,8 @@ fn decompile_block_aux_gen( { aux_gen_errors.push(( name.clone(), - DecompileError::BadConstantFormat { msg: format!("congruence: {e}") }, + DecompileError::BadConstantFormat { msg: format!("congruence: {e}") } + .into(), )); } } @@ -5609,7 +5796,7 @@ pub fn decompile_env( let mut work_env: LeanEnv = dstt.env.iter().map(|e| (e.key().clone(), e.value().clone())).collect(); - let mut aux_gen_errors: Vec<(Name, DecompileError)> = Vec::new(); + let mut aux_gen_errors: Vec<(Name, AuxGenError)> = Vec::new(); // Tracks constants already ingressed into `kctx.kenv` across all blocks, // so the BFS below doesn't redundantly walk the same dependency subgraph @@ -5969,6 +6156,64 @@ mod tests { ); } + /// The recompile of `roundtrip_block` shares under the state's limits, and + /// a sharing failure keeps its compile error (a resource limit stays a + /// resource limit) and names the constant. + #[test] + fn roundtrip_recompile_sharing_failure_names_the_constant() { + use ixon::sharing_exact::ExactSharingLimits; + let name = Name::str(Name::str(Name::anon(), "RT".into()), "d".into()); + let sort0 = LeanExpr::sort(Level::zero()); + let def = Def { + name: name.clone(), + level_params: vec![], + typ: LeanExpr::all( + Name::anon(), + sort0.clone(), + sort0.clone(), + BinderInfo::Default, + ), + kind: DefKind::Definition, + value: LeanExpr::lam( + Name::anon(), + sort0.clone(), + LeanExpr::bvar(Nat::from(0u64)), + BinderInfo::Default, + ), + hints: ReducibilityHints::Abbrev, + safety: DefinitionSafety::Safe, + all: vec![name.clone()], + }; + let stt = CompileState { + sharing_limits: ExactSharingLimits { + max_output_bytes: 1, + ..Default::default() + }, + ..CompileState::default() + }; + let err = roundtrip_block( + &[LeanMutConst::Defn(def)], + &FxHashMap::default(), + None, + &stt, + &DecompileState::default(), + ) + .expect_err("one output byte cannot hold the definition"); + match &err { + AuxGenError::Recompile { constant, step, err: inner } => { + assert_eq!((constant.as_str(), *step), ("RT.d", "sharing")); + assert!(matches!(inner, CompileError::ResourceLimit { .. }), "{err}"); + }, + AuxGenError::Decompile(e) => panic!("expected a recompile error: {e}"), + } + assert!( + err + .to_string() + .starts_with("recompile of 'RT.d' (sharing): resource limit:"), + "{err}" + ); + } + /// Register a Name in `stt.env.names` so `decompile_name` can resolve it. /// Mirrors `compile_name` (content-address the name, insert into names map). fn register_name(stt: &CompileState, name: &Name) -> Address { @@ -6387,3 +6632,463 @@ mod tests { let _ = Level::zero(); } } + +// =========================================================================== +// Extended index space for `Share` inside `meta_sharing` +// +// `Share(i)` inside `meta_sharing[j]` denotes primary entry `i` (`i < p`) or +// `meta_sharing[i - p]` (`p <= i < p + j`); anything else is +// `InvalidMetaShareIndex`. No compiler emits such a share today, so these +// hand-built fixtures pin the reader rule. They mirror the Lean +// `decompile-unit` "metadata share" tests in `Tests/Ix/Decompile.lean`. +// +// Every fixture has one primary entry (`p = 1`), `prim0 = (#1 #2)`, and a +// primary root `head #99` whose `CallSite` metadata reads one collapsed +// argument from `meta_sharing` before the kept `#99`. +// =========================================================================== + +#[cfg(test)] +mod meta_share_tests { + use super::*; + use crate::compile::compile_name; + + struct Fx { + stt: CompileState, + head: Name, + head_addr: Address, + head2: Name, + head2_addr: Address, + } + + fn fx() -> Fx { + let stt = CompileState::default(); + let head = Name::str(Name::anon(), "MS.head".to_string()); + let head2 = Name::str(Name::anon(), "MS.head2".to_string()); + let head_addr = compile_name(&head, &stt); + let head2_addr = compile_name(&head2, &stt); + Fx { stt, head, head_addr, head2, head2_addr } + } + + fn prim0() -> Arc { + Expr::app(Expr::var(1), Expr::var(2)) + } + /// `meta_sharing[0]`, shared: `Share(0)` is primary entry 0. + fn shared_m0() -> Arc { + Expr::app(Expr::share(0), Expr::var(3)) + } + /// `meta_sharing[1]`, shared: `Share(1) = p + 0` is `meta_sharing[0]`. + fn shared_m1() -> Arc { + Expr::app(Expr::share(1), Expr::share(0)) + } + fn plain_m0() -> Arc { + Expr::app(prim0(), Expr::var(3)) + } + fn plain_m1() -> Arc { + Expr::app(plain_m0(), prim0()) + } + + fn bv(n: u64) -> LeanExpr { + LeanExpr::bvar(Nat::from(n)) + } + fn lean_prim0() -> LeanExpr { + LeanExpr::app(bv(1), bv(2)) + } + fn lean_m0() -> LeanExpr { + LeanExpr::app(lean_prim0(), bv(3)) + } + fn lean_m1() -> LeanExpr { + LeanExpr::app(lean_m0(), lean_prim0()) + } + + /// The primary root `head #99`. + fn root() -> Arc { + Expr::app(Expr::reference(0, vec![]), Expr::var(99)) + } + + /// `head x #99`. + fn spine(fx: &Fx, x: LeanExpr) -> LeanExpr { + LeanExpr::app( + LeanExpr::app(LeanExpr::cnst(fx.head.clone(), vec![]), x), + bv(99), + ) + } + + /// Arena `0` leaf (the kept argument), `1` the call site, whose source + /// spine is `head #99`. + fn arena(fx: &Fx, k: u64, orig_head: Option<(u64, u64)>) -> ExprMeta { + let mut arena = ExprMeta::default(); + let leaf = arena.alloc(ExprMetaData::Leaf); + arena.alloc(ExprMetaData::CallSite { + name: fx.head_addr.clone(), + entries: vec![ + CallSiteEntry::Collapsed { sharing_idx: k, meta: u64::MAX }, + CallSiteEntry::Kept { canon_idx: 0, meta: leaf }, + ], + canon_meta: vec![leaf], + orig_head, + }); + arena + } + + /// A cache with the primary table `[prim0]` and `meta_sharing` installed + /// directly (no table check), so the lazy checks are exercised. + fn cache(fx: &Fx, meta_sharing: Vec>) -> BlockCache { + BlockCache { + sharing: vec![prim0()], + meta_sharing, + refs: vec![fx.head_addr.clone()], + current_const: "meta_share".into(), + ..Default::default() + } + } + + fn run( + fx: &Fx, + meta_sharing: Vec>, + arena: &ExprMeta, + root: &Arc, + root_idx: u64, + ) -> Result { + let mut cache = cache(fx, meta_sharing); + decompile_expr( + root, + arena, + root_idx, + &[], + &mut cache, + &fx.stt, + &DecompileState::default(), + ) + } + + fn assert_meta_share_err( + r: Result, + want_idx: u64, + want_entry: u64, + want_p: usize, + want_q: usize, + ) { + match r { + Err(DecompileError::InvalidMetaShareIndex { + idx, + entry, + primary_len, + meta_len, + .. + }) => assert_eq!( + (idx, entry, primary_len, meta_len), + (want_idx, want_entry, want_p, want_q) + ), + other => panic!("expected InvalidMetaShareIndex, got {other:?}"), + } + } + + #[test] + fn meta_share_primary_entry() { + let fx = fx(); + let got = run(&fx, vec![shared_m0()], &arena(&fx, 0, None), &root(), 1); + assert_eq!(got.expect("decompiles"), spine(&fx, lean_m0())); + } + + #[test] + fn meta_share_earlier_meta_entry() { + let fx = fx(); + let got = run( + &fx, + vec![shared_m0(), shared_m1()], + &arena(&fx, 1, None), + &root(), + 1, + ); + assert_eq!(got.expect("decompiles"), spine(&fx, lean_m1())); + } + + /// The shared table decompiles exactly like the unshared original. + #[test] + fn meta_share_round_trip_equals_unshared() { + let fx = fx(); + let a = arena(&fx, 1, None); + let shared = + run(&fx, vec![shared_m0(), shared_m1()], &a, &root(), 1).unwrap(); + let plain = run(&fx, vec![plain_m0(), plain_m1()], &a, &root(), 1).unwrap(); + assert_eq!(shared, plain); + assert_eq!(shared, spine(&fx, lean_m1())); + } + + /// `orig_head` reads its entry in that entry's metadata scope too: + /// source spine ` #99`. + #[test] + fn meta_share_orig_head() { + let fx = fx(); + let got = run( + &fx, + vec![shared_m0(), shared_m1()], + &arena(&fx, 0, Some((1, u64::MAX))), + &root(), + 1, + ); + assert_eq!( + got.expect("decompiles"), + LeanExpr::app(LeanExpr::app(lean_m1(), lean_m0()), bv(99)) + ); + } + + #[test] + fn meta_share_forward_reference_rejected() { + let fx = fx(); + let table = vec![Expr::app(Expr::share(2), Expr::var(3)), Expr::var(4)]; + let lazy = run(&fx, table.clone(), &arena(&fx, 0, None), &root(), 1); + assert_meta_share_err(lazy, 2, 0, 1, 2); + assert_meta_share_err(validate_meta_sharing(1, &table, "t"), 2, 0, 1, 2); + } + + #[test] + fn meta_share_self_reference_rejected() { + let fx = fx(); + let table = vec![Expr::app(Expr::share(1), Expr::var(3))]; + let lazy = run(&fx, table.clone(), &arena(&fx, 0, None), &root(), 1); + assert_meta_share_err(lazy, 1, 0, 1, 1); + assert_meta_share_err(validate_meta_sharing(1, &table, "t"), 1, 0, 1, 1); + } + + #[test] + fn meta_share_out_of_range_rejected() { + let fx = fx(); + let table = vec![Expr::var(0), Expr::app(Expr::share(5), Expr::var(3))]; + let lazy = run(&fx, table.clone(), &arena(&fx, 1, None), &root(), 1); + let msg = lazy.as_ref().unwrap_err().to_string(); + assert!(msg.contains("out of range"), "{msg}"); + assert_meta_share_err(lazy, 5, 1, 1, 2); + assert_meta_share_err(validate_meta_sharing(1, &table, "t"), 5, 1, 1, 2); + } + + /// A primary `Share(i)` with `i >= p` stays invalid although + /// `meta_sharing` has entries: metadata never changes how primary bytes + /// decode. + #[test] + fn meta_share_primary_share_unchanged() { + let fx = fx(); + let root = Expr::app(Expr::reference(0, vec![]), Expr::share(1)); + let got = run(&fx, vec![shared_m0()], &arena(&fx, 0, None), &root, 1); + assert!( + matches!( + got, + Err(DecompileError::InvalidShareIndex { idx: 1, max: 1, .. }) + ), + "{got:?}" + ); + } + + /// The expression cache is keyed by scope: `sub = Share(1) #7` is valid + /// in `meta_sharing[1]` (decoded first, as the collapsed argument of the + /// call site in function position) and must still be rejected when the + /// primary root applies the call site to the same `sub` (same pointer, + /// same arena index; no call-site scan covers that occurrence). + #[test] + fn meta_share_cache_keyed_by_scope() { + let fx = fx(); + let sub = Expr::app(Expr::share(1), Expr::var(7)); + let root = Expr::app(root(), sub.clone()); + let mut a = arena(&fx, 1, None); + let root_idx = a.alloc(ExprMetaData::App { children: [1, u64::MAX] }); + let got = run(&fx, vec![shared_m0(), sub], &a, &root, root_idx); + assert!( + matches!( + got, + Err(DecompileError::InvalidShareIndex { idx: 1, max: 1, .. }) + ), + "{got:?}" + ); + } + + /// A call site nested in a metadata expression: its canonical spine runs + /// through a metadata share into `meta_sharing[0]`, and an argument there + /// is a primary share. Source: `head (head2 (#1 #2) #9) #99`. + #[test] + fn meta_share_nested_call_site_crosses_scopes() { + let fx = fx(); + let m0 = Expr::app(Expr::reference(0, vec![]), Expr::share(0)); + let m1 = Expr::app(Expr::share(1), Expr::var(9)); + let mut a = ExprMeta::default(); + let leaf = a.alloc(ExprMetaData::Leaf); + let inner = a.alloc(ExprMetaData::CallSite { + name: fx.head2_addr.clone(), + entries: vec![ + CallSiteEntry::Kept { canon_idx: 0, meta: u64::MAX }, + CallSiteEntry::Kept { canon_idx: 1, meta: u64::MAX }, + ], + canon_meta: vec![u64::MAX, u64::MAX], + orig_head: None, + }); + let outer = a.alloc(ExprMetaData::CallSite { + name: fx.head_addr.clone(), + entries: vec![ + CallSiteEntry::Collapsed { sharing_idx: 1, meta: inner }, + CallSiteEntry::Kept { canon_idx: 0, meta: leaf }, + ], + canon_meta: vec![leaf], + orig_head: None, + }); + let got = run(&fx, vec![m0, m1], &a, &root(), outer); + let inner_lean = LeanExpr::app( + LeanExpr::app(LeanExpr::cnst(fx.head2.clone(), vec![]), lean_prim0()), + bv(9), + ); + assert_eq!(got.expect("decompiles"), spine(&fx, inner_lean)); + } + + /// An eta call site in a metadata expression: the synthesized wrapper is + /// stripped across a metadata share (`meta_sharing[1] = λ. Share(1)`, the + /// inner lambda being `meta_sharing[0]`). Source: `head (head2 #1) #99` + /// (the kept `#3` is lowered by the two synthesized binders). + #[test] + fn meta_share_eta_wrapper_across_meta_share() { + let fx = fx(); + let m0 = Expr::lam( + Expr::var(5), + Expr::app( + Expr::app(Expr::reference(0, vec![]), Expr::var(3)), + Expr::var(0), + ), + ); + let m1 = Expr::lam(Expr::var(6), Expr::share(1)); + let mut a = ExprMeta::default(); + let leaf = a.alloc(ExprMetaData::Leaf); + let eta = a.alloc(ExprMetaData::EtaCallSite { + n_synth: 2, + name: fx.head2_addr.clone(), + entries: vec![CallSiteEntry::Kept { canon_idx: 0, meta: u64::MAX }], + canon_meta: vec![u64::MAX, u64::MAX], + wrapper_meta: u64::MAX, + }); + let outer = a.alloc(ExprMetaData::CallSite { + name: fx.head_addr.clone(), + entries: vec![ + CallSiteEntry::Collapsed { sharing_idx: 1, meta: eta }, + CallSiteEntry::Kept { canon_idx: 0, meta: leaf }, + ], + canon_meta: vec![leaf], + orig_head: None, + }); + let got = run(&fx, vec![m0, m1], &a, &root(), outer); + let inner_lean = + LeanExpr::app(LeanExpr::cnst(fx.head2.clone(), vec![]), bv(1)); + assert_eq!(got.expect("decompiles"), spine(&fx, inner_lean)); + } + + /// Register an axiom `MS.ax : head #99` with the given + /// `meta_sharing` and run the whole `decompile_env` path (the table is + /// checked by `load_meta_extensions`). + fn decompile_axiom_env( + meta_sharing: Vec>, + ) -> (Result, Fx, Name) { + let fx = fx(); + let ax_name = Name::str(Name::anon(), "MS.ax".to_string()); + let ax_addr_name = compile_name(&ax_name, &fx.stt); + let ax = Constant { + info: ConstantInfo::Axio(Axiom { + is_unsafe: false, + lvls: 0, + typ: root(), + }), + sharing: vec![prim0()], + refs: vec![fx.head_addr.clone()], + univs: vec![], + }; + let mut bytes = Vec::new(); + ax.put(&mut bytes); + let addr = Address::hash(&bytes); + fx.stt.env.store_const(addr.clone(), ax); + let mut meta = ConstantMeta::new(ConstantMetaInfo::Axio { + name: ax_addr_name, + lvls: vec![], + arena: arena(&fx, 1, None), + type_root: 1, + }); + meta.meta_sharing = meta_sharing; + fx.stt.env.register_name(ax_name.clone(), Named::new(addr, meta)); + (decompile_env(&fx.stt), fx, ax_name) + } + + #[test] + fn meta_share_whole_constant_decompiles() { + let (dstt, fx, ax_name) = + decompile_axiom_env(vec![shared_m0(), shared_m1()]); + let dstt = dstt.expect("decompile_env succeeds"); + let entry = dstt.env.get(&ax_name).expect("MS.ax decompiled"); + match &*entry { + LeanConstantInfo::AxiomInfo(v) => { + assert_eq!(v.cnst.typ, spine(&fx, lean_m1())); + }, + other => { + panic!("expected AxiomInfo, got {:?}", std::mem::discriminant(other)) + }, + } + } + + /// Entry 2 is never read (the call site reads entry 1) but references + /// itself (`Share(3) = p + 2`): the table check still rejects it. + #[test] + fn meta_share_unread_malformed_entry_rejected() { + let (dstt, _, _) = decompile_axiom_env(vec![ + shared_m0(), + shared_m1(), + Expr::app(Expr::share(3), Expr::var(0)), + ]); + assert_meta_share_err(dstt.map(|_| ()), 3, 2, 1, 3); + } + + /// Regression: metadata without shares behaves as before. + #[test] + fn meta_share_tables_without_shares_unchanged() { + let fx = fx(); + let got = run(&fx, vec![plain_m0()], &arena(&fx, 0, None), &root(), 1); + assert_eq!(got.expect("decompiles"), spine(&fx, lean_m0())); + validate_meta_sharing(0, &[plain_m0(), plain_m1()], "t") + .expect("no shares: valid against an empty primary table"); + } + + /// The table check visits each shared node once. In-memory tables share + /// subterms through `Arc`s (the compiler's expression memo); on the chain + /// `e(k+1) = App(e(k), e(k))` a tree walk is 2^depth (depth 26 took 1.6 s, + /// doubling per level), so depth 64 only finishes as a DAG walk. A + /// violation behind shared subterms is still the one the tree walk + /// reports first. + #[test] + fn validate_meta_sharing_visits_shared_subterms_once() { + let mut e = Expr::app(Expr::share(0), Expr::var(0)); + for _ in 0..64 { + e = Expr::app(e.clone(), e); + } + validate_meta_sharing(1, &[e.clone(), e.clone()], "t") + .expect("every share is primary entry 0"); + // Entry 1 reads `e` (seen in entry 0) and then `Share(2)`, a self + // reference of entry 1 (`p + 1 = 2`). + let err = validate_meta_sharing( + 1, + &[e.clone(), Expr::app(e.clone(), Expr::share(2))], + "t", + ) + .unwrap_err(); + assert_eq!( + err, + DecompileError::InvalidMetaShareIndex { + idx: 2, + entry: 1, + primary_len: 1, + meta_len: 2, + constant: "t".into(), + } + ); + // Inside the shared chain itself, the first violation in pre-order is + // the leftmost leaf: `Share(0)` against an empty primary table. + let err = validate_meta_sharing(0, &[e], "t").unwrap_err(); + assert!( + matches!( + err, + DecompileError::InvalidMetaShareIndex { idx: 0, entry: 0, .. } + ), + "{err}" + ); + } +} diff --git a/crates/compile/src/graph.rs b/crates/compile/src/graph.rs index a95fb7542..9c0a50bb0 100644 --- a/crates/compile/src/graph.rs +++ b/crates/compile/src/graph.rs @@ -729,10 +729,10 @@ mod tests { assert!(compiled.ungrounded.is_empty()); let mut bytes = Vec::new(); compiled.env.put(&mut bytes).unwrap(); - // Migrated to Ixon v3; both worker counts must preserve these bytes. + // Ixon v4; both worker counts must preserve these bytes. assert_eq!( blake3::hash(&bytes).to_hex().as_str(), - "34fe80b5eae41a9d430a4e2a61d499e9db25ea587af289f0b4fc63b7770924f5" + "ea6cf4ca0e86e8db054f872a11fc2115284a9638e7b67d697940e1d19555725e" ); } } diff --git a/crates/compile/src/kernel_egress.rs b/crates/compile/src/kernel_egress.rs index d3a59739e..464470cac 100644 --- a/crates/compile/src/kernel_egress.rs +++ b/crates/compile/src/kernel_egress.rs @@ -405,9 +405,9 @@ use std::sync::Arc; use indexmap::IndexSet; use crate::compile::{ - apply_sharing_to_axiom_with_stats, apply_sharing_to_definition_with_stats, - apply_sharing_to_mutual_block, apply_sharing_to_quotient_with_stats, - apply_sharing_to_recursor_with_stats, + apply_sharing_to_axiom_with_limits, apply_sharing_to_definition_with_limits, + apply_sharing_to_mutual_block_with_limits, + apply_sharing_to_quotient_with_limits, apply_sharing_to_recursor_with_limits, }; use ix_common::address::Address; use ixon::constant::{ @@ -420,6 +420,7 @@ use ixon::constant::{ use ixon::env::{Env as IxonEnv, Named}; use ixon::expr::Expr as IxonExpr; use ixon::metadata::ConstantMetaInfo; +use ixon::sharing_exact::ExactSharingLimits; use ixon::univ::Univ as IxonUniv; /// Per-constant (or per-block) working context accumulated while converting @@ -980,6 +981,7 @@ fn egress_muts_block( original_env: &IxonEnv, names: &FxHashMap, name_index: &FxHashMap, KConst)>, + limits: &ExactSharingLimits, out: &IxonEnv, ) -> Result<(), String> { let mut_ctx_vec = build_block_mut_ctx(all, names, name_index)?; @@ -1049,19 +1051,15 @@ fn egress_muts_block( } let (refs, univs) = ctx.into_vecs(); - let first_name = names + // The block must name its first member. + names .get(all.first().and_then(|c| c.first()).ok_or("empty Muts")?) - .cloned() .ok_or("first name missing")?; - let block_name_str = first_name.pretty(); - let result = apply_sharing_to_mutual_block( - mut_consts, - refs, - univs, - Some(&block_name_str), - ); - let block_addr = content_address_of(&result.constant); - out.store_const(block_addr.clone(), result.constant); + let result = + apply_sharing_to_mutual_block_with_limits(limits, mut_consts, refs, univs) + .map_err(|e| format!("egress '{muts_name}': {e}"))?; + let block_addr = content_address_of(&result); + out.store_const(block_addr.clone(), result); // Register the synthetic Muts Named entry at the new block_addr. Preserve // the original `meta` / `original` fields — decompile's Pass 2 keys off @@ -1171,6 +1169,7 @@ fn egress_standalone( original_named: &Named, original_env: &IxonEnv, name_index: &FxHashMap, KConst)>, + limits: &ExactSharingLimits, out: &IxonEnv, ) -> Result<(), String> { let (_, kc) = name_index @@ -1182,39 +1181,44 @@ fn egress_standalone( if let Some(orig_const) = original_env.get_const(&original_named.addr) { ctx.preseed_univs(&orig_const.univs); } + // A sharing failure (resource limit or construction error) names the + // constant it stopped. + let sharing_err = |e: ixon::CompileError| format!("egress '{name}': {e}"); let (constant, addr) = match kc { KConst::Defn { .. } => { let def = kdefn_to_ixon(kc, &mut ctx)?; let (refs, univs) = ctx.into_vecs(); - let result = apply_sharing_to_definition_with_stats( - def, - refs, - univs, - Some(&name.pretty()), - ); - let addr = content_address_of(&result.constant); - (result.constant, addr) + let result = + apply_sharing_to_definition_with_limits(limits, def, refs, univs) + .map_err(sharing_err)?; + let addr = content_address_of(&result); + (result, addr) }, KConst::Recr { .. } => { let rec = krecr_to_ixon(kc, &mut ctx)?; let (refs, univs) = ctx.into_vecs(); - let result = apply_sharing_to_recursor_with_stats(rec, refs, univs); - let addr = content_address_of(&result.constant); - (result.constant, addr) + let result = + apply_sharing_to_recursor_with_limits(limits, rec, refs, univs) + .map_err(sharing_err)?; + let addr = content_address_of(&result); + (result, addr) }, KConst::Axio { .. } => { let ax = kaxio_to_ixon(kc, &mut ctx)?; let (refs, univs) = ctx.into_vecs(); - let result = apply_sharing_to_axiom_with_stats(ax, refs, univs); - let addr = content_address_of(&result.constant); - (result.constant, addr) + let result = apply_sharing_to_axiom_with_limits(limits, ax, refs, univs) + .map_err(sharing_err)?; + let addr = content_address_of(&result); + (result, addr) }, KConst::Quot { .. } => { let q = kquot_to_ixon(kc, &mut ctx)?; let (refs, univs) = ctx.into_vecs(); - let result = apply_sharing_to_quotient_with_stats(q, refs, univs); - let addr = content_address_of(&result.constant); - (result.constant, addr) + let result = + apply_sharing_to_quotient_with_limits(limits, q, refs, univs) + .map_err(sharing_err)?; + let addr = content_address_of(&result); + (result, addr) }, other => { return Err(format!( @@ -1240,9 +1244,12 @@ fn egress_standalone( /// Partitions original Named entries into Muts-block drivers and standalone /// constants, then processes each partition in parallel via rayon. Storing /// into the output `IxonEnv` is thread-safe because the env uses DashMaps. +/// Every rebuilt constant is shared under `limits` (the compile's +/// `CompileState::sharing_limits`); a sharing failure names its constant. pub fn ixon_egress( kenv: &KEnv, original_env: &IxonEnv, + limits: &ExactSharingLimits, ) -> Result { let t_start = std::time::Instant::now(); let out = IxonEnv::new(); @@ -1336,6 +1343,7 @@ pub fn ixon_egress( original_env, &names, &name_index, + limits, &out, ) }, @@ -1346,7 +1354,7 @@ pub fn ixon_egress( let t_solo = std::time::Instant::now(); standalone_entries.par_iter().try_for_each( |(name, named)| -> Result<(), String> { - egress_standalone(name, named, original_env, &name_index, &out) + egress_standalone(name, named, original_env, &name_index, limits, &out) }, )?; eprintln!("[ixon_egress] standalone consts: {:.2?}", t_solo.elapsed()); @@ -1790,4 +1798,57 @@ mod tests { assert!(matches!(&*ci, LeanCI::AxiomInfo(..))); } } + + // ---- ixon egress: sharing limits ---- + + /// A sharing failure while rebuilding a constant names the constant and + /// keeps the compile error's category (here a resource limit). + #[test] + fn egress_standalone_sharing_failure_names_the_constant() { + let name = mk_name("Egress.Limited"); + let kc = KConst::::Axio { + name: name.clone(), + level_params: vec![], + is_unsafe: false, + lvls: 0, + ty: KExpr::all( + mk_name("x"), + BinderInfo::Default, + sort0(), + KExpr::all(mk_name("y"), BinderInfo::Default, sort0(), sort0()), + ), + }; + let mut name_index = FxHashMap::default(); + name_index.insert(name.clone(), (mk_id("Egress.Limited"), kc)); + let original_named = + Named::new(mk_addr("Egress.Limited"), ixon::ConstantMeta::default()); + let limits = + ExactSharingLimits { max_output_bytes: 1, ..Default::default() }; + let out = IxonEnv::new(); + let err = egress_standalone( + &name, + &original_named, + &IxonEnv::new(), + &name_index, + &limits, + &out, + ) + .expect_err("one output byte cannot hold the axiom"); + assert!( + err.starts_with("egress 'Egress.Limited': resource limit:"), + "{err}" + ); + assert!(err.contains("--sharing-limits output_bytes=N"), "{err}"); + // Under the default limits the same constant egresses. + egress_standalone( + &name, + &original_named, + &IxonEnv::new(), + &name_index, + &ExactSharingLimits::default(), + &out, + ) + .unwrap(); + assert!(out.named.contains_key(&name)); + } } diff --git a/crates/compile/src/semantic_contract.rs b/crates/compile/src/semantic_contract.rs index 68c59480e..f3b2998cc 100644 --- a/crates/compile/src/semantic_contract.rs +++ b/crates/compile/src/semantic_contract.rs @@ -302,30 +302,31 @@ pub fn of_ixon(expr: &Expr) -> Option { } /// Context-free presence scan only; never used as resource-validity evidence. -pub fn contains_ixon( +/// A `Share` node met in index space `scope` is expanded by `resolve`, which +/// returns the target and the index space the target's own `Share` nodes are +/// read in (the decompiler's primary/metadata share scopes). Mirrors Lean +/// `Ix.SemanticContract.containsIxon`. +pub fn contains_ixon( expr: &Arc, - sharing: &[Arc], -) -> Result { + scope: S, + mut resolve: impl FnMut(S, u64) -> Result<(Arc, S), E>, +) -> Result +where + S: Copy + Eq + std::hash::Hash, +{ let mut seen = rustc_hash::FxHashSet::default(); - let mut stack = vec![expr]; - while let Some(e) = stack.pop() { - if !seen.insert(Arc::as_ptr(e)) { + let mut stack = vec![(expr.clone(), scope)]; + while let Some((e, s)) = stack.pop() { + if !seen.insert((Arc::as_ptr(&e), s)) { continue; } - if of_ixon(e).is_some() { + if of_ixon(&e).is_some() { return Ok(true); } if let Expr::Share(index) = e.as_ref() { - stack.push( - sharing - .get( - usize::try_from(*index) - .map_err(|_error| "semantic scan: sharing index overflow")?, - ) - .ok_or("semantic scan: invalid sharing index")?, - ); + stack.push(resolve(s, *index)?); } else { - stack.extend(e.children()); + stack.extend(e.children().into_iter().map(|c| (c.clone(), s))); } } Ok(false) diff --git a/crates/ffi/src/compile.rs b/crates/ffi/src/compile.rs index e8d111db3..c5ddce891 100644 --- a/crates/ffi/src/compile.rs +++ b/crates/ffi/src/compile.rs @@ -19,6 +19,7 @@ use ix_common::address::Address; use ix_common::env::{Name, ReducibilityHints}; use ix_compile::compile::{ CompileOptions, CompileState, compile_env_with_options, + compiler_sharing_limits, }; use ix_compile::condense::compute_sccs; use ix_compile::decompile::decompile_env; @@ -960,7 +961,7 @@ extern "C" fn rs_get_block_sharing_len( // ============================================================================= #[cfg(feature = "test-ffi")] -/// Expand shares while preserving all v3 contracts and static groups. +/// Expand shares while preserving all Ixon contracts and static groups. fn unshare_expr( expr: &Arc, sharing: &[Arc], @@ -1379,6 +1380,21 @@ impl LeanIxDecompileError { ctor.set_obj(0, LeanIxSerializeError::build(se)); ctor }, + DecompileError::InvalidMetaShareIndex { + idx, + entry, + primary_len, + meta_len, + constant, + } => { + let ctor = LeanIxDecompileError::alloc(11); + ctor.set_obj(0, build_lean_nat_usize(*primary_len)); + ctor.set_obj(1, build_lean_nat_usize(*meta_len)); + ctor.set_obj(2, build_lean_string(constant)); + ctor.set_num_64(0, *idx); + ctor.set_num_64(1, *entry); + ctor + }, } } } @@ -1455,6 +1471,26 @@ impl LeanIxDecompileError { 10 => DecompileError::Serialize( LeanIxSerializeError(self.get_obj(0)).decode(), ), + 11 => { + let primary_len = LeanNat::to_nat(&self.get_obj(0)) + .to_u64() + .and_then(|x| usize::try_from(x).ok()) + .unwrap_or(0); + let meta_len = LeanNat::to_nat(&self.get_obj(1)) + .to_u64() + .and_then(|x| usize::try_from(x).ok()) + .unwrap_or(0); + let constant = self.get_obj(2).as_string().to_string(); + let idx = self.get_num_64(0); + let entry = self.get_num_64(1); + DecompileError::InvalidMetaShareIndex { + idx, + entry, + primary_len, + meta_len, + constant, + } + }, tag => unreachable!("Invalid DecompileError tag: {tag}"), } } @@ -1463,14 +1499,15 @@ impl LeanIxDecompileError { impl LeanIxCompileError { /// Build a Lean CompileError from a Rust CompileError. /// - /// Tags 0–6: + /// Tags 0–7: /// 0: missingConstant (name : String) → 1 obj /// 1: missingAddress (addr : Address) → 1 obj /// 2: invalidMutualBlock (reason : String) → 1 obj /// 3: unsupportedExpr (desc : String) → 1 obj /// 4: unknownUnivParam (curr param : String) → 2 obj - /// 5: serializeError (msg : String) → 1 obj + /// 5: serializeError (err : SerializeError) → 1 obj /// 6: resourceLimit (reason : String) → 1 obj + /// 7: sharingConstruction (reason : String) → 1 obj pub fn build(err: &CompileError) -> Self { match err { CompileError::MissingConstant { name, .. } => { @@ -1509,6 +1546,11 @@ impl LeanIxCompileError { ctor.set_obj(0, build_lean_string(reason)); ctor }, + CompileError::SharingConstruction { reason } => { + let ctor = LeanIxCompileError::alloc(7); + ctor.set_obj(0, build_lean_string(reason)); + ctor + }, } } } @@ -1546,6 +1588,9 @@ impl LeanIxCompileError { 6 => CompileError::ResourceLimit { reason: self.get_obj(0).as_string().to_string(), }, + 7 => CompileError::SharingConstruction { + reason: self.get_obj(0).as_string().to_string(), + }, tag => unreachable!("Invalid CompileError tag: {tag}"), } } @@ -1676,7 +1721,14 @@ pub extern "C" fn rs_decompile_env( // reconstructs the block structure from the env itself — // `name_to_addr` so aux_gen resolves addresses for the names it // regenerates (mirroring `rs_compile_validate_aux`'s Phase 7 setup). - let stt = CompileState { env, ..CompileState::default() }; + // The recompile check runs under the compiler's sharing limits. + let sharing_limits = match compiler_sharing_limits() { + Ok(l) => l, + Err(e) => { + return LeanIOResult::error_string(&format!("rs_decompile_env: {e}")); + }, + }; + let stt = CompileState { env, sharing_limits, ..CompileState::default() }; for entry in stt.env.named.iter() { stt.name_to_addr.insert(entry.key().clone(), entry.value().addr.clone()); } @@ -1776,7 +1828,15 @@ pub extern "C" fn rs_decompile_env_consts( )); } - let stt = CompileState { env, ..CompileState::default() }; + let sharing_limits = match compiler_sharing_limits() { + Ok(l) => l, + Err(e) => { + return LeanIOResult::error_string(&format!( + "rs_decompile_env_consts: {e}" + )); + }, + }; + let stt = CompileState { env, sharing_limits, ..CompileState::default() }; for entry in stt.env.named.iter() { stt.name_to_addr.insert(entry.key().clone(), entry.value().addr.clone()); } diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index f8d1d744f..3a28e05ef 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -4202,6 +4202,7 @@ pub extern "C" fn rs_decompile_roundtrip( if let Err(e) = compile_state.env.put(&mut bytes) { return build_string_array(&[format!("serialize error: {e}")]); } + let sharing_limits = compile_state.sharing_limits.clone(); drop(compile_state); let mut slice: &[u8] = &bytes; let env = match ixon::env::Env::get_demoted_named(&mut slice) { @@ -4217,7 +4218,7 @@ pub extern "C" fn rs_decompile_roundtrip( ); drop(bytes); - let stt = CompileState { env, ..CompileState::default() }; + let stt = CompileState { env, sharing_limits, ..CompileState::default() }; for entry in stt.env.named.iter() { stt.name_to_addr.insert(entry.key().clone(), entry.value().addr.clone()); } @@ -4301,12 +4302,14 @@ pub extern "C" fn rs_kernel_roundtrip( // Egress KEnv → IxonEnv (reusing the original env's `ConstantMeta` + // blobs + names). let t3 = Instant::now(); - let egressed_ixon = match ixon_egress(&kenv, &compile_state.env) { - Ok(e) => e, - Err(msg) => { - return build_string_array(&[format!("ixon_egress error: {msg}")]); - }, - }; + let egressed_ixon = + match ixon_egress(&kenv, &compile_state.env, &compile_state.sharing_limits) + { + Ok(e) => e, + Err(msg) => { + return build_string_array(&[format!("ixon_egress error: {msg}")]); + }, + }; eprintln!( "[rs_kernel_roundtrip] ixon egress: {:>8.1?} ({} consts, {} named)", t3.elapsed(), diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs index 089f52497..1fc35ee24 100644 --- a/crates/ffi/src/lean.rs +++ b/crates/ffi/src/lean.rs @@ -342,6 +342,7 @@ lean_ffi::lean_inductive! { { num_obj: 2 }, // tag 8: badBlobFormat { num_obj: 1 }, // tag 9: badConstantFormat { num_obj: 1 }, // tag 10: serialize + { num_obj: 3, num_64: 2 }, // tag 11: invalidMetaShareIndex ]; LeanIxCompileError [ @@ -352,6 +353,7 @@ lean_ffi::lean_inductive! { { num_obj: 2 }, // tag 4: unknownUnivParam { num_obj: 1 }, // tag 5: serialize { num_obj: 1 }, // tag 6: resourceLimit + { num_obj: 1 }, // tag 7: sharingConstruction ]; // Defined in `Ix/KernelCheck.lean`. diff --git a/crates/ffi/src/lean_env.rs b/crates/ffi/src/lean_env.rs index 6eae3edab..c654ac3c2 100644 --- a/crates/ffi/src/lean_env.rs +++ b/crates/ffi/src/lean_env.rs @@ -1270,14 +1270,6 @@ pub fn decode_env(list: LeanList>) -> Env { extern "C" fn rs_tmp_decode_const_map( obj: LeanList>, ) -> usize { - // Enable hash-consed size tracking for debugging - ix_compile::compile::TRACK_HASH_CONSED_SIZE - .store(true, std::sync::atomic::Ordering::Relaxed); - - // Enable verbose sharing analysis for debugging pathological blocks - ix_compile::compile::ANALYZE_SHARING - .store(false, std::sync::atomic::Ordering::Relaxed); - let env = decode_env(obj); let n = env.len(); let env = Arc::new(env); @@ -1745,7 +1737,6 @@ extern "C" fn rs_tmp_decode_const_map( eprintln!("[rust-compile] Phase 4: Size analysis..."); let _ = stt.env.serialized_size_breakdown(); analyze_const_size(&stt, "Nat.add_comm"); - analyze_block_size_stats(&stt); // Phase 5: Serialize eprintln!("[rust-compile] Phase 5: Serializing env..."); @@ -1769,6 +1760,7 @@ extern "C" fn rs_tmp_decode_const_map( Ok(fresh_env) => { let fresh_stt = ix_compile::compile::CompileState { env: fresh_env, + sharing_limits: stt.sharing_limits.clone(), ..Default::default() }; for entry in fresh_stt.env.named.iter() { @@ -3880,6 +3872,7 @@ extern "C" fn rs_compile_validate_aux( // importantly, the other 30 cores no longer idle while one thread // chases every Arc. let compile_env_only = std::mem::take(&mut stt.env); + let sharing_limits = stt.sharing_limits.clone(); rayon::join(|| drop(dstt), || drop(stt)); // ══════════════════════════════════════════════════════════════════════ @@ -3965,6 +3958,7 @@ extern "C" fn rs_compile_validate_aux( Some(fresh_env) => { let fresh_stt = ix_compile::compile::CompileState { env: fresh_env, + sharing_limits, ..Default::default() }; let mut n_original = 0usize; @@ -4496,198 +4490,3 @@ fn serialized_const_size(constant: &ixon::constant::Constant) -> usize { constant.put(&mut buf); buf.len() } - -/// Analyze block size statistics: hash-consing vs serialization. -#[cfg(feature = "test-ffi")] -fn analyze_block_size_stats(stt: &ix_compile::compile::CompileState) { - use ix_compile::compile::BlockSizeStats; - - // Check if hash-consed size tracking was enabled - let tracking_enabled = ix_compile::compile::TRACK_HASH_CONSED_SIZE - .load(std::sync::atomic::Ordering::Relaxed); - if !tracking_enabled { - println!("\n=== Block Size Analysis ==="); - println!( - " Hash-consed size tracking disabled (set IX_TRACK_HASH_CONSED=1 to enable)" - ); - return; - } - - // Collect all stats into a vector for analysis - let stats: Vec<(String, BlockSizeStats)> = stt - .block_stats - .iter() - .map(|entry| (entry.key().pretty(), entry.value().clone())) - .collect(); - - if stats.is_empty() { - println!("\n=== Block Size Analysis ==="); - println!(" No block statistics collected"); - return; - } - - // Compute totals - let total_hash_consed: usize = - stats.iter().map(|(_, s)| s.hash_consed_size).sum(); - let total_serialized: usize = - stats.iter().map(|(_, s)| s.serialized_size).sum(); - let total_blocks = stats.len(); - let total_consts: usize = stats.iter().map(|(_, s)| s.const_count).sum(); - - // Compute per-block overhead (serialized - hash_consed) - let mut overheads: Vec<(String, isize, f64, usize)> = stats - .iter() - .map(|(name, s)| { - let overhead = s.serialized_size as isize - s.hash_consed_size as isize; - let ratio = if s.hash_consed_size > 0 { - s.serialized_size as f64 / s.hash_consed_size as f64 - } else { - 1.0 - }; - (name.clone(), overhead, ratio, s.const_count) - }) - .collect(); - - // Sort by overhead descending (most bloated first) - overheads.sort_by_key(|entry| std::cmp::Reverse(entry.1)); - - // Compute statistics - let avg_ratio = if total_hash_consed > 0 { - total_serialized as f64 / total_hash_consed as f64 - } else { - 1.0 - }; - - // Find blocks with worst ratio (only for blocks with >100 bytes hash-consed) - let mut ratios: Vec<_> = stats - .iter() - .filter(|(_, s)| s.hash_consed_size > 100) - .map(|(name, s)| { - let ratio = s.serialized_size as f64 / s.hash_consed_size as f64; - (name.clone(), ratio, s.hash_consed_size, s.serialized_size) - }) - .collect(); - ratios - .sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal)); - - println!("\n=== Block Size Analysis (Hash-Consing vs Serialization) ==="); - println!(" Total blocks: {}", total_blocks); - println!(" Total constants: {}", total_consts); - println!(); - println!( - " Total hash-consed size: {} bytes ({:.2} KB)", - total_hash_consed, - total_hash_consed as f64 / 1024.0 - ); - println!( - " Total serialized size: {} bytes ({:.2} KB)", - total_serialized, - total_serialized as f64 / 1024.0 - ); - println!(" Overall ratio: {:.3}x", avg_ratio); - println!( - " Total overhead: {} bytes ({:.2} KB)", - total_serialized as isize - total_hash_consed as isize, - (total_serialized as f64 - total_hash_consed as f64) / 1024.0 - ); - - // Distribution of ratios (more granular buckets for analysis) - let count_in_range = |lo: f64, hi: f64| -> usize { - stats - .iter() - .filter(|(_, s)| { - if s.hash_consed_size == 0 { - return false; - } - let r = s.serialized_size as f64 / s.hash_consed_size as f64; - r >= lo && r < hi - }) - .count() - }; - - let ratio_under_0_05 = count_in_range(0.0, 0.05); - let ratio_0_05_to_0_1 = count_in_range(0.05, 0.1); - let ratio_0_1_to_0_2 = count_in_range(0.1, 0.2); - let ratio_0_2_to_0_5 = count_in_range(0.2, 0.5); - let ratio_0_5_to_1 = count_in_range(0.5, 1.0); - let ratio_1_to_1_5 = count_in_range(1.0, 1.5); - let ratio_1_5_to_2 = count_in_range(1.5, 2.0); - let ratio_over_2 = count_in_range(2.0, f64::INFINITY); - - println!(); - println!(" Ratio distribution (serialized / hash-consed):"); - println!(" < 0.05x (20x+ compression): {} blocks", ratio_under_0_05); - println!(" 0.05-0.1x (10-20x): {} blocks", ratio_0_05_to_0_1); - println!(" 0.1-0.2x (5-10x): {} blocks", ratio_0_1_to_0_2); - println!(" 0.2-0.5x (2-5x): {} blocks", ratio_0_2_to_0_5); - println!(" 0.5-1.0x (1-2x): {} blocks", ratio_0_5_to_1); - println!(" 1.0-1.5x (slight bloat): {} blocks", ratio_1_to_1_5); - println!(" 1.5-2.0x: {} blocks", ratio_1_5_to_2); - println!(" >= 2.0x (high bloat): {} blocks", ratio_over_2); - - // Top 10 blocks by absolute overhead - if !overheads.is_empty() { - println!(); - println!(" Top 10 blocks by overhead (serialized - hash_consed):"); - for (name, overhead, ratio, const_count) in overheads.iter().take(10) { - println!( - " {:+} bytes ({:.2}x, {} consts): {}", - overhead, - ratio, - const_count, - truncate_name(name, 50) - ); - } - } - - // Top 10 blocks by worst ratio (with >100 bytes) - if !ratios.is_empty() { - println!(); - println!(" Top 10 blocks by ratio (hash-consed > 100 bytes):"); - for (name, ratio, hc, ser) in ratios.iter().take(10) { - println!( - " {:.2}x ({} -> {} bytes): {}", - ratio, - hc, - ser, - truncate_name(name, 50) - ); - } - } - - // Bottom 10 blocks by ratio (best compression) - let mut best_ratios: Vec<_> = stats - .iter() - .filter(|(_, s)| s.hash_consed_size > 100) - .map(|(name, s)| { - let ratio = s.serialized_size as f64 / s.hash_consed_size as f64; - (name.clone(), ratio, s.hash_consed_size, s.serialized_size) - }) - .collect(); - best_ratios - .sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal)); - - if !best_ratios.is_empty() { - println!(); - println!(" Top 10 blocks by best ratio (most efficient):"); - for (name, ratio, hc, ser) in best_ratios.iter().take(10) { - println!( - " {:.2}x ({} -> {} bytes): {}", - ratio, - hc, - ser, - truncate_name(name, 50) - ); - } - } -} - -/// Truncate a name for display. -#[cfg(feature = "test-ffi")] -fn truncate_name(name: &str, max_len: usize) -> String { - if name.len() <= max_len { - name.to_string() - } else { - format!("...{}", &name[name.len() - max_len + 3..]) - } -} diff --git a/crates/ffi/src/lean_ixon/expr.rs b/crates/ffi/src/lean_ixon/expr.rs index 94becd760..9c25ffa8f 100644 --- a/crates/ffi/src/lean_ixon/expr.rs +++ b/crates/ffi/src/lean_ixon/expr.rs @@ -132,7 +132,7 @@ impl LeanIxonExpr { } impl LeanIxonExpr { - /// Decode all v3 expression forms without erasing contracts. + /// Decode all Ixon expression forms without erasing contracts. pub fn decode(&self) -> IxonExpr { let ctor = self.as_ctor(); let tag = ctor.tag(); diff --git a/crates/ffi/src/lean_ixon/serialize.rs b/crates/ffi/src/lean_ixon/serialize.rs index 49890d2ea..4904f9c53 100644 --- a/crates/ffi/src/lean_ixon/serialize.rs +++ b/crates/ffi/src/lean_ixon/serialize.rs @@ -6,26 +6,13 @@ use std::sync::Arc; use crate::lean::{ - LeanIxAddress, LeanIxonConstant, LeanIxonExpr, LeanIxonRawEnv, LeanIxonUniv, + LeanIxonConstant, LeanIxonExpr, LeanIxonRawEnv, LeanIxonUniv, }; use ix_common::address::Address; use ixon::serialize::put_expr; -use ixon::sharing::hash_expr; use ixon::univ::put_univ; use lean_ffi::object::{LeanBorrowed, LeanByteArray, LeanOwned}; -/// Check if Lean's computed hash matches Rust's computed hash. -#[unsafe(no_mangle)] -pub extern "C" fn rs_expr_hash_matches( - expr_obj: LeanIxonExpr>, - expected_hash: LeanIxAddress>, -) -> bool { - let expr = Arc::new(expr_obj.decode()); - let hash = hash_expr(&expr); - let expected = expected_hash.decode(); - Address::from_slice(hash.as_bytes()).is_ok_and(|h| h == expected) -} - /// Check if Lean's Ixon.Univ serialization matches Rust. #[unsafe(no_mangle)] pub extern "C" fn rs_eq_univ_serialization( diff --git a/crates/ffi/src/lean_ixon/sharing.rs b/crates/ffi/src/lean_ixon/sharing.rs index f49218f49..8b2e4ce89 100644 --- a/crates/ffi/src/lean_ixon/sharing.rs +++ b/crates/ffi/src/lean_ixon/sharing.rs @@ -1,157 +1,154 @@ -//! Ixon sharing analysis FFI. - -use std::sync::Arc; - -use crate::lean::LeanIxonExpr; -use ixon::expr::Expr as IxonExpr; -use ixon::serialize::put_expr; -use ixon::sharing::{analyze_block, build_sharing_vec, decide_sharing}; -use lean_ffi::object::{LeanArray, LeanBorrowed, LeanByteArray, LeanOwned}; +//! Exact and canonical sharing FFI (test hooks for the Lean/Rust +//! differential, `Tests/Ix/SharingExactFFI.lean`). + +use ixon::sharing_exact::ExactSharingLimits; +use lean_ffi::object::{LeanBorrowed, LeanByteArray, LeanExcept, LeanOwned}; + +/// The limits of every hook: the defaults (the compiler's) in the checked +/// mode (`full_check`), so that the differential also builds and checks +/// every candidate of the tiered construction. The checked mode changes no +/// output and no limit outcome; it fails only on an internal discrepancy. +fn parity_limits() -> ExactSharingLimits { + ExactSharingLimits { full_check: true, ..ExactSharingLimits::default() } +} -/// FFI: Debug sharing analysis - print usage counts for subterms with usage >= 2. -/// This helps diagnose why Lean and Rust make different sharing decisions. +/// FFI: exact-minimum sharing of one serialized Constant (the width-state +/// search, a test oracle; not the compiler path). +/// +/// Lean signature: +/// `@[extern "rs_exact_sharing_normalize"] +/// opaque exactSharingNormalize : @& ByteArray → Except String ByteArray` +/// +/// Decodes exactly one Constant (trailing bytes are rejected), expands and +/// validates its sharing table under the backward-reference rule, and +/// returns the serialized exact-minimum encoding computed with the default +/// limits ([`parity_limits`]). Error strings start with `decode:`, +/// `malformed sharing:`, `format bound:`, `resource exhausted:` or +/// `internal error:`; no error carries a partial encoding. #[unsafe(no_mangle)] -pub extern "C" fn rs_debug_sharing_analysis( - exprs_obj: LeanArray>, -) { - let exprs: Vec> = - exprs_obj.map(|x| Arc::new(LeanIxonExpr(x).decode())); - - println!("[Rust] Analyzing {} input expressions", exprs.len()); - - let (info_map, _ptr_to_hash, topo_order) = analyze_block(&exprs, false); - let effective_sizes = - ixon::sharing::compute_effective_sizes(&info_map, &topo_order); - - println!("[Rust] Found {} unique subterms", info_map.len()); - - // Collect subterms with usage >= 2 - let mut candidates: Vec<_> = info_map - .iter() - .filter(|(_, info)| info.usage_count >= 2) - .filter_map(|(hash, info)| { - let eff_size = *effective_sizes.get(hash)?; - Some((hash, info, eff_size)) - }) - .collect(); - - // Sort by usage count descending - candidates.sort_by_key(|entry| std::cmp::Reverse(entry.1.usage_count)); - - println!("[Rust] Subterms with usage >= 2:"); - for (hash, info, eff_size) in candidates { - let n = info.usage_count; - let n_i = n.cast_signed(); - let eff_size_i = eff_size.cast_signed(); - let potential = (n_i - 1) * eff_size_i - (n_i + eff_size_i); - println!( - " usage={} eff_size={} potential={} hash={:.8}", - n, eff_size, potential, hash - ); - println!(" expr={:?}", info.expr); +extern "C" fn rs_exact_sharing_normalize( + bytes_obj: LeanByteArray>, +) -> LeanExcept { + use ixon::sharing_exact::normalize_constant_bytes; + match normalize_constant_bytes(bytes_obj.as_bytes(), &parity_limits()) { + Ok(bytes) => LeanExcept::ok(LeanByteArray::from_bytes(&bytes)), + Err(err) => LeanExcept::error_string(&err.to_string()), } } -/// FFI: Run Rust's sharing analysis on Lean-provided Ixon.Expr array. -/// Returns the number of shared items Rust would produce. +/// FFI: uniform-width exact sharing of one serialized Constant (phase 1 of +/// the canonical construction, at a given width). +/// +/// Lean signature: +/// `@[extern "rs_uniform_sharing_normalize"] +/// opaque uniformSharingNormalize : UInt64 → @& ByteArray → Except String ByteArray` +/// +/// Every Share is priced `w` bytes (the uniform-width model of +/// `Ix.Sharing.Exact.Uniform`); the output uses real table indices. Uses the +/// default limits ([`parity_limits`]); `w = 0` is a `format bound:` error. #[unsafe(no_mangle)] -extern "C" fn rs_analyze_sharing_count( - exprs_obj: LeanArray>, -) -> u64 { - let exprs = LeanIxonExpr::decode_array(&exprs_obj); - - let (info_map, _ptr_to_hash, topo_order) = analyze_block(&exprs, false); - let shared_hashes = decide_sharing(&info_map, &topo_order); - - shared_hashes.len() as u64 +extern "C" fn rs_uniform_sharing_normalize( + w: u64, + bytes_obj: LeanByteArray>, +) -> LeanExcept { + use ixon::sharing_exact::normalize_constant_bytes_uniform; + match normalize_constant_bytes_uniform( + w, + bytes_obj.as_bytes(), + &parity_limits(), + ) { + Ok(bytes) => LeanExcept::ok(LeanByteArray::from_bytes(&bytes)), + Err(err) => LeanExcept::error_string(&err.to_string()), + } } -/// FFI: Run Rust's full sharing pipeline on Lean-provided Ixon.Expr array. -/// Writes the sharing vector and rewritten exprs to output arrays. -/// Returns number of shared items. +/// FFI: tiered canonical sharing of one serialized Constant. +/// +/// Lean signature: +/// `@[extern "rs_tiered_sharing_normalize"] +/// opaque tieredSharingNormalize : @& ByteArray → Except String ByteArray` +/// +/// Expands the Constant's table and re-shares it with the canonical tiered +/// construction under the TagN layout and the default limits in the checked +/// mode ([`parity_limits`]); the output is serialized with the wire (TagN) +/// Share code. #[unsafe(no_mangle)] -extern "C" fn rs_run_sharing_analysis( - exprs_obj: LeanArray>, - out_sharing_vec: LeanByteArray, - out_rewritten: LeanByteArray, -) -> u64 { - let exprs = LeanIxonExpr::decode_array(&exprs_obj); - - let (info_map, ptr_to_hash, topo_order) = analyze_block(&exprs, false); - let shared_hashes = decide_sharing(&info_map, &topo_order); - let (rewritten_exprs, sharing_vec) = build_sharing_vec( - &exprs, - &shared_hashes, - &ptr_to_hash, - &info_map, - &topo_order, - ); - - // Serialize sharing vector to bytes - let mut sharing_bytes: Vec = Vec::new(); - for expr in &sharing_vec { - put_expr(expr, &mut sharing_bytes); - } - - // Serialize rewritten exprs to bytes - let mut rewritten_bytes: Vec = Vec::new(); - for expr in &rewritten_exprs { - put_expr(expr, &mut rewritten_bytes); +extern "C" fn rs_tiered_sharing_normalize( + bytes_obj: LeanByteArray>, +) -> LeanExcept { + use ixon::sharing_exact::{ShareLayout, normalize_constant_bytes_tiered}; + match normalize_constant_bytes_tiered( + ShareLayout::TagN, + bytes_obj.as_bytes(), + &parity_limits(), + ) { + Ok(bytes) => LeanExcept::ok(LeanByteArray::from_bytes(&bytes)), + Err(err) => LeanExcept::error_string(&err.to_string()), } - - // Write to output arrays - unsafe { out_sharing_vec.set_data(&sharing_bytes) }; - unsafe { out_rewritten.set_data(&rewritten_bytes) }; - - shared_hashes.len() as u64 } -/// FFI: Compare Lean's sharing analysis with Rust's on the same input. -/// Takes: exprs (Array Expr), lean_sharing (Array Expr), lean_rewritten (Array Expr) -/// Returns packed u64: -/// - bits 0-31: 1 if sharing vectors match, 0 otherwise -/// - bits 32-47: Lean sharing count -/// - bits 48-63: Rust sharing count +/// FFI: build one block Constant through the compiler's sharing functions. +/// +/// Lean signature: +/// `@[extern "rs_compiler_sharing_build"] +/// opaque compilerSharingBuild : @& ByteArray → Except String ByteArray` +/// +/// Decodes exactly one Constant whose roots carry no sharing table, and +/// rebuilds it with `ix_compile::compile::apply_sharing_to_*_with_limits` +/// (the explicit-limits forms of the functions every compile, aux-gen, +/// kernel-egress and decompile-recompile path calls) under the default +/// limits in the checked mode ([`parity_limits`]; the compiler itself runs +/// the default mode, which writes the same bytes). Projections are returned +/// unchanged. Errors are the compile error's text, prefixed `decode:` for +/// input errors. #[unsafe(no_mangle)] -extern "C" fn rs_compare_sharing_analysis( - exprs_obj: LeanArray>, - lean_sharing_obj: LeanArray>, - _lean_rewritten_obj: LeanArray>, -) -> u64 { - // Decode input expressions - let exprs = LeanIxonExpr::decode_array(&exprs_obj); - - // Decode Lean's sharing vector - let lean_sharing = LeanIxonExpr::decode_array(&lean_sharing_obj); - - // Run Rust's sharing analysis - let (info_map, ptr_to_hash, topo_order) = analyze_block(&exprs, false); - let shared_hashes = decide_sharing(&info_map, &topo_order); - let (_rewritten_exprs, rust_sharing) = build_sharing_vec( - &exprs, - &shared_hashes, - &ptr_to_hash, - &info_map, - &topo_order, - ); - - // Compare sharing vectors - let lean_count = lean_sharing.len() as u64; - let rust_count = rust_sharing.len() as u64; - - // Serialize both to bytes for comparison - let mut lean_bytes: Vec = Vec::new(); - for expr in &lean_sharing { - put_expr(expr, &mut lean_bytes); +extern "C" fn rs_compiler_sharing_build( + bytes_obj: LeanByteArray>, +) -> LeanExcept { + use ix_compile::compile::{ + apply_sharing_to_axiom_with_limits, + apply_sharing_to_definition_with_limits, + apply_sharing_to_mutual_block_with_limits, + apply_sharing_to_quotient_with_limits, + apply_sharing_to_recursor_with_limits, + }; + use ixon::constant::{Constant, ConstantInfo}; + let limits = parity_limits(); + let mut input = bytes_obj.as_bytes(); + let c = match Constant::get(&mut input) { + Ok(c) => c, + Err(e) => return LeanExcept::error_string(&format!("decode: {e}")), + }; + if !input.is_empty() || !c.sharing.is_empty() { + return LeanExcept::error_string( + "decode: expected one Constant with an empty sharing table", + ); } - - let mut rust_bytes: Vec = Vec::new(); - for expr in &rust_sharing { - put_expr(expr, &mut rust_bytes); + let (refs, univs) = (c.refs.clone(), c.univs.clone()); + let built = match c.info.clone() { + ConstantInfo::Defn(d) => { + apply_sharing_to_definition_with_limits(&limits, d, refs, univs) + }, + ConstantInfo::Recr(r) => { + apply_sharing_to_recursor_with_limits(&limits, r, refs, univs) + }, + ConstantInfo::Axio(a) => { + apply_sharing_to_axiom_with_limits(&limits, a, refs, univs) + }, + ConstantInfo::Quot(q) => { + apply_sharing_to_quotient_with_limits(&limits, q, refs, univs) + }, + ConstantInfo::Muts(ms) => { + apply_sharing_to_mutual_block_with_limits(&limits, ms, refs, univs) + }, + _ => Ok(c), + }; + match built { + Ok(out) => { + let mut buf = Vec::new(); + out.put(&mut buf); + LeanExcept::ok(LeanByteArray::from_bytes(&buf)) + }, + Err(e) => LeanExcept::error_string(&e.to_string()), } - - let matches = if lean_bytes == rust_bytes { 1u64 } else { 0u64 }; - - // Pack result: matches | (lean_count << 32) | (rust_count << 48) - matches | (lean_count << 32) | (rust_count << 48) } diff --git a/crates/ixon/Cargo.toml b/crates/ixon/Cargo.toml index 744417cfd..ee1b00fea 100644 --- a/crates/ixon/Cargo.toml +++ b/crates/ixon/Cargo.toml @@ -4,6 +4,11 @@ version.workspace = true edition.workspace = true license.workspace = true +[features] +# Scoped phase timers of the canonical sharing construction +# (`sharing_exact::profile_report`); diagnostic only, off by default. +sharing-profile = [] + [dependencies] bignat = { workspace = true } blake3 = { workspace = true } @@ -23,6 +28,8 @@ rayon = { workspace = true } [dev-dependencies] ix-common = { workspace = true, features = ["quickcheck"] } +# The process allocator of the `ix` binary, for the `sharing_corpus` runner. +mimalloc = { workspace = true } quickcheck = { workspace = true } quickcheck_macros = { workspace = true } diff --git a/crates/ixon/examples/arena_study.rs b/crates/ixon/examples/arena_study.rs new file mode 100644 index 000000000..59fd73fc6 --- /dev/null +++ b/crates/ixon/examples/arena_study.rs @@ -0,0 +1,1387 @@ +//! ExprMeta arena encoding study. +//! +//! Streams §5 of an `.ixe` file (`Env::parse_lazy_index` + +//! `NamedMetaCursor`), decodes every `ConstantMeta` (primary and `original`) +//! with the production reader, and prices each metadata arena under several +//! child-reference encodings. Every price comes from one size function that +//! mirrors the arena writer; `--check-writer` compares it with the production +//! writer. +//! +//! Encodings (only the arena's integers differ; tag bytes, raw addresses and +//! the rest of the file are the same): +//! +//! * `v3`: absolute child indices, every integer `Tag0` (the v3 format); +//! * `abs`: absolute child indices, every integer TagN (`f = 0`) — the v4 +//! baseline once `Tag0` is replaced everywhere; +//! * `delta`: every child reference is the backward delta `i - 1 - c` +//! (wrapping) as TagN, every other integer TagN; +//! * `implicit`: post-order implicit children. A structural child slot whose +//! node is the one the post-order cursor expects is "fresh" and costs no +//! bytes (one bit in the node tag); every other child reference is an +//! explicit backward delta `i - 1 - c` (wrapping) as TagN +//! (`docs/sharing-minimum-arena.md`); +//! * `implicit + hash-consing`: `implicit` after hash-consing each arena +//! (identical nodes with identical children merged, first occurrence kept; +//! nodes carrying a level-spelling patch are never merged). +//! +//! The tool also reports the child-delta distribution, the fraction of fresh +//! children, and the name-reference bytes inside arenas. +//! +//! ```text +//! cargo run --release -p ixon --example arena_study -- +//! [--check-writer] compare every arena's predicted size under the +//! production writer's encoding (as the next two +//! options describe it) with `ExprMeta::put_with`, and +//! round-trip it through the production writer and +//! reader +//! [--writer v3|implicit] the production writer's encoding: v3 +//! (absolute children, every integer Tag0) or +//! implicit (the default; other integers as +//! --other-tagn says) +//! [--other-tagn] the production writer writes every integer other +//! than child references as TagN (default Tag0) +//! [--int-census] instead: price every f = 0 integer outside constant +//! bodies under Tag0, TagN and TagN with a 4-byte rung, +//! self-checked against every §5 window +//! ``` +//! +//! The study compares the v3 arena (Tag0 integers) with TagN encodings for +//! a follow-up arena change. The writer of this checkout is the v4 writer +//! (implicit children, every other integer TagN), so `--check-writer` +//! matches it only with `--other-tagn`; the default (Tag0 integers) and +//! `--writer v3` describe earlier writers and match only a checkout that has +//! them. TagN now includes the 4-byte rung that `--int-census` evaluated, so +//! its rung column equals TagN. + +#![allow(clippy::cast_precision_loss)] +#![allow(clippy::cast_possible_truncation)] +#![allow(clippy::cast_possible_wrap)] +#![allow(clippy::cast_sign_loss)] +#![allow(clippy::needless_range_loop)] + +use std::collections::{HashMap, HashSet}; +use std::sync::Arc; +use std::time::Instant; + +use ix_common::address::Address; +use ix_common::env::ReducibilityHints; +use ixon::Env; +use ixon::TagN; +use ixon::constant::Constant; +use ixon::metadata::{ + CallSiteEntry, ConstantMeta, ConstantMetaInfo, DataValue, ExprMeta, + ExprMetaData, NameGet, NameIndex, NamePut, +}; +use ixon::serialize::{NamedMetaCursor, put_expr, put_named_indexed}; +use ixon::univ::put_univ; + +// --------------------------------------------------------------------------- +// Integer prices +// --------------------------------------------------------------------------- + +/// Width of the v3 `Tag0` code. +fn tag0_w(v: u64) -> usize { + if v < 128 { 1 } else { 1 + (8 - (v.leading_zeros() as usize) / 8) } +} + +/// Width of TagN with a 0-bit flag. +fn tagn_w(v: u64) -> usize { + TagN::byte_width(0, v) +} + +fn code_w(tagn: bool, v: u64) -> usize { + if tagn { tagn_w(v) } else { tag0_w(v) } +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +enum Enc { + V3, + Abs, + Delta, + Implicit, +} + +const ENCS: [Enc; 4] = [Enc::V3, Enc::Abs, Enc::Delta, Enc::Implicit]; + +/// Integer codes per field family (`true` = TagN, `false` = Tag0). `names` +/// covers name indices (node names, mdata keys, `OfName` values), `mdata` +/// the mdata stack and map counts, `scalars` every other integer of the +/// arena (length prefix, call-site counts and scalars). Child references +/// follow `children`. +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +struct Pricing { + names: bool, + mdata: bool, + scalars: bool, + children: Enc, +} + +impl Pricing { + fn of(enc: Enc) -> Pricing { + let n = enc != Enc::V3; + Pricing { names: n, mdata: n, scalars: n, children: enc } + } +} + +// --------------------------------------------------------------------------- +// Node structure +// --------------------------------------------------------------------------- + +fn kind(n: &ExprMetaData) -> usize { + match n { + ExprMetaData::Leaf => 0, + ExprMetaData::App { .. } => 1, + ExprMetaData::Binder { .. } => 2, + ExprMetaData::LetBinder { .. } => 3, + ExprMetaData::Ref { .. } => 4, + ExprMetaData::Prj { .. } => 5, + ExprMetaData::Mdata { .. } => 6, + ExprMetaData::CallSite { .. } => 7, + ExprMetaData::EtaCallSite { .. } => 8, + } +} + +const KIND_NAMES: [&str; 9] = [ + "leaf", + "app", + "binder", + "letBinder", + "ref", + "prj", + "mdata", + "callSite", + "etaCallSite", +]; + +const SLOT_NAMES: [&str; 10] = [ + "App function", + "App argument", + "Binder type", + "Binder body", + "Let type", + "Let value", + "Let body", + "Prj child", + "Mdata child", + "call-site references", +]; + +/// Structural child slots (the ones that can be implicit), in field order, +/// with their report slot ids. +fn slots(n: &ExprMetaData) -> Vec<(usize, u64)> { + match n { + ExprMetaData::App { children } => vec![(0, children[0]), (1, children[1])], + ExprMetaData::Binder { children, .. } => { + vec![(2, children[0]), (3, children[1])] + }, + ExprMetaData::LetBinder { children, .. } => { + vec![(4, children[0]), (5, children[1]), (6, children[2])] + }, + ExprMetaData::Prj { child, .. } => vec![(7, *child)], + ExprMetaData::Mdata { child, .. } => vec![(8, *child)], + _ => vec![], + } +} + +/// Arena references of call-site nodes (always explicit), in write order. +fn callsite_refs(n: &ExprMetaData) -> Vec { + let mut out = Vec::new(); + let ents = |es: &[CallSiteEntry], out: &mut Vec| { + for e in es { + match e { + CallSiteEntry::Kept { meta, .. } + | CallSiteEntry::Collapsed { meta, .. } => out.push(*meta), + } + } + }; + match n { + ExprMetaData::CallSite { entries, canon_meta, orig_head, .. } => { + ents(entries, &mut out); + out.extend_from_slice(canon_meta); + if let Some((_, m)) = orig_head { + out.push(*m); + } + }, + ExprMetaData::EtaCallSite { entries, canon_meta, wrapper_meta, .. } => { + ents(entries, &mut out); + out.extend_from_slice(canon_meta); + out.push(*wrapper_meta); + }, + _ => {}, + } + out +} + +/// The node's own name reference, if any. +fn node_name(n: &ExprMetaData) -> Option<&Address> { + match n { + ExprMetaData::Binder { name, .. } + | ExprMetaData::LetBinder { name, .. } + | ExprMetaData::Ref { name } + | ExprMetaData::CallSite { name, .. } + | ExprMetaData::EtaCallSite { name, .. } => Some(name), + ExprMetaData::Prj { struct_name, .. } => Some(struct_name), + _ => None, + } +} + +/// Bytes of a node excluding its child references and its own name +/// reference: tag byte, mdata payload, call-site scalars. +fn rest_w(n: &ExprMetaData, ix: &NameIndex, pr: Pricing) -> usize { + let w = |v: u64| code_w(pr.scalars, v); + let mw = |v: u64| code_w(pr.mdata, v); + let name_w = + |a: &Address| code_w(pr.names, *ix.get(a).expect("name in index")); + let dv_w = |d: &DataValue| -> usize { + 1 + match d { + DataValue::OfBool(_) => 1, + DataValue::OfName(a) => name_w(a), + _ => 32, + } + }; + let ents_w = |es: &[CallSiteEntry]| -> usize { + w(es.len() as u64) + + es + .iter() + .map(|e| match e { + CallSiteEntry::Kept { canon_idx: x, .. } + | CallSiteEntry::Collapsed { sharing_idx: x, .. } => 1 + w(*x), + }) + .sum::() + }; + 1 + match n { + ExprMetaData::Mdata { mdata, .. } => { + mw(mdata.len() as u64) + + mdata + .iter() + .map(|kv| { + mw(kv.len() as u64) + + kv.iter().map(|(k, d)| name_w(k) + dv_w(d)).sum::() + }) + .sum::() + }, + ExprMetaData::CallSite { entries, canon_meta, orig_head, .. } => { + ents_w(entries) + + w(canon_meta.len() as u64) + + 1 + + orig_head.map_or(0, |(s, _)| w(s)) + }, + ExprMetaData::EtaCallSite { n_synth, entries, canon_meta, .. } => { + w(*n_synth) + ents_w(entries) + w(canon_meta.len() as u64) + }, + _ => 0, + } +} + +// --------------------------------------------------------------------------- +// The implicit (post-order cursor) encoding +// --------------------------------------------------------------------------- + +/// Per node, the fresh mask over its structural slots: bit `s` set = slot +/// `s` is the node the post-order cursor expects and is not written. The +/// cursor starts at `i - 1`, visits the slots last to first, and after a +/// fresh child `c` moves to `lo[c] - 1`, where `lo[c]` is the first index of +/// `c`'s contiguous block (`lo[i] = cursor + 1` after `i`'s slots). +fn implicit_masks(nodes: &[ExprMetaData]) -> Vec { + let mut lo: Vec = Vec::with_capacity(nodes.len()); + let mut masks = Vec::with_capacity(nodes.len()); + for (i, n) in nodes.iter().enumerate() { + let sl = slots(n); + let mut cur: i64 = i as i64 - 1; + let mut mask = 0u8; + for s in (0..sl.len()).rev() { + let c = sl[s].1; + if cur >= 0 && c == cur as u64 { + mask |= 1 << s; + cur = lo[c as usize] as i64 - 1; + } + } + lo.push((cur + 1) as u64); + masks.push(mask); + } + masks +} + +/// Child-reference bytes of node `i` under `enc` (`mask` only for +/// `Implicit`). +fn child_w(n: &ExprMetaData, i: usize, mask: u8, enc: Enc) -> usize { + let delta = |c: u64| (i as u64).wrapping_sub(1).wrapping_sub(c); + let mut b = 0; + for (s, (_, c)) in slots(n).into_iter().enumerate() { + b += match enc { + Enc::V3 => tag0_w(c), + Enc::Abs => tagn_w(c), + Enc::Delta => tagn_w(delta(c)), + Enc::Implicit => { + if mask & (1 << s) != 0 { + 0 + } else { + tagn_w(delta(c)) + } + }, + }; + } + for c in callsite_refs(n) { + b += match enc { + Enc::V3 => tag0_w(c), + Enc::Abs => tagn_w(c), + Enc::Delta | Enc::Implicit => tagn_w(delta(c)), + }; + } + b +} + +/// Bytes of node `i` (with its implicit mask) under `pr`. +fn node_w( + n: &ExprMetaData, + i: usize, + mask: u8, + ix: &NameIndex, + pr: Pricing, +) -> usize { + rest_w(n, ix, pr) + + node_name(n).map_or(0, |a| code_w(pr.names, ix[a])) + + child_w(n, i, mask, pr.children) +} + +/// Predicted arena bytes (length prefix + nodes) under `pr`. +fn arena_w(nodes: &[ExprMetaData], ix: &NameIndex, pr: Pricing) -> usize { + let masks = implicit_masks(nodes); + let mut b = code_w(pr.scalars, nodes.len() as u64); + for (i, n) in nodes.iter().enumerate() { + b += node_w(n, i, masks[i], ix, pr); + } + b +} + +/// Renumber every arena reference of a node. +fn map_refs(n: &mut ExprMetaData, f: &dyn Fn(u64) -> u64) { + let ents = |es: &mut Vec| { + for e in es.iter_mut() { + match e { + CallSiteEntry::Kept { meta, .. } + | CallSiteEntry::Collapsed { meta, .. } => *meta = f(*meta), + } + } + }; + match n { + ExprMetaData::App { children } | ExprMetaData::Binder { children, .. } => { + for c in children.iter_mut() { + *c = f(*c); + } + }, + ExprMetaData::LetBinder { children, .. } => { + for c in children.iter_mut() { + *c = f(*c); + } + }, + ExprMetaData::Prj { child, .. } | ExprMetaData::Mdata { child, .. } => { + *child = f(*child); + }, + ExprMetaData::CallSite { entries, canon_meta, orig_head, .. } => { + ents(entries); + for c in canon_meta.iter_mut() { + *c = f(*c); + } + if let Some((_, m)) = orig_head { + *m = f(*m); + } + }, + ExprMetaData::EtaCallSite { entries, canon_meta, wrapper_meta, .. } => { + ents(entries); + for c in canon_meta.iter_mut() { + *c = f(*c); + } + *wrapper_meta = f(*wrapper_meta); + }, + ExprMetaData::Leaf | ExprMetaData::Ref { .. } => {}, + } +} + +/// Hash-cons an arena: first occurrences in order, references renumbered; +/// nodes whose index carries a level-spelling patch stay distinct. +fn hash_cons( + nodes: &[ExprMetaData], + patched: &HashSet, +) -> (Vec, Vec) { + let mut map: HashMap<(Option, ExprMetaData), u64> = HashMap::new(); + let mut canon: Vec = Vec::with_capacity(nodes.len()); + let mut out: Vec = Vec::new(); + for (i, n) in nodes.iter().enumerate() { + let mut m = n.clone(); + // Non-backward references (none expected) are kept verbatim. + map_refs(&mut m, &|c| canon.get(c as usize).copied().unwrap_or(c)); + let key = (patched.contains(&(i as u64)).then_some(i), m.clone()); + let id = *map.entry(key).or_insert_with(|| { + out.push(m); + (out.len() - 1) as u64 + }); + canon.push(id); + } + (out, canon) +} + +// --------------------------------------------------------------------------- +// Statistics +// --------------------------------------------------------------------------- + +/// TagN (`f = 0`) width buckets: 1, 2, 3, 5, 9 bytes. +fn wbucket(v: u64) -> usize { + match tagn_w(v) { + 1 => 0, + 2 => 1, + 3 => 2, + 5 => 3, + _ => 4, + } +} + +#[derive(Default)] +struct Stats { + entries: u64, + arenas: u64, + orig_arenas: u64, + nodes: u64, + kind_nodes: [u64; 9], + /// Bytes per encoding (index into `ENCS`), then `implicit + hash-consing` + /// and `delta + hash-consing`. + bytes: [u64; 6], + /// Root and patch indices outside the arena (type/value/rule roots, + /// level-spelling patch keys): count, TagN bytes before and after + /// hash-consing, and how many point to a merged (redirected) node. + roots: u64, + root_bytes: u64, + root_bytes_hc: u64, + roots_redirected: u64, + /// Call-site references redirected by hash-consing. + cs_refs_redirected: u64, + /// Node bytes per kind per encoding (length prefixes excluded). + kind_bytes: [[u64; 9]; 4], + slot_children: [u64; 10], + slot_fresh: [u64; 10], + slot_forward: [u64; 10], + /// Δ = 0 (the immediately preceding node). + slot_delta0: [u64; 10], + slot_delta_w: [[u64; 5]; 10], + slot_explicit_w: [[u64; 5]; 10], + hc_nodes: u64, + name_refs: u64, + name_bytes_v3: u64, + name_bytes_tagn: u64, + name_distinct: u64, + name_local_bytes: u64, + writer_checked: u64, + writer_size_mismatch: u64, + writer_roundtrip_mismatch: u64, + writer_bytes: u64, + v3_node_mismatch: u64, + /// Writer check: per-entry arena bytes written minus the same arenas priced + /// in v3, and the §5 window and length-prefix bytes as written and as they + /// would be with v3 arenas. + entry_delta: i64, + window_new: u64, + window_v3: u64, + prefix_new: u64, + prefix_v3: u64, +} + +fn arena_of(info: &ConstantMetaInfo) -> Option<&ExprMeta> { + match info { + ConstantMetaInfo::Def { arena, .. } + | ConstantMetaInfo::Axio { arena, .. } + | ConstantMetaInfo::Quot { arena, .. } + | ConstantMetaInfo::Indc { arena, .. } + | ConstantMetaInfo::Ctor { arena, .. } + | ConstantMetaInfo::Rec { arena, .. } => Some(arena), + ConstantMetaInfo::Empty | ConstantMetaInfo::Muts { .. } => None, + } +} + +/// Arena indices held outside the arena by the variant: type, value and +/// rule roots. +fn roots_of(info: &ConstantMetaInfo) -> Vec { + match info { + ConstantMetaInfo::Def { type_root, value_root, .. } => { + vec![*type_root, *value_root] + }, + ConstantMetaInfo::Axio { type_root, .. } + | ConstantMetaInfo::Quot { type_root, .. } + | ConstantMetaInfo::Indc { type_root, .. } + | ConstantMetaInfo::Ctor { type_root, .. } => vec![*type_root], + ConstantMetaInfo::Rec { type_root, rule_roots, .. } => { + let mut v = vec![*type_root]; + v.extend_from_slice(rule_roots); + v + }, + ConstantMetaInfo::Empty | ConstantMetaInfo::Muts { .. } => vec![], + } +} + +#[derive(Clone, Copy, PartialEq, Eq)] +enum Writer { + V3, + Implicit, +} + +struct Opts { + check_writer: bool, + writer: Writer, + /// Every integer of the production writer other than child references + /// is TagN (`--other-tagn`, after the Tag0 removal) or Tag0. + other_tagn: bool, +} + +impl Opts { + /// The pricing that matches the production writer. + fn pricing(&self) -> Pricing { + match self.writer { + Writer::V3 => Pricing::of(Enc::V3), + Writer::Implicit => Pricing { + names: self.other_tagn, + mdata: self.other_tagn, + scalars: self.other_tagn, + children: Enc::Implicit, + }, + } + } +} + +fn study_arena( + st: &mut Stats, + cm: &ConstantMeta, + ix: &NameIndex, + rev: &Vec
, + orig: bool, + opts: &Opts, +) { + let Some(arena) = arena_of(&cm.info) else { return }; + let nodes = &arena.nodes; + st.arenas += 1; + if orig { + st.orig_arenas += 1; + } + st.nodes += nodes.len() as u64; + let masks = implicit_masks(nodes); + for (e, enc) in ENCS.iter().enumerate() { + st.bytes[e] += code_w(*enc != Enc::V3, nodes.len() as u64) as u64; + } + let mut names: HashMap = HashMap::new(); + for (i, n) in nodes.iter().enumerate() { + let k = kind(n); + st.kind_nodes[k] += 1; + for (e, enc) in ENCS.iter().enumerate() { + let b = node_w(n, i, masks[i], ix, Pricing::of(*enc)) as u64; + st.bytes[e] += b; + st.kind_bytes[e][k] += b; + } + if opts.writer == Writer::V3 && opts.check_writer { + // The v3 node writer is position-free: check every node alone. + let predicted = node_w(n, i, 0, ix, Pricing::of(Enc::V3)); + let one = ExprMeta { nodes: vec![n.clone()] }; + let mut buf = Vec::new(); + one.put_with(NamePut::Indexed(ix), &mut buf).expect("put"); + // The one-node arena has a 1-byte length prefix. + if buf.len() - 1 != predicted { + st.v3_node_mismatch += 1; + } + } + for (s, (slot, c)) in slots(n).iter().enumerate() { + st.slot_children[*slot] += 1; + if *c >= i as u64 { + st.slot_forward[*slot] += 1; + } + let d = (i as u64).wrapping_sub(1).wrapping_sub(*c); + st.slot_delta_w[*slot][wbucket(d)] += 1; + if d == 0 { + st.slot_delta0[*slot] += 1; + } + if masks[i] & (1 << s) != 0 { + st.slot_fresh[*slot] += 1; + } else { + st.slot_explicit_w[*slot][wbucket(d)] += 1; + } + } + for c in callsite_refs(n) { + st.slot_children[9] += 1; + if c >= i as u64 { + st.slot_forward[9] += 1; + } + let d = (i as u64).wrapping_sub(1).wrapping_sub(c); + st.slot_delta_w[9][wbucket(d)] += 1; + st.slot_explicit_w[9][wbucket(d)] += 1; + if d == 0 { + st.slot_delta0[9] += 1; + } + } + if let Some(a) = node_name(n) { + let g = ix[a]; + st.name_refs += 1; + st.name_bytes_v3 += tag0_w(g) as u64; + st.name_bytes_tagn += tagn_w(g) as u64; + let next = names.len() as u64; + let local = *names.entry(g).or_insert(next); + st.name_local_bytes += tagn_w(local) as u64; + } + } + st.name_distinct += names.len() as u64; + st.name_local_bytes += tagn_w(names.len() as u64) as u64 + + names.keys().map(|g| tagn_w(*g) as u64).sum::(); + let patched: HashSet = + cm.univ_patches.iter().map(|p| p.arena_idx).collect(); + let (hc, canon) = hash_cons(nodes, &patched); + st.hc_nodes += hc.len() as u64; + st.bytes[4] += arena_w(&hc, ix, Pricing::of(Enc::Implicit)) as u64; + st.bytes[5] += arena_w(&hc, ix, Pricing::of(Enc::Delta)) as u64; + // Redirection: roots and patch keys outside the arena take the surviving + // node's index; a reference is "redirected" when its node was merged + // into an earlier one. + // Class ids are assigned in first-occurrence order, so node i survives + // iff its id equals the number of classes seen before it. + let mut survives = Vec::with_capacity(canon.len()); + let mut seen = 0u64; + for &k in &canon { + survives.push(k == seen); + if k == seen { + seen += 1; + } + } + let merged = |c: u64| survives.get(c as usize).is_some_and(|s| !s); + let mut outside: Vec = roots_of(&cm.info); + outside.extend(cm.univ_patches.iter().map(|p| p.arena_idx)); + for r in outside { + st.roots += 1; + st.root_bytes += tagn_w(r) as u64; + let nr = canon.get(r as usize).copied().unwrap_or(r); + st.root_bytes_hc += tagn_w(nr) as u64; + if merged(r) { + st.roots_redirected += 1; + } + } + for n in nodes { + for c in callsite_refs(n) { + if merged(c) { + st.cs_refs_redirected += 1; + } + } + } + if opts.check_writer { + let predicted = arena_w(nodes, ix, opts.pricing()); + let mut buf = Vec::new(); + arena.put_with(NamePut::Indexed(ix), &mut buf).expect("arena put"); + st.writer_checked += 1; + st.writer_bytes += buf.len() as u64; + st.entry_delta += + buf.len() as i64 - arena_w(nodes, ix, Pricing::of(Enc::V3)) as i64; + if buf.len() != predicted { + st.writer_size_mismatch += 1; + } + let mut slice: &[u8] = &buf; + match ExprMeta::get_with(&mut slice, NameGet::Indexed(rev)) { + Ok(back) if back == *arena && slice.is_empty() => {}, + _ => st.writer_roundtrip_mismatch += 1, + } + } +} + +fn pct(a: u64, b: u64) -> String { + if b == 0 { + "0".into() + } else { + format!("{:.2}%", a as f64 * 100.0 / b as f64) + } +} + +fn spct(a: i64, b: u64) -> String { + if b == 0 { + "0".into() + } else { + format!("{:+.2}%", a as f64 * 100.0 / b as f64) + } +} + +fn main() -> Result<(), String> { + let mut args = std::env::args().skip(1); + let path = args.next().ok_or( + "usage: arena_study [--check-writer] [--writer v3|implicit] [--other-tagn]", + )?; + let mut opts = + Opts { check_writer: false, writer: Writer::Implicit, other_tagn: false }; + let mut census = false; + while let Some(a) = args.next() { + match a.as_str() { + "--check-writer" => opts.check_writer = true, + "--other-tagn" => opts.other_tagn = true, + "--int-census" => census = true, + "--writer" => { + opts.writer = match args.next().as_deref() { + Some("v3") => Writer::V3, + Some("implicit") => Writer::Implicit, + x => return Err(format!("bad --writer {x:?}")), + } + }, + x => return Err(format!("unknown argument {x}")), + } + } + let t0 = Instant::now(); + let file = std::fs::File::open(&path).map_err(|e| e.to_string())?; + // SAFETY: the corpus file is not modified while it is mapped. + let mmap = + Arc::new(unsafe { memmap2::Mmap::map(&file) }.map_err(|e| e.to_string())?); + if census { + println!("{}", int_census(&path, &mmap)?); + return Ok(()); + } + let index = Env::parse_lazy_index(&mmap)?; + let ix: NameIndex = index + .name_reverse_index + .iter() + .enumerate() + .map(|(i, a)| (a.clone(), i as u64)) + .collect(); + eprintln!( + "[arena_study] {path}: {} bytes, {} names, {} named entries; index in {} ms", + mmap.len(), + index.name_reverse_index.len(), + index.named.len(), + t0.elapsed().as_millis() + ); + let const_addrs: Vec
= + index.consts.iter().map(|c| c.addr.clone()).collect(); + let (mut scratch, mut entry_buf) = (Vec::new(), Vec::new()); + let mut cursor = NamedMetaCursor::open(&mmap, &index)?; + let mut st = Stats::default(); + while let Some((_, named)) = cursor.next_entry()? { + st.entries += 1; + st.entry_delta = 0; + let meta = named.meta(); + study_arena(&mut st, &meta, &ix, &index.name_reverse_index, false, &opts); + if let Some((_, o)) = named.original() { + study_arena(&mut st, &o, &ix, &index.name_reverse_index, true, &opts); + } + if opts.check_writer { + // The §5 window as the production writer emits it, and as it would + // be with the same arenas in v3 (everything else in the window is + // written by the same helpers). + entry_buf.clear(); + put_named_indexed( + &named, + &ix, + &const_addrs, + &mut scratch, + &mut entry_buf, + )?; + let new = scratch.len() as u64; + let v3 = (new as i64 - st.entry_delta) as u64; + st.window_new += new; + st.window_v3 += v3; + st.prefix_new += code_w(opts.other_tagn, new) as u64; + st.prefix_v3 += code_w(opts.other_tagn, v3) as u64; + } + if st.entries % 100_000 == 0 { + eprintln!( + "[arena_study] {} entries, {} s", + st.entries, + t0.elapsed().as_secs() + ); + } + } + let file = mmap.len() as u64; + let mut md = String::new(); + md += &format!( + "## Arena study: `{}`\n\n- File {} bytes; Named entries {}; arenas {} ({} in `original` metadata); nodes {}. Wall {} s.\n", + path, + file, + st.entries, + st.arenas, + st.orig_arenas, + st.nodes, + t0.elapsed().as_secs() + ); + if opts.check_writer { + md += &format!( + "- Writer check ({}, integers other than child references {}): {} arenas, {} bytes written; size mismatches **{}**, roundtrip mismatches **{}**.\n", + match opts.writer { + Writer::V3 => "v3", + Writer::Implicit => "implicit", + }, + if opts.other_tagn { "TagN" } else { "Tag0" }, + st.writer_checked, + st.writer_bytes, + st.writer_size_mismatch, + st.writer_roundtrip_mismatch + ); + if opts.writer == Writer::V3 { + md += &format!( + "- v3 node mirror vs production node writer: **{}** mismatches.\n", + st.v3_node_mismatch + ); + } + let new = st.window_new + st.prefix_new; + let v3 = st.window_v3 + st.prefix_v3; + md += &format!( + "- §5 metadata windows as written by the production writer: {} bytes + {} length-prefix bytes; with the same arenas in v3: {} + {}. Change: {:+} bytes ({} of the file).\n", + st.window_new, + st.prefix_new, + st.window_v3, + st.prefix_v3, + new as i64 - v3 as i64, + spct(new as i64 - v3 as i64, file) + ); + } + md += "\nArena bytes (length prefixes and nodes, primary and `original`) per encoding:\n\n| encoding | bytes | % of file | vs v3 | vs abs (v4 baseline) | change vs abs, % of file |\n|---|---:|---:|---:|---:|---:|\n"; + let enc_names = [ + "v3 (Tag0, absolute)", + "abs (TagN, absolute)", + "delta (TagN backward deltas)", + "implicit (post-order cursor + TagN deltas)", + "implicit + hash-consing (dedup first)", + "delta + hash-consing (dedup first)", + ]; + for (e, nm) in enc_names.iter().enumerate() { + let b = st.bytes[e]; + md += &format!( + "| {} | {} | {} | {} | {} | {} |\n", + nm, + b, + pct(b, file), + b as i64 - st.bytes[0] as i64, + b as i64 - st.bytes[1] as i64, + spct(b as i64 - st.bytes[1] as i64, file) + ); + } + md += &format!( + "\n- Hash-consing keeps {} of {} nodes ({}); nodes carrying a level-spelling patch are never merged.\n- Redirection outside the arena (type/value/rule roots and patch keys): {} indices, {} redirected to an earlier surviving node; TagN bytes {} before, {} after hash-consing ({:+}). Call-site references redirected inside the arena: {} (priced in the arena rows).\n", + st.hc_nodes, + st.nodes, + pct(st.hc_nodes, st.nodes), + st.roots, + st.roots_redirected, + st.root_bytes, + st.root_bytes_hc, + st.root_bytes_hc as i64 - st.root_bytes as i64, + st.cs_refs_redirected + ); + md += "\nNode bytes by kind (length prefixes excluded):\n\n| kind | nodes | v3 | abs | delta | implicit | implicit B/node |\n|---|---:|---:|---:|---:|---:|---:|\n"; + for k in 0..9 { + md += &format!( + "| {} | {} | {} | {} | {} | {} | {:.2} |\n", + KIND_NAMES[k], + st.kind_nodes[k], + st.kind_bytes[0][k], + st.kind_bytes[1][k], + st.kind_bytes[2][k], + st.kind_bytes[3][k], + if st.kind_nodes[k] == 0 { + 0.0 + } else { + st.kind_bytes[3][k] as f64 / st.kind_nodes[k] as f64 + } + ); + } + md += "\nChild references per slot. Δ = parent − child − 1 (0 = the immediately preceding node); widths are TagN (`f = 0`) widths of Δ (1 B: Δ < 128, 2 B: < 16,512, 3 B: < 82,048, 5 B, 9 B). \"fresh\" = implicit under the post-order cursor (0 bytes); the explicit widths are for the other references.\n\n| slot | children | not backward | Δ = 0 | Δ 1 B | 2 B | 3 B | 5 B | 9 B | fresh | fresh % | explicit 1 B | 2 B | 3 B | 5 B | 9 B |\n|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|\n"; + let mut tot = [0u64; 14]; + for s in 0..10 { + let dw = st.slot_delta_w[s]; + let ew = st.slot_explicit_w[s]; + let row = [ + st.slot_children[s], + st.slot_forward[s], + st.slot_delta0[s], + dw[0], + dw[1], + dw[2], + dw[3], + dw[4], + st.slot_fresh[s], + ew[0], + ew[1], + ew[2], + ew[3], + ew[4], + ]; + for j in 0..14 { + tot[j] += row[j]; + } + md += &format!( + "| {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} |\n", + SLOT_NAMES[s], + row[0], + row[1], + row[2], + row[3], + row[4], + row[5], + row[6], + row[7], + row[8], + pct(row[8], row[0]), + row[9], + row[10], + row[11], + row[12], + row[13] + ); + } + md += &format!( + "| **all** | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} |\n", + tot[0], + tot[1], + tot[2], + tot[3], + tot[4], + tot[5], + tot[6], + tot[7], + tot[8], + pct(tot[8], tot[0]), + tot[9], + tot[10], + tot[11], + tot[12], + tot[13] + ); + md += &format!( + "\nName references inside arenas (node names: binder, let, ref, prj, call-site): {} references; {} bytes as v3 `Tag0` global indices, {} as TagN global indices ({:+} bytes, {} of the file); {} distinct per arena (summed). With a per-arena local name table (count + distinct global indices + local indices, all TagN): {} bytes ({:+} vs TagN global, {} of the file).\n", + st.name_refs, + st.name_bytes_v3, + st.name_bytes_tagn, + st.name_bytes_tagn as i64 - st.name_bytes_v3 as i64, + spct(st.name_bytes_tagn as i64 - st.name_bytes_v3 as i64, file), + st.name_distinct, + st.name_local_bytes, + st.name_local_bytes as i64 - st.name_bytes_tagn as i64, + spct(st.name_local_bytes as i64 - st.name_bytes_tagn as i64, file) + ); + println!("{md}"); + Ok(()) +} + +// --------------------------------------------------------------------------- +// Integer census (`--int-census`): every f = 0 integer outside constant +// bodies, priced under Tag0, TagN and TagN with a 4-byte rung (which TagN +// now includes) +// --------------------------------------------------------------------------- + +/// TagN (`f = 0`) with the 4-byte rung: 1, 2, 3, 4, 5, 9 bytes (codes +/// `c = 0, 1, 2, 3` select 2, 3, 4, 8 following bytes), the proposal the +/// census evaluated; TagN now has the same widths. +fn tagn4_w(v: u64) -> usize { + const R3: u64 = 82_048; + const R4: u64 = R3 + (1 << 24); + const R5: u64 = R4 + (1 << 32); + if v < 128 { + 1 + } else if v < 16_512 { + 2 + } else if v < R3 { + 3 + } else if v < R4 { + 4 + } else if v < R5 { + 5 + } else { + 9 + } +} + +const CENSUS_CLASSES: [&str; 17] = [ + "§1 blob count and lengths", + "§2 constant count and lengths", + "§3 hint count, rank deltas, fused hints", + "§4 name count and component lengths", + "§5 entry count and name keys", + "§5 constant ranks", + "§5 fused hints", + "§5 metadata window lengths", + "ConstantMetaInfo name indices", + "ConstantMetaInfo counts and aux layout", + "arena roots (type/value/rule)", + "arena lengths", + "arena node name indices (incl. mdata keys, OfName)", + "arena explicit child deltas", + "arena counts and call-site scalars", + "ConstantMeta table counts and patches", + "(unused)", +]; + +#[derive(Default, Clone, Copy)] +struct CensusRow { + ints: u64, + /// Integers in [82,048, 2^24): 4 bytes in Tag0 and in TagN, 5 bytes in + /// TagN without its 4-byte rung. + in_gap: u64, + tag0: u64, + tagn: u64, + tagn4: u64, +} + +#[derive(Default)] +struct Census { + rows: [CensusRow; 17], + const_max_refs: usize, + const_max_univs: usize, + const_max_sharing: usize, + consts_decoded: u64, + windows: u64, + window_mismatch: u64, +} + +impl Census { + fn add(&mut self, class: usize, v: u64) { + let r = &mut self.rows[class]; + r.ints += 1; + if (82_048..(1 << 24)).contains(&v) { + r.in_gap += 1; + } + r.tag0 += tag0_w(v) as u64; + r.tagn += tagn_w(v) as u64; + r.tagn4 += tagn4_w(v) as u64; + } + + fn idx_vec(&mut self, ix: &NameIndex, v: &[Address]) { + self.add(9, v.len() as u64); + for a in v { + self.add(8, ix[a]); + } + } + + fn arena(&mut self, ix: &NameIndex, nodes: &[ExprMetaData]) { + self.add(11, nodes.len() as u64); + let masks = implicit_masks(nodes); + for (i, n) in nodes.iter().enumerate() { + if let Some(a) = node_name(n) { + self.add(12, ix[a]); + } + let delta = |c: u64| (i as u64).wrapping_sub(1).wrapping_sub(c); + for (s, (_, c)) in slots(n).into_iter().enumerate() { + if masks[i] & (1 << s) == 0 { + self.add(13, delta(c)); + } + } + for c in callsite_refs(n) { + self.add(13, delta(c)); + } + match n { + ExprMetaData::Mdata { mdata, .. } => { + self.add(14, mdata.len() as u64); + for kv in mdata { + self.add(14, kv.len() as u64); + for (k, d) in kv { + self.add(12, ix[k]); + if let DataValue::OfName(a) = d { + self.add(12, ix[a]); + } + } + } + }, + ExprMetaData::CallSite { entries, canon_meta, orig_head, .. } => { + self.add(14, entries.len() as u64); + for e in entries { + match e { + CallSiteEntry::Kept { canon_idx: x, .. } + | CallSiteEntry::Collapsed { sharing_idx: x, .. } => { + self.add(14, *x); + }, + } + } + self.add(14, canon_meta.len() as u64); + if let Some((s, _)) = orig_head { + self.add(14, *s); + } + }, + ExprMetaData::EtaCallSite { n_synth, entries, canon_meta, .. } => { + self.add(14, *n_synth); + self.add(14, entries.len() as u64); + for e in entries { + match e { + CallSiteEntry::Kept { canon_idx: x, .. } + | CallSiteEntry::Collapsed { sharing_idx: x, .. } => { + self.add(14, *x); + }, + } + } + self.add(14, canon_meta.len() as u64); + }, + _ => {}, + } + } + } + + fn meta(&mut self, ix: &NameIndex, cm: &ConstantMeta) { + match &cm.info { + ConstantMetaInfo::Empty => {}, + ConstantMetaInfo::Def { name, lvls, all, ctx, arena, .. } => { + self.add(8, ix[name]); + self.idx_vec(ix, lvls); + self.idx_vec(ix, all); + self.idx_vec(ix, ctx); + self.arena(ix, &arena.nodes); + }, + ConstantMetaInfo::Axio { name, lvls, arena, .. } + | ConstantMetaInfo::Quot { name, lvls, arena, .. } => { + self.add(8, ix[name]); + self.idx_vec(ix, lvls); + self.arena(ix, &arena.nodes); + }, + ConstantMetaInfo::Indc { name, lvls, ctors, all, ctx, arena, .. } => { + self.add(8, ix[name]); + self.idx_vec(ix, lvls); + self.idx_vec(ix, ctors); + self.idx_vec(ix, all); + self.idx_vec(ix, ctx); + self.arena(ix, &arena.nodes); + }, + ConstantMetaInfo::Ctor { name, lvls, induct, arena, .. } => { + self.add(8, ix[name]); + self.idx_vec(ix, lvls); + self.add(8, ix[induct]); + self.arena(ix, &arena.nodes); + }, + ConstantMetaInfo::Rec { + name, + lvls, + rules, + all, + ctx, + arena, + rule_roots, + .. + } => { + self.add(8, ix[name]); + self.idx_vec(ix, lvls); + self.idx_vec(ix, rules); + self.idx_vec(ix, all); + self.idx_vec(ix, ctx); + self.arena(ix, &arena.nodes); + self.add(9, rule_roots.len() as u64); + }, + ConstantMetaInfo::Muts { all, aux_layout } => { + self.add(9, all.len() as u64); + for cls in all { + self.idx_vec(ix, cls); + } + if let Some(l) = aux_layout { + self.add(9, l.perm.len() as u64); + for &p in &l.perm { + self.add(9, p as u64); + } + self.add(9, l.source_ctor_counts.len() as u64); + for &c in &l.source_ctor_counts { + self.add(9, c as u64); + } + self.add(9, l.evaporated.len() as u64); + } + }, + } + for r in roots_of(&cm.info) { + self.add(10, r); + } + self.add(15, cm.meta_sharing.len() as u64); + self.add(15, cm.meta_refs.len() as u64); + self.add(15, cm.meta_univs.len() as u64); + self.add(15, cm.univ_patches.len() as u64); + for p in &cm.univ_patches { + self.add(15, p.arena_idx); + self.add(15, p.univ_idxs.len() as u64); + for &u in &p.univ_idxs { + self.add(15, u); + } + } + } +} + +fn fused_opt_hint(h: Option) -> u64 { + match h { + None => 0, + Some(ReducibilityHints::Opaque) => 1, + Some(ReducibilityHints::Abbrev) => 2, + Some(ReducibilityHints::Regular(x)) => u64::from(x) + 3, + } +} + +fn fused_hint(h: &ReducibilityHints) -> u64 { + fused_opt_hint(Some(*h)) - 1 +} + +/// Run the census over a parsed file and render it. +fn int_census(path: &str, mmap: &[u8]) -> Result { + let (index, names) = Env::parse_lazy_index_with_names(mmap)?; + let ix: NameIndex = index + .name_reverse_index + .iter() + .enumerate() + .map(|(i, a)| (a.clone(), i as u64)) + .collect(); + let const_addrs: Vec
= + index.consts.iter().map(|c| c.addr.clone()).collect(); + let mut c = Census::default(); + // §1-§4. + c.add(0, index.blobs.len() as u64); + for (_, b) in &index.blobs { + c.add(0, b.len() as u64); + } + c.add(1, index.consts.len() as u64); + for s in &index.consts { + c.add(1, s.len as u64); + if let Ok(k) = Constant::get(&mut &mmap[s.offset..s.offset + s.len]) { + c.consts_decoded += 1; + c.const_max_refs = c.const_max_refs.max(k.refs.len()); + c.const_max_univs = c.const_max_univs.max(k.univs.len()); + c.const_max_sharing = c.const_max_sharing.max(k.sharing.len()); + } + } + c.add(2, index.hints.len() as u64); + let mut ranked: Vec<(u64, u64)> = index + .hints + .iter() + .map(|(a, h)| { + ( + const_addrs.binary_search(a).map_or(u64::MAX, |r| r as u64), + fused_hint(h), + ) + }) + .collect(); + ranked.sort_unstable(); + let mut prev = 0u64; + for (rank, h) in ranked { + c.add(2, rank + 1 - prev); + c.add(2, h); + prev = rank + 1; + } + c.add(3, index.name_reverse_index.len() as u64); + for a in &index.name_reverse_index { + if let Some(n) = names.get(a) { + match n.as_data() { + ix_common::env::NameData::Str(_, s, _) => c.add(3, s.len() as u64), + ix_common::env::NameData::Num(_, n, _) => { + c.add(3, n.to_le_bytes().len() as u64); + }, + ix_common::env::NameData::Anonymous(_) => {}, + } + } + } + // §5. + c.add(4, index.named.len() as u64); + let (mut scratch, mut entry_buf) = (Vec::new(), Vec::new()); + let mut cursor = NamedMetaCursor::open(mmap, &index)?; + while let Some((name_addr, named)) = cursor.next_entry()? { + c.add(4, ix[&name_addr]); + c.add( + 5, + const_addrs.binary_search(&named.addr).map_or(u64::MAX, |r| r as u64), + ); + c.add(6, fused_opt_hint(named.hints())); + entry_buf.clear(); + put_named_indexed(&named, &ix, &const_addrs, &mut scratch, &mut entry_buf)?; + c.add(7, scratch.len() as u64); + // Self-check: the window is exactly the census integers (TagN) plus + // the non-integer bytes. + let before: u64 = c.rows[8..16].iter().map(|r| r.tagn).sum(); + let meta = named.meta(); + c.meta(&ix, &meta); + let mut nonint = meta_nonint_bytes(&meta) + 1; + if let Some((_, o)) = named.original() { + c.meta(&ix, &o); + nonint += 32 + meta_nonint_bytes(&o); + } + let after: u64 = c.rows[8..16].iter().map(|r| r.tagn).sum(); + c.windows += 1; + if after - before + nonint != scratch.len() as u64 { + c.window_mismatch += 1; + } + } + let file = mmap.len() as u64; + let mut md = format!( + "## Integer census (f = 0, outside constant bodies): `{path}`\n\n- File {file} bytes; {} names; {} constants ({} decoded: max refs table {}, max univs table {}, max sharing table {}).\n- Self-check: {} of {} §5 windows equal TagN-priced census integers plus non-integer bytes ({} mismatches).\n- Widths: Tag0 (v3); TagN (1, 2, 3, 4, 5, 9 bytes; 4 bytes for [82,048, 16,859,264)); TagN with a 4-byte rung, the proposal this census evaluated, which TagN now includes (so its column equals TagN and \"rung saves\" is 0). \"In [82,048, 2^24)\" are the integers on which TagN without that rung wrote one byte more than Tag0.\n\n| field class | integers | in [82,048, 2^24) | Tag0 bytes | TagN bytes | TagN − Tag0 | TagN with 4-byte rung | rung saves |\n|---|---:|---:|---:|---:|---:|---:|---:|\n", + index.name_reverse_index.len(), + index.consts.len(), + c.consts_decoded, + c.const_max_refs, + c.const_max_univs, + c.const_max_sharing, + c.windows - c.window_mismatch, + c.windows, + c.window_mismatch + ); + let mut t = CensusRow::default(); + for (k, r) in c.rows.iter().enumerate().take(16) { + t.ints += r.ints; + t.in_gap += r.in_gap; + t.tag0 += r.tag0; + t.tagn += r.tagn; + t.tagn4 += r.tagn4; + md += &format!( + "| {} | {} | {} | {} | {} | {:+} | {} | {} |\n", + CENSUS_CLASSES[k], + r.ints, + r.in_gap, + r.tag0, + r.tagn, + r.tagn as i64 - r.tag0 as i64, + r.tagn4, + r.tagn - r.tagn4 + ); + } + md += &format!( + "| **all** | {} | {} | {} | {} | {:+} ({}) | {} | {} ({}) |\n", + t.ints, + t.in_gap, + t.tag0, + t.tagn, + t.tagn as i64 - t.tag0 as i64, + spct(t.tagn as i64 - t.tag0 as i64, file), + t.tagn4, + t.tagn - t.tagn4, + pct(t.tagn - t.tagn4, file) + ); + Ok(md) +} + +/// Non-integer bytes of a `ConstantMeta` (tags, raw addresses, booleans, +/// expression and universe payloads): with the census integers priced in +/// TagN this must add up to the production writer's bytes. +fn meta_nonint_bytes(cm: &ConstantMeta) -> u64 { + let arena = |nodes: &[ExprMetaData]| -> u64 { + let mut b = nodes.len() as u64; + for n in nodes { + match n { + ExprMetaData::Mdata { mdata, .. } => { + for kv in mdata { + for (_, d) in kv { + b += 1 + + match d { + DataValue::OfBool(_) => 1, + DataValue::OfName(_) => 0, + _ => 32, + }; + } + } + }, + ExprMetaData::CallSite { entries, .. } => { + b += entries.len() as u64 + 1; + }, + ExprMetaData::EtaCallSite { entries, .. } => { + b += entries.len() as u64; + }, + _ => {}, + } + } + b + }; + let mut b = 1 + arena_of(&cm.info).map_or(0, |a| arena(&a.nodes)); + if let ConstantMetaInfo::Muts { aux_layout, .. } = &cm.info { + b += 1 + aux_layout.as_ref().map_or(0, |l| l.evaporated.len() as u64); + } + for e in &cm.meta_sharing { + let mut buf = Vec::new(); + put_expr(e, &mut buf); + b += buf.len() as u64; + } + b += 32 * cm.meta_refs.len() as u64; + for u in &cm.meta_univs { + let mut buf = Vec::new(); + put_univ(u, &mut buf); + b += buf.len() as u64; + } + b +} diff --git a/crates/ixon/examples/sharing_corpus.rs b/crates/ixon/examples/sharing_corpus.rs new file mode 100644 index 000000000..94e1e0dd6 --- /dev/null +++ b/crates/ixon/examples/sharing_corpus.rs @@ -0,0 +1,663 @@ +//! Corpus runner for the canonical sharing construction. +//! +//! Runs the tiered canonical construction (`sharing_exact`, TagN layout) on +//! every constant of an `.ixe` file (or a deterministic subset), in parallel, +//! and prints a report: certified count, failures with names and candidate +//! counts, serialized and TagN-priced byte totals against the stored and +//! unshared encodings, the per-constant delta distribution, phase +//! statistics, the slowest constants, wall time and peak RSS. The +//! `--select-out` address lists feed the Lean/Rust corpus differential +//! (`IX_SHARING_CORPUS_SELECT` of the `exact-sharing-ffi` suite). +//! +//! ```text +//! cargo run --release -p ixon --example sharing_corpus -- +//! [--threads N] worker threads (default: all cores) +//! [--limit N] only the first N constants (address order) +//! [--csv PATH] per-constant CSV (with the blake3 of the +//! output and, per phase-1 width, the final +//! bytes, model bytes, states and work) +//! [--select-out PATH] write a selection: every --select-stride-th +//! constant plus those with more than +//! --select-min-cand R1/R2 candidates +//! [--select-stride N] (default 50) +//! [--select-min-cand N] (default 2000) +//! [--only HEX] only constants whose address starts with HEX +//! (repeatable) +//! [--par-widths N] [--par-components N] [--par-materialize N] +//! thread budgets inside one constant +//! [--serial-constants] one constant at a time (per-constant latency) +//! [--check-sequential] also run the sequential reference (under the +//! same limits) and compare +//! [--max-states N] override the max_states limit +//! [--sharing-limits SPEC] override limits (`ExactSharingLimits:: +//! with_overrides`, the grammar of `ix compile +//! --sharing-limits`), after --max-states +//! [--full-check] the checked mode (`ExactSharingLimits:: +//! full_check`): build and check every candidate +//! and cross-check every shortcut; the output +//! and every column but `ms` are those of the +//! default mode, and a discrepancy is a failure +//! with an `internal error` status +//! ``` +//! +//! Candidate counts are reported two ways: `cand`, the R1/R2 search +//! candidates (`candidate_terms`: at least two expanded occurrences and an +//! unshared encoding longer than one byte), and `k`, the tiered count +//! (compact in-degree >= 2 and unshared length >= 2). + +#![allow(clippy::cast_precision_loss)] +#![allow(clippy::cast_possible_truncation)] + +use std::collections::BTreeMap; +use std::io::Write; +use std::sync::Arc; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::time::Instant; + +use ix_common::address::Address; +use ixon::Env; +use ixon::constant::{Constant, ConstantInfo}; +use ixon::sharing_exact::{ + ExactSharingLimits, Parallelism, ShareLayout, SharingDag, SharingError, + TieredSharingResult, candidate_terms, constant_fixed_len, constant_len, + layout_bytes, normalize_constant_sharing_tiered, + normalize_constant_sharing_tiered_par, +}; +use rayon::prelude::*; + +// The allocator of the `ix` binary (`crates/ffi`), so per-constant times +// match the compiler's. +#[global_allocator] +static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc; + +/// The Share layout of the construction: TagN, the wire Share code. +const LAYOUT: ShareLayout = ShareLayout::TagN; + +struct Args { + path: String, + threads: Option, + limit: Option, + csv: Option, + select_out: Option, + select_stride: usize, + select_min_cand: usize, + parallel: Parallelism, + check_sequential: bool, + only: Vec, + serial_constants: bool, + max_states: Option, + sharing_limits: Option, + full_check: bool, +} + +fn parse_args() -> Result { + let mut it = std::env::args().skip(1); + let mut a = Args { + path: String::new(), + threads: None, + limit: None, + csv: None, + select_out: None, + select_stride: 50, + select_min_cand: 2000, + parallel: Parallelism::SEQUENTIAL, + check_sequential: false, + only: Vec::new(), + serial_constants: false, + max_states: None, + sharing_limits: None, + full_check: false, + }; + let num = |v: Option| -> Result { + v.ok_or("missing value")?.parse::().map_err(|e| e.to_string()) + }; + while let Some(arg) = it.next() { + match arg.as_str() { + "--threads" => a.threads = Some(num(it.next())?), + "--limit" => a.limit = Some(num(it.next())?), + "--csv" => a.csv = it.next(), + "--select-out" => a.select_out = it.next(), + "--select-stride" => a.select_stride = num(it.next())?, + "--select-min-cand" => a.select_min_cand = num(it.next())?, + "--par-widths" => a.parallel.widths = num(it.next())?, + "--par-components" => a.parallel.components = num(it.next())?, + "--par-materialize" => a.parallel.materialize = num(it.next())?, + "--check-sequential" => a.check_sequential = true, + "--only" => a.only.push(it.next().ok_or("missing value")?), + "--serial-constants" => a.serial_constants = true, + "--max-states" => a.max_states = Some(num(it.next())? as u64), + "--sharing-limits" => { + a.sharing_limits = Some(it.next().ok_or("missing value")?); + }, + "--full-check" => a.full_check = true, + p if !p.starts_with("--") && a.path.is_empty() => a.path = p.to_string(), + other => return Err(format!("unknown argument {other}")), + } + } + if a.path.is_empty() { + return Err("usage: sharing_corpus [options]".into()); + } + Ok(a) +} + +/// One processed constant. +#[derive(Default, Clone)] +struct Row { + idx: usize, + addr: String, + status: String, + kind: &'static str, + raw: u64, + n: u64, + cand: u64, + k: u64, + /// Serialized bytes of the output (the wire Share code). + real: u64, + /// The same output priced by the TagN layout (`layout_bytes`); the + /// construction checks that it equals `real`. + tagn: u64, + unshared: Option, + w: u64, + uncertain: u64, + max_comp: u64, + comps: u64, + slot_states: u64, + /// `--check-sequential`: how the sequential reference compares. + seq_check: &'static str, + uniform_states: u64, + /// blake3 of the serialized output Constant (empty on failure). + out_hash: String, + /// Per phase-1 width 1, 2, 3: `(final layout bytes, phase-1 model bytes, + /// states_created, work)` of that candidate's run. + per_width: Vec<(u64, u64, u64, u64)>, + /// Candidates whose phase 3 ran per prefix. + per_prefix: u64, + ms: f64, +} + +fn kind_of(c: &Constant) -> &'static str { + match &c.info { + ConstantInfo::Defn(_) => "defn", + ConstantInfo::Recr(_) => "recr", + ConstantInfo::Axio(_) => "axio", + ConstantInfo::Quot(_) => "quot", + ConstantInfo::CPrj(_) => "cprj", + ConstantInfo::RPrj(_) => "rprj", + ConstantInfo::IPrj(_) => "iprj", + ConstantInfo::DPrj(_) => "dprj", + ConstantInfo::Muts(_) => "muts", + } +} + +fn projection_block(c: &Constant) -> Option
{ + match &c.info { + ConstantInfo::CPrj(p) => Some(p.block.clone()), + ConstantInfo::RPrj(p) => Some(p.block.clone()), + ConstantInfo::IPrj(p) => Some(p.block.clone()), + ConstantInfo::DPrj(p) => Some(p.block.clone()), + _ => None, + } +} + +fn process( + idx: usize, + addr: &Address, + mut bytes: &[u8], + limits: &ExactSharingLimits, + par: Parallelism, + check_sequential: bool, +) -> Row { + let mut row = + Row { idx, addr: addr.hex(), raw: bytes.len() as u64, ..Row::default() }; + let c = match Constant::get(&mut bytes) { + Ok(c) => c, + Err(e) => { + row.status = format!("decode: {e}"); + return row; + }, + }; + row.kind = kind_of(&c); + if let Ok(dag) = + SharingDag::from_constant(&c, &ExactSharingLimits::unbounded()) + { + row.n = dag.len() as u64; + row.cand = candidate_terms(&dag).len() as u64; + } + let start = Instant::now(); + let r = normalize_constant_sharing_tiered_par(LAYOUT, &c, limits, par); + row.ms = start.elapsed().as_secs_f64() * 1e3; + if check_sequential { + // The sequential reference under the same limits: a difference is a + // difference of the parallel path, not of the limits. + let s = normalize_constant_sharing_tiered(LAYOUT, &c, limits); + row.seq_check = compare_sequential(&r, &s); + } + match r { + Ok((out, res)) => { + row.status = "ok".into(); + let real = constant_len(&out).unwrap_or(u64::MAX); + let fixed = constant_fixed_len(&c).unwrap_or(0); + row.real = real; + row.tagn = fixed + + layout_bytes(LAYOUT, &res.sharing, &res.roots) + .unwrap_or(u64::MAX - fixed); + row.unshared = res.unshared_len.map(|u| fixed + u); + row.k = res.stats.candidate_count; + row.w = res.stats.w; + row.uncertain = res.phase1.uncertain.len() as u64; + row.comps = res.phase1.components.len() as u64; + row.max_comp = + res.phase1.components.iter().map(Vec::len).max().unwrap_or(0) as u64; + row.slot_states = res.stats.slot_states; + row.uniform_states = res.phase1.states_visited; + let mut bytes = Vec::new(); + out.put(&mut bytes); + row.out_hash = blake3::hash(&bytes).to_hex().to_string(); + row.per_prefix = res.stats.per_prefix_candidates; + row.per_width = res + .stats + .candidate_lengths + .iter() + .zip(&res.stats.candidate_meters) + .map(|(&(_, len), &(_, model, states, work))| { + (len, model, states, work) + }) + .collect(); + }, + Err(SharingError::ResourceExhausted(e)) => { + row.status = format!("resource:{:?}", e.resource); + }, + Err(e) => row.status = format!("error: {e}"), + } + row +} + +type Normalized = Result<(Constant, TieredSharingResult), SharingError>; + +/// How a run compares with the sequential reference (`--check-sequential`). +fn compare_sequential(p: &Normalized, s: &Normalized) -> &'static str { + match (p, s) { + (Ok((pc, pr)), Ok((sc, sr))) => { + let (mut a, mut b) = (Vec::new(), Vec::new()); + pc.put(&mut a); + sc.put(&mut b); + if a != b { + "bytes differ" + } else if pr != sr { + "result differs" + } else { + "same" + } + }, + (Err(e), Err(f)) if e == f => "same error", + ( + Err(SharingError::ResourceExhausted(_)), + Err(SharingError::ResourceExhausted(_)), + ) => "both exhausted, other resource", + (Err(_), Err(_)) => "errors differ", + _ => "outcome differs", + } +} + +fn signed(x: u64) -> i64 { + i64::try_from(x).unwrap_or(i64::MAX) +} + +fn peak_rss_kib() -> Option { + let s = std::fs::read_to_string("/proc/self/status").ok()?; + let line = s.lines().find(|l| l.starts_with("VmHWM:"))?; + line.split_whitespace().nth(1)?.parse().ok() +} + +fn percentiles(mut xs: Vec) -> String { + if xs.is_empty() { + return "n/a".into(); + } + xs.sort_unstable(); + // Nearest-rank percentile, rounding the rank down. + let at = |num: usize, den: usize| xs[(xs.len() - 1) * num / den]; + format!( + "min {} p1 {} p10 {} p50 {} p90 {} p99 {} p99.9 {} max {}", + xs[0], + at(1, 100), + at(10, 100), + at(50, 100), + at(90, 100), + at(99, 100), + at(999, 1000), + xs[xs.len() - 1] + ) +} + +fn main() -> Result<(), String> { + let args = parse_args()?; + if let Some(t) = args.threads { + rayon::ThreadPoolBuilder::new() + .num_threads(t) + .build_global() + .map_err(|e| e.to_string())?; + } + let t0 = Instant::now(); + let file = std::fs::File::open(&args.path).map_err(|e| e.to_string())?; + // SAFETY: the corpus file is not modified while it is mapped. + let mmap = + Arc::new(unsafe { memmap2::Mmap::map(&file) }.map_err(|e| e.to_string())?); + let index = Env::parse_lazy_index(&mmap)?; + let load_ms = t0.elapsed().as_millis(); + let mut consts = index.consts.clone(); + if let Some(n) = args.limit { + consts.truncate(n); + } + if !args.only.is_empty() { + consts.retain(|c| { + let h = c.addr.hex(); + args.only.iter().any(|p| h.starts_with(p.as_str())) + }); + } + eprintln!( + "[sharing_corpus] {}: {} constants, {} names, index parsed in {load_ms} ms; processing {} under {:?}", + args.path, + index.consts.len(), + index.named.len(), + consts.len(), + LAYOUT + ); + // Names: the least name of each address; anonymous mutual blocks get the + // least name of a projection into them. + let window: BTreeMap<&Address, (usize, usize)> = + index.consts.iter().map(|c| (&c.addr, (c.offset, c.len))).collect(); + let mut names: BTreeMap = BTreeMap::new(); + for n in &index.named { + let s = n.name.pretty(); + let e = names.entry(n.addr.clone()).or_insert_with(|| s.clone()); + if s < *e { + *e = s; + } + } + let mut block_names: BTreeMap = BTreeMap::new(); + for (addr, name) in &names { + if let Some(&(off, len)) = window.get(addr) + && let Ok(c) = Constant::get(&mut &mmap[off..off + len]) + && let Some(b) = projection_block(&c) + { + let e = block_names.entry(b).or_insert_with(|| format!("{name} [block]")); + let cand = format!("{name} [block]"); + if cand < *e { + *e = cand; + } + } + } + let name_of = |hex: &str, addr: &Address| -> String { + names + .get(addr) + .or_else(|| block_names.get(addr)) + .cloned() + .unwrap_or_else(|| format!("<{}>", &hex[..16])) + }; + let mut limits = ExactSharingLimits::default(); + if let Some(m) = args.max_states { + limits.max_states = m; + } + if let Some(spec) = &args.sharing_limits { + limits = limits.with_overrides(spec)?; + } + limits.full_check = args.full_check; + let done = AtomicUsize::new(0); + let t1 = Instant::now(); + let total = consts.len(); + let one = |(i, c): (usize, &ixon::env::LazyConstSlice)| { + let row = process( + i, + &c.addr, + &mmap[c.offset..c.offset + c.len], + &limits, + args.parallel, + args.check_sequential, + ); + let d = done.fetch_add(1, Ordering::Relaxed) + 1; + if d.is_multiple_of(50_000) { + eprintln!( + "[sharing_corpus] {d}/{total} in {:.1} s", + t1.elapsed().as_secs_f64() + ); + } + row + }; + // `--serial-constants`: one constant at a time, so the pool serves only the + // parallelism inside a constant (per-constant latency). + let rows: Vec = if args.serial_constants { + consts.iter().enumerate().map(one).collect() + } else { + consts.par_iter().enumerate().map(one).collect() + }; + let run_s = t1.elapsed().as_secs_f64(); + // CSV. + if let Some(path) = &args.csv { + let mut f = std::io::BufWriter::new( + std::fs::File::create(path).map_err(|e| e.to_string())?, + ); + writeln!(f, "idx,addr,name,kind,status,raw,real,tagn,unshared,n,cand,k,w,uncertain,comps,max_comp,slot_states,uniform_states,out_hash,len1,len2,len3,model1,model2,model3,states1,states2,states3,work1,work2,work3,ms").map_err(|e| e.to_string())?; + for (r, c) in rows.iter().zip(&consts) { + let col = |k: usize, f: fn(&(u64, u64, u64, u64)) -> u64| { + r.per_width.get(k).map_or(String::new(), |x| f(x).to_string()) + }; + let cols = |f: fn(&(u64, u64, u64, u64)) -> u64| { + format!("{},{},{}", col(0, f), col(1, f), col(2, f)) + }; + writeln!( + f, + "{},{},\"{}\",{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{:.3}", + r.idx, + r.addr, + name_of(&r.addr, &c.addr).replace('"', "'"), + r.kind, + r.status, + r.raw, + r.real, + r.tagn, + r.unshared.map_or(String::new(), |u| u.to_string()), + r.n, + r.cand, + r.k, + r.w, + r.uncertain, + r.comps, + r.max_comp, + r.slot_states, + r.uniform_states, + r.out_hash, + cols(|x| x.0), + cols(|x| x.1), + cols(|x| x.2), + cols(|x| x.3), + r.ms + ) + .map_err(|e| e.to_string())?; + } + } + // Selection for the Lean differential. + if let Some(path) = &args.select_out { + let mut f = std::io::BufWriter::new( + std::fs::File::create(path).map_err(|e| e.to_string())?, + ); + let mut count = 0; + for r in &rows { + if r.idx % args.select_stride == 0 || r.cand > args.select_min_cand as u64 + { + writeln!(f, "{}", r.addr).map_err(|e| e.to_string())?; + count += 1; + } + } + eprintln!("[sharing_corpus] wrote {count} selected addresses to {path}"); + } + // Report. + let ok: Vec<&Row> = rows.iter().filter(|r| r.status == "ok").collect(); + let failed: Vec<(&Row, &Address)> = rows + .iter() + .zip(&consts) + .filter(|(r, _)| r.status != "ok") + .map(|(r, c)| (r, &c.addr)) + .collect(); + let sum = |f: &dyn Fn(&Row) -> u64| ok.iter().map(|r| f(r)).sum::(); + println!("# sharing_corpus report"); + println!( + "- corpus: {} ({} constants; {} processed); layout {:?}{}", + args.path, + index.consts.len(), + rows.len(), + LAYOUT, + if args.full_check { "; checked mode (--full-check)" } else { "" } + ); + if args.max_states.is_some() || args.sharing_limits.is_some() { + println!("- limits: {limits:?}"); + } + println!( + "- wall: index {load_ms} ms, processing {run_s:.1} s with {} threads; peak RSS {} KiB", + rayon::current_num_threads(), + peak_rss_kib().map_or("?".into(), |k| k.to_string()) + ); + println!( + "- certified: {} / {}; failed: {}", + ok.len(), + rows.len(), + failed.len() + ); + let mut by_status: BTreeMap<&str, usize> = BTreeMap::new(); + for (r, _) in &failed { + *by_status.entry(r.status.as_str()).or_default() += 1; + } + println!("- failures by status: {by_status:?}"); + if args.check_sequential { + let mut by_check: BTreeMap<&str, usize> = BTreeMap::new(); + for r in &rows { + *by_check.entry(r.seq_check).or_default() += 1; + } + println!( + "- sequential check (parallel {:?} vs the sequential reference): {by_check:?}", + args.parallel + ); + for (r, a) in rows.iter().zip(&consts) { + if r.seq_check != "same" && r.seq_check != "same error" { + println!( + " - {}: {} ({})", + r.seq_check, + name_of(&r.addr, &a.addr), + &r.addr[..16] + ); + } + } + } + for (r, a) in &failed { + println!( + " - FAILED {} ({}): {}; N {}, cand {}, raw {} B, {:.0} ms", + name_of(&r.addr, a), + &r.addr[..16], + r.status, + r.n, + r.cand, + r.raw, + r.ms + ); + } + let raw = sum(&|r| r.raw); + let real = sum(&|r| r.real); + let tagn = sum(&|r| r.tagn); + let un_known: Vec<&&Row> = + ok.iter().filter(|r| r.unshared.is_some()).collect(); + let unshared: u64 = un_known.iter().map(|r| r.unshared.unwrap_or(0)).sum(); + let raw_known: u64 = un_known.iter().map(|r| r.raw).sum(); + let real_known: u64 = un_known.iter().map(|r| r.real).sum(); + println!( + "- certified constants: stored {raw} B; serialized output {real} B ({:+.2}%); under TagN {tagn} B ({:+.2}%)", + (real as f64 - raw as f64) / raw as f64 * 100.0, + (tagn as f64 - raw as f64) / raw as f64 * 100.0 + ); + println!( + "- unshared (where it fits u64, {} constants): {unshared} B; stored {raw_known} B; serialized output {real_known} B", + un_known.len() + ); + let deltas: Vec = + ok.iter().map(|r| signed(r.real) - signed(r.raw)).collect(); + let (neg, zero, pos) = ( + deltas.iter().filter(|d| **d < 0).count(), + deltas.iter().filter(|d| **d == 0).count(), + deltas.iter().filter(|d| **d > 0).count(), + ); + println!( + "- serialized output - stored per constant: {neg} smaller, {zero} equal, {pos} larger; {}", + percentiles(deltas) + ); + let tdeltas: Vec = + ok.iter().map(|r| signed(r.tagn) - signed(r.raw)).collect(); + println!("- TagN price - stored per constant: {}", percentiles(tdeltas)); + println!( + "- candidates with a per-prefix phase 3 (order not closed under stored \ + descendants): {}; largest work charged to one candidate: {}", + ok.iter().map(|r| r.per_prefix).sum::(), + ok.iter().flat_map(|r| r.per_width.iter().map(|x| x.3)).max().unwrap_or(0) + ); + println!( + "- phase-1 width w: {:?}", + ok.iter().fold(BTreeMap::::new(), |mut m, r| { + *m.entry(r.w).or_default() += 1; + m + }) + ); + println!( + "- uncertain terms per constant: {}", + percentiles(ok.iter().map(|r| signed(r.uncertain)).collect()) + ); + println!( + "- largest component per constant: {}", + percentiles(ok.iter().map(|r| signed(r.max_comp)).collect()) + ); + println!( + "- uniform search states per constant: {}", + percentiles(ok.iter().map(|r| signed(r.uniform_states)).collect()) + ); + println!( + "- first-tier search states per constant: {}", + percentiles(ok.iter().map(|r| signed(r.slot_states)).collect()) + ); + println!( + "- R1/R2 candidates per constant (all): {}", + percentiles(rows.iter().map(|r| signed(r.cand)).collect()) + ); + println!( + "- milliseconds per constant (certified): {}", + percentiles(ok.iter().map(|r| r.ms.round() as i64).collect()) + ); + let mut slow: Vec<(&Row, &Address)> = + rows.iter().zip(&consts).map(|(r, c)| (r, &c.addr)).collect(); + slow.sort_by(|a, b| b.0.ms.total_cmp(&a.0.ms)); + println!("- slowest 10:"); + for (r, a) in slow.iter().take(10) { + println!( + " - {:.0} ms {} ({}): {} {}, N {}, cand {}, k {}, w {}, uncertain {}, components {} (largest {}), states uniform {} first-tier {}", + r.ms, + name_of(&r.addr, a), + &r.addr[..16], + r.kind, + r.status, + r.n, + r.cand, + r.k, + r.w, + r.uncertain, + r.comps, + r.max_comp, + r.uniform_states, + r.slot_states + ); + } + // Phase timers (only with the `sharing-profile` feature of ixon). + let profile = ixon::sharing_exact::profile_report(); + if !profile.is_empty() { + println!("- phase timers (summed over threads):"); + for (name, ns, calls) in profile { + println!(" - {name}: {:.3} s in {calls} scopes", ns as f64 / 1e9); + } + } + println!("- total wall {:.1} s", t0.elapsed().as_secs_f64()); + Ok(()) +} diff --git a/crates/ixon/src/assumption_tree.rs b/crates/ixon/src/assumption_tree.rs index 05500c2f4..314c2732e 100644 --- a/crates/ixon/src/assumption_tree.rs +++ b/crates/ixon/src/assumption_tree.rs @@ -18,10 +18,10 @@ //! //! ## Serialization //! -//! Tag4 size 2 under flag 0xE: +//! TagN size 2 under flag 0xE: //! //! ```text -//! [Tag4(0xE, 2) = 0xE2] [body] +//! [TagN(0xE, 2) = 0xE2] [body] //! //! body recursive: //! Leaf(addr): [0x00] [addr:32] @@ -40,7 +40,7 @@ use ix_common::address::Address; use super::merkle::{MerklePath, leaf_hash, node_hash, zero_address}; use super::proof::{FLAG_CLAIM, VARIANT_ASSUMPTION_TREE}; -use super::tag::Tag4; +use super::tag::TagN; // Body-tag bytes (within the AssumptionTree-flagged payload). const BODY_LEAF: u8 = 0x00; @@ -178,9 +178,9 @@ impl AssumptionTree { // ---- Serialization ---- - /// Serialize with Tag4(0xE, 2) outer header + recursive body. + /// Serialize with TagN(0xE, 2) outer header + recursive body. pub fn put(&self, buf: &mut Vec) { - Tag4::new(FLAG_CLAIM, VARIANT_ASSUMPTION_TREE).put(buf); + TagN::put(4, FLAG_CLAIM, VARIANT_ASSUMPTION_TREE, buf); self.put_body(buf); } @@ -201,13 +201,13 @@ impl AssumptionTree { } } - /// Deserialize: expects Tag4(0xE, 2) outer header. + /// Deserialize: expects TagN(0xE, 2) outer header. pub fn get(buf: &mut &[u8]) -> Result { - let tag = Tag4::get(buf)?; - if tag.flag != FLAG_CLAIM || tag.size != VARIANT_ASSUMPTION_TREE { + let tag = TagN::get(4, buf)?; + if tag.flag != FLAG_CLAIM || tag.value != VARIANT_ASSUMPTION_TREE { return Err(format!( - "AssumptionTree::get: expected Tag4{{0xE, 2}}, got Tag4{{{}, {}}}", - tag.flag, tag.size, + "AssumptionTree::get: expected header {{0xE, 2}}, got {{{}, {}}}", + tag.flag, tag.value, )); } Self::get_body(buf) @@ -490,7 +490,7 @@ mod tests { #[test] fn serde_rejects_wrong_tag() { - // Tag4(0xE, 3) = Eval claim, not AssumptionTree. + // TagN(0xE, 3) = Eval claim, not AssumptionTree. let bytes = [0xE3, 0x00, 0x00]; assert!(AssumptionTree::get(&mut &bytes[..]).is_err()); } diff --git a/crates/ixon/src/catalog.rs b/crates/ixon/src/catalog.rs index befec4f15..3473c7e25 100644 --- a/crates/ixon/src/catalog.rs +++ b/crates/ixon/src/catalog.rs @@ -34,7 +34,7 @@ //! //! Wire format: Convention B (own magic + explicit version, the //! `.ixes`/`.ixprof` precedent). Fixed-width little-endian integers — -//! deliberately unlike `.ixe`'s Tag0 varints. Trailing bytes after the +//! deliberately unlike `.ixe`'s TagN varints. Trailing bytes after the //! storage section are preserved opaquely (future sections: 0x01 agg //! tree, 0x02 per-unit assumption roots); readers of this version stop //! after storage, the `.ixes` trick. @@ -64,7 +64,8 @@ pub const CATALOG_MAGIC: &[u8; 8] = b"IXC\0\0\0\0\0"; /// The manifest's filename inside a `.ixc` directory. pub const MANIFEST_FILE: &str = "manifest"; -/// Manifest v2 binds Ixon v3 and erased-lean-v1 catalog claims. +/// Manifest v2 binds the Ixon object format (`Env::OBJECT_FORMAT`) and +/// erased-lean-v1 catalog claims. pub const CATALOG_VERSION: u32 = 2; /// Storage-profile flag: bit0 of the header `flags` word. @@ -228,7 +229,8 @@ impl Catalog { out.extend_from_slice(&CATALOG_VERSION.to_le_bytes()); let flags: u32 = if self.is_chunked() { FLAG_CHUNKED } else { 0 }; out.extend_from_slice(&flags.to_le_bytes()); - out.extend_from_slice(&[3, 1]); // Ixon v3, erased-lean-v1. + // Ixon object format, erased-lean-v1. + out.extend_from_slice(&[crate::env::Env::OBJECT_FORMAT, 1]); out.extend_from_slice(self.members_root.as_bytes()); out.extend_from_slice(self.content_root.as_bytes()); let count = u32::try_from(self.members.len()) @@ -307,8 +309,13 @@ impl Catalog { // they may change the meaning of everything that follows. return Err(format!("unknown .ixc flags 0x{flags:X}")); } - if c.u8()? != 3 { - return Err("catalog: unsupported object format".into()); + let format = c.u8()?; + if format != crate::env::Env::OBJECT_FORMAT { + return Err(format!( + "catalog: unsupported object format {format}, expected {} — \ + regenerate the catalog", + crate::env::Env::OBJECT_FORMAT + )); } if c.u8()? != 1 { return Err("catalog: wrong validator identity".into()); diff --git a/crates/ixon/src/comm.rs b/crates/ixon/src/comm.rs index 9de866ca9..61279bd43 100644 --- a/crates/ixon/src/comm.rs +++ b/crates/ixon/src/comm.rs @@ -5,14 +5,14 @@ use ix_common::address::Address; -use super::tag::Tag4; +use super::tag::TagN; -/// Tag4 variant for Commitment (flag=0xE, size=1). +/// TagN variant for Commitment (flag=0xE, value=1). pub const VARIANT: u64 = 1; /// A cryptographic commitment. /// -/// The commitment is computed as `blake3(Tag4{0xE,1} || secret || payload)` where: +/// The commitment is computed as `blake3(TagN{0xE,1} || secret || payload)` where: /// - `secret` is the address of a random blinding factor (stored in blobs) /// - `payload` is the address of the committed constant #[derive(Clone, Debug, PartialEq, Eq, Hash)] @@ -51,19 +51,19 @@ impl Comm { Ok(Comm { secret, payload }) } - /// Serialize with Tag4{0xE, 1} header. + /// Serialize with TagN{0xE, 1} header. pub fn put_tagged(&self, buf: &mut Vec) { - Tag4::new(0xE, VARIANT).put(buf); + TagN::put(4, 0xE, VARIANT, buf); self.put(buf); } - /// Deserialize with Tag4{0xE, 1} header. + /// Deserialize with TagN{0xE, 1} header. pub fn get_tagged(buf: &mut &[u8]) -> Result { - let tag = Tag4::get(buf)?; - if tag.flag != 0xE || tag.size != VARIANT { + let tag = TagN::get(4, buf)?; + if tag.flag != 0xE || tag.value != VARIANT { return Err(format!( - "Comm::get_tagged: expected Tag4{{0xE, 1}}, got Tag4{{{}, {}}}", - tag.flag, tag.size + "Comm::get_tagged: expected header {{0xE, 1}}, got {{{}, {}}}", + tag.flag, tag.value )); } Self::get(buf) diff --git a/crates/ixon/src/constant.rs b/crates/ixon/src/constant.rs index da6411ec6..1f206dc92 100644 --- a/crates/ixon/src/constant.rs +++ b/crates/ixon/src/constant.rs @@ -181,8 +181,8 @@ pub enum ConstantInfo { } impl ConstantInfo { - // Constant variant indices (used as Tag4 size field) - // These are 0-7, fitting in 3 bits for single-byte Tag4 + // Constant variant indices (the value of the TagN header) + // These are 0-7, fitting in 3 bits for single-byte TagN // Note: Muts uses a separate flag (0xC), not a variant here pub const CONST_DEFN: u64 = 0; pub const CONST_RECR: u64 = 1; @@ -193,7 +193,7 @@ impl ConstantInfo { pub const CONST_IPRJ: u64 = 6; pub const CONST_DPRJ: u64 = 7; - /// Returns the variant index (used as Tag4 size field) + /// Returns the variant index (the value of the TagN header) /// Returns None for Muts (which uses its own flag) pub fn variant(&self) -> Option { match self { @@ -224,9 +224,9 @@ pub struct Constant { } impl Constant { - /// Tag4 flag used for non-Muts constants (variant in size field, always 1 byte) + /// TagN flag used for non-Muts constants (the variant is the value; one byte) pub const FLAG: u8 = 0xD; - /// Tag4 flag used for Muts constants (entry count in size field) + /// TagN flag used for Muts constants (the entry count is the value) pub const FLAG_MUTS: u8 = 0xC; /// Create a new constant with no sharing, refs, or univs @@ -472,7 +472,7 @@ pub mod tests { } #[test] - fn constant_tag4_serialization() { + fn constant_tagn_serialization() { let defn = gen_definition(&mut Gen::new(10)); let cnst = Constant::new(ConstantInfo::Defn(defn)); let mut buf = Vec::new(); diff --git a/crates/ixon/src/diff.rs b/crates/ixon/src/diff.rs index 3e39b4d5e..0f60aabea 100644 --- a/crates/ixon/src/diff.rs +++ b/crates/ixon/src/diff.rs @@ -2877,8 +2877,8 @@ mod tests { let (o, slots) = count_occ(e, &cnst.sharing, &geran_idxs, &mut memo_geran); geran_occurrences += o; - // UnivPatch wire estimate: Tag0 arenaIdx (~3B) + Tag0 len (1B) - // + Tag0 per index (~2B). + // UnivPatch wire estimate: TagN arenaIdx (~3B) + TagN len (1B) + // + TagN per index (~2B). geran_patch_bytes += o * 4 + slots * 2; } } diff --git a/crates/ixon/src/env.rs b/crates/ixon/src/env.rs index 566a41b9b..f1a1c772f 100644 --- a/crates/ixon/src/env.rs +++ b/crates/ixon/src/env.rs @@ -329,7 +329,7 @@ pub struct AuxLayout { } /// One constant in a [`LazyIndex`]: its content address plus the byte window -/// `[offset, offset+len)` of its serialized Tag4 body within the source buffer. +/// `[offset, offset+len)` of its serialized TagN body within the source buffer. /// No bytes are copied — the consumer (the Lean lazy loader) slices its own /// copy of the buffer at these offsets. #[derive(Debug, Clone)] diff --git a/crates/ixon/src/error.rs b/crates/ixon/src/error.rs index 04b65e74e..7ddfbf7b5 100644 --- a/crates/ixon/src/error.rs +++ b/crates/ixon/src/error.rs @@ -49,7 +49,7 @@ impl std::error::Error for SerializeError {} /// Errors during compilation (Lean → Ixon). /// -/// Variant order matches Lean constructor tags (0–6). +/// Variant order matches Lean constructor tags (0–7). #[derive(Debug, Clone, PartialEq, Eq)] pub enum CompileError { /// Referenced constant not found (tag 0). @@ -67,6 +67,9 @@ pub enum CompileError { Serialize(SerializeError), /// Compilation could not stay within its resource budget (tag 6). ResourceLimit { reason: String }, + /// The sharing construction failed other than by resource exhaustion, + /// which is `ResourceLimit` (tag 7). + SharingConstruction { reason: String }, } impl std::fmt::Display for CompileError { @@ -87,6 +90,9 @@ impl std::fmt::Display for CompileError { }, Self::Serialize(e) => write!(f, "serialization error: {e}"), Self::ResourceLimit { reason } => write!(f, "resource limit: {reason}"), + Self::SharingConstruction { reason } => { + write!(f, "sharing construction: {reason}") + }, } } } @@ -108,7 +114,7 @@ impl From for CompileError { /// Errors during decompilation (Ixon → Lean). /// -/// Variant order matches Lean constructor tags (0–10). +/// Variant order matches Lean constructor tags (0–11). #[derive(Debug, Clone, PartialEq, Eq)] pub enum DecompileError { /// Invalid Ref(idx) reference - refs table too small (tag 0) @@ -133,6 +139,18 @@ pub enum DecompileError { BadConstantFormat { msg: String }, /// Serialization error during decompilation (tag 10) Serialize(SerializeError), + /// `Share(idx)` occurring in `meta_sharing[entry]` outside that entry's + /// index space (`ConstantMeta::meta_sharing`; tag 11): with `primary_len` + /// primary and `meta_len` metadata entries the valid indices are + /// `idx < primary_len + entry`. `idx >= primary_len + meta_len` is out of + /// range; any other rejected index is a forward or self reference. + InvalidMetaShareIndex { + idx: u64, + entry: u64, + primary_len: usize, + meta_len: usize, + constant: String, + }, } impl std::fmt::Display for DecompileError { @@ -180,6 +198,33 @@ impl std::fmt::Display for DecompileError { write!(f, "bad constant format: {msg}") }, Self::Serialize(e) => write!(f, "serialization error: {e}"), + Self::InvalidMetaShareIndex { + idx, + entry, + primary_len, + meta_len, + constant, + } => { + let end = u64::try_from(primary_len.saturating_add(*meta_len)) + .unwrap_or(u64::MAX); + if *idx >= end { + write!( + f, + "invalid Share({idx}) in meta_sharing[{entry}] of '{constant}': \ + out of range ({primary_len} primary + {meta_len} metadata entries)" + ) + } else { + let bound = u64::try_from(*primary_len) + .unwrap_or(u64::MAX) + .saturating_add(*entry); + write!( + f, + "invalid Share({idx}) in meta_sharing[{entry}] of '{constant}': \ + forward or self reference (this entry may reference only \ + indices below {bound})" + ) + } + }, } } } diff --git a/crates/ixon/src/expr.rs b/crates/ixon/src/expr.rs index 0aee6c4a2..1d62a8c29 100644 --- a/crates/ixon/src/expr.rs +++ b/crates/ixon/src/expr.rs @@ -90,7 +90,7 @@ pub enum Expr { } impl Expr { - // Tag4 flags for expression variants (0x0-0xB) + // TagN flags for expression variants (0x0-0xB) pub const FLAG_SORT: u8 = 0x0; pub const FLAG_VAR: u8 = 0x1; pub const FLAG_REF: u8 = 0x2; @@ -600,7 +600,7 @@ pub mod tests { #[test] fn telescope_lam_byte_boundaries() { for (n, tag_bytes) in - [(1u64, 1), (7, 1), (8, 2), (255, 2), (256, 3), (500, 3)] + [(1u64, 1), (7, 1), (8, 2), (255, 2), (256, 2), (1031, 2), (1032, 3)] { let ty = Expr::var(1); let mut expr: Arc = Expr::var(0); diff --git a/crates/ixon/src/lazy.rs b/crates/ixon/src/lazy.rs index a50822af1..c1a075dd8 100644 --- a/crates/ixon/src/lazy.rs +++ b/crates/ixon/src/lazy.rs @@ -1,7 +1,7 @@ //! Lazy materialization of `Constant` from on-disk bytes. //! //! Stored inside `Env::consts`: `DashMap`. The -//! `.ixe` loader reads each constant's bytes (preceded by a Tag0 +//! `.ixe` loader reads each constant's bytes (preceded by a TagN //! length sidecar at the env-section level — see `Env::get`) into a //! `LazyConstant::from_bytes`, deferring `Constant::get` until first //! access via [`LazyConstant::get`]. @@ -27,7 +27,7 @@ //! //! Invariants: //! - `raw_bytes()` returns exactly what `Constant::put` produces and -//! `Address::hash` consumes — the Tag0 length prefix is *not* +//! `Address::hash` consumes — the TagN length prefix is *not* //! included. //! - `Address::hash(self.raw_bytes()) == addr` for the address this //! lazy entry was stored under (`verify_address` checks this). @@ -96,7 +96,7 @@ pub enum ConstVariantTag { /// Lazy-materialized `Constant` backed by serialized bytes. #[derive(Debug, Clone)] pub struct LazyConstant { - /// Tag4-encoded constant bytes (exactly the slice consumed by + /// TagN-encoded constant bytes (exactly the slice consumed by /// `Constant::get` and hashed by `Address::hash`). bytes: BytesSource, /// Pre-materialized `Constant`. Populated *only* by @@ -258,16 +258,16 @@ impl LazyConstant { } /// Identify the `ConstantInfo` variant by reading just the outer - /// `Tag4` head byte — no allocation, no body parse. + /// TagN (f = 4) header byte — no allocation, no body parse. /// - /// `Tag4` encoding (see `src/ix/ixon/tag.rs:64-70`): head is - /// `[flag:4][large:1][size:3]`. For `Constant`: - /// - `flag = 0xC` (`Constant::FLAG_MUTS`) → Muts block (size field - /// encodes the entry count, possibly in large form; we ignore it + /// TagN (f = 4) encoding (`crate::tag::TagN`): head is + /// `[flag:4][L:1][payload:3]`, `L = 0` for values below 8. For `Constant`: + /// - `flag = 0xC` (`Constant::FLAG_MUTS`) → Muts block (the value is + /// the entry count, possibly multi-byte; we ignore it /// here — knowing it's Muts is enough). /// - `flag = 0xD` (`Constant::FLAG`) → non-Muts variant; index - /// 0..=7 in the `size` field. All non-Muts variants fit in 3 - /// bits, so `large=0` always; the index is read directly. + /// 0..=7 as the value. All non-Muts variants fit in 3 + /// bits, so `L = 0` always; the index is read directly. /// /// Used by `build_anon_work` to dispatch on variant without /// materializing the entire `Arc` body. For the ~95% of @@ -286,7 +286,7 @@ impl LazyConstant { Constant::FLAG => { if large { return Err(format!( - "LazyConstant::peek_variant: unexpected large-form Tag4 for non-Muts constant (head=0x{head:02X})" + "LazyConstant::peek_variant: unexpected multi-byte header for non-Muts constant (head=0x{head:02X})" )); } match u64::from(small) { @@ -304,12 +304,12 @@ impl LazyConstant { } }, _ => Err(format!( - "LazyConstant::peek_variant: unexpected Tag4 flag 0x{flag:X} (expected 0xC or 0xD)" + "LazyConstant::peek_variant: unexpected constant header flag 0x{flag:X} (expected 0xC or 0xD)" )), } } - /// Raw serialized bytes (the Tag4 constant body, no length prefix). + /// Raw serialized bytes (the TagN constant body, no length prefix). pub fn raw_bytes(&self) -> &[u8] { self.bytes.as_slice() } diff --git a/crates/ixon/src/lib.rs b/crates/ixon/src/lib.rs index aeff352d1..d19b442bc 100644 --- a/crates/ixon/src/lib.rs +++ b/crates/ixon/src/lib.rs @@ -2,7 +2,7 @@ //! //! This module provides: //! - Alpha-invariant representations of Lean expressions and constants -//! - Compact tag-based serialization (Tag4 for exprs, Tag2 for univs, Tag0 for ints) +//! - Compact TagN integer serialization (4-bit flag for exprs, 2-bit for univs, none for ints) //! - Content-addressed storage with sharing support //! - Cryptographic commitments for ZK proofs @@ -25,13 +25,14 @@ pub mod proof; pub mod resource; pub mod serialize; pub mod shard_claim; -pub mod sharing; +pub mod sharing_exact; pub mod syntax; pub mod tag; pub mod univ; -/// Stable identifier for the v3 Ixon wire grammar. -pub const WIRE_FORMAT_ID: &str = "ixon-v3"; +/// Stable identifier for the Ixon wire format, version 4 +/// (`Env::VERSION`). Mirrors `Ixon.wireFormatId`. +pub const WIRE_FORMAT_ID: &str = "ixon-v4"; // Re-export main types pub use comm::Comm; @@ -57,7 +58,7 @@ pub use proof::{ Claim, Proof, RevealConstantInfo, RevealConstructorInfo, RevealMutConstInfo, RevealRecursorRule, }; -pub use tag::{Tag0, Tag2, Tag4}; +pub use tag::TagN; pub use univ::Univ; /// Shared test utilities for ixon modules. @@ -106,92 +107,52 @@ mod doc_examples { use ix_common::address::Address; // ========================================================================= - // Tag4 examples (docs section "Tag4 (4-bit flag)") + // TagN examples (docs section "TagN"): f = 4, 2, 0 flag bits // ========================================================================= - #[test] - fn tag4_small_value() { - // Tag4 { flag: 0x1, size: 5 } - // Header: 0b0001_0_101 = 0x15 - let tag = Tag4::new(0x1, 5); + fn tagn(f: u32, flag: u8, value: u64) -> Vec { let mut buf = Vec::new(); - tag.put(&mut buf); - assert_eq!(buf, vec![0x15], "Tag4 {{ flag: 1, size: 5 }} should be 0x15"); + TagN::put(f, flag, value, &mut buf); + buf } #[test] - fn tag4_large_value() { - // Tag4 { flag: 0x2, size: 256 } - // Header: 0b0010_1_001 = 0x29 (large=1, 2 bytes follow) - // Bytes: 0x00 0x01 (256 in little-endian) - let tag = Tag4::new(0x2, 256); - let mut buf = Vec::new(); - tag.put(&mut buf); - assert_eq!( - buf, - vec![0x29, 0x00, 0x01], - "Tag4 {{ flag: 2, size: 256 }} should be [0x29, 0x00, 0x01]" - ); + fn tagn4_small_value() { + // f = 4, flag 0x1, value 5: rung 1 (value < 8), header 0b0001_0_101. + assert_eq!(tagn(4, 0x1, 5), vec![0x15]); } - // ========================================================================= - // Tag2 examples (docs section "Tag2 (2-bit flag)") - // ========================================================================= - #[test] - fn tag2_small_value() { - // Tag2 { flag: 0, size: 15 } - // Header: 0b00_0_01111 = 0x0F - let tag = Tag2::new(0, 15); - let mut buf = Vec::new(); - tag.put(&mut buf); - assert_eq!(buf, vec![0x0F], "Tag2 {{ flag: 0, size: 15 }} should be 0x0F"); + fn tagn4_two_byte_value() { + // f = 4, flag 0x2, value 256: rung 2 ([8, 1032)), 256 - 8 = 248 = 0x0F8: + // header 0b0010_10_00 (L = 1, M = 0, high bits 0), then 0xF8. + assert_eq!(tagn(4, 0x2, 256), vec![0x28, 0xF8]); } #[test] - fn tag2_large_value() { - // Tag2 { flag: 3, size: 100 } - // 100 doesn't fit in 5 bits, needs 1 byte to encode - // Header: 0b11_1_00000 = 0xE0 (flag=3, large=1, byte_count-1=0) - // Bytes: 0x64 (100) - let tag = Tag2::new(3, 100); - let mut buf = Vec::new(); - tag.put(&mut buf); - assert_eq!( - buf, - vec![0xE0, 0x64], - "Tag2 {{ flag: 3, size: 100 }} should be [0xE0, 0x64]" - ); + fn tagn2_small_value() { + // f = 2, flag 0, value 15: rung 1 (value < 32), header 0b00_0_01111. + assert_eq!(tagn(2, 0, 15), vec![0x0F]); } - // ========================================================================= - // Tag0 examples (docs section "Tag0 (no flag)") - // ========================================================================= + #[test] + fn tagn2_two_byte_value() { + // f = 2, flag 3, value 100: rung 2 ([32, 4128)), 100 - 32 = 68 = 0x44: + // header 0b11_10_0000, then 0x44. + assert_eq!(tagn(2, 3, 100), vec![0xE0, 0x44]); + } #[test] - fn tag0_small_value() { - // Tag0 { size: 42 } - // Header: 0b0_0101010 = 0x2A - let tag = Tag0::new(42); - let mut buf = Vec::new(); - tag.put(&mut buf); - assert_eq!(buf, vec![0x2A], "Tag0 {{ size: 42 }} should be 0x2A"); + fn tagn0_small_value() { + // f = 0, value 42: rung 1 (value < 128), header 0b0_0101010. + assert_eq!(tagn(0, 0, 42), vec![0x2A]); } #[test] - fn tag0_large_value() { - // Tag0 { size: 1000 } - // 1000 = 0x3E8, needs 2 bytes to encode - // Header: 0b1_0000001 = 0x81 (large=1, byte_count-1=1) - // Bytes: 0xE8 0x03 (1000 in little-endian) - let tag = Tag0::new(1000); - let mut buf = Vec::new(); - tag.put(&mut buf); - assert_eq!( - buf, - vec![0x81, 0xE8, 0x03], - "Tag0 {{ size: 1000 }} should be [0x81, 0xE8, 0x03]" - ); + fn tagn0_two_byte_value() { + // f = 0, value 1000: rung 2 ([128, 16512)), 1000 - 128 = 872 = 0x368: + // header 0b10_000011 (high bits 3), then 0x68. + assert_eq!(tagn(0, 0, 1000), vec![0x83, 0x68]); } // ========================================================================= @@ -200,7 +161,7 @@ mod doc_examples { #[test] fn univ_zero() { - // Univ::Zero -> Tag2 { flag: 0, size: 0 } -> 0x00 + // Univ::Zero -> TagN(2, 0, 0) -> 0x00 let mut buf = Vec::new(); univ::put_univ(&Univ::zero(), &mut buf); assert_eq!(buf, vec![0x00], "Univ::Zero should be 0x00"); @@ -209,7 +170,7 @@ mod doc_examples { #[test] fn univ_succ_zero() { // Univ::Succ(Zero) uses telescope compression: - // Tag2 { flag: 0, size: 1 } (succ_count=1) + base (Zero) + // TagN(2, 0, 1) (succ_count=1) + base (Zero) // = 0b00_0_00001 = 0x01, then Zero = 0x00 let mut buf = Vec::new(); univ::put_univ(&Univ::succ(Univ::zero()), &mut buf); @@ -222,7 +183,7 @@ mod doc_examples { #[test] fn univ_var_1() { - // Univ::Var(1) -> Tag2 { flag: 3, size: 1 } + // Univ::Var(1) -> TagN(2, 3, 1) // = 0b11_0_00001 = 0xC1 let mut buf = Vec::new(); univ::put_univ(&Univ::var(1), &mut buf); @@ -231,7 +192,7 @@ mod doc_examples { #[test] fn univ_max_zero_var1() { - // Univ::Max(Zero, Var(1)) -> Tag2 { flag: 1, size: 0 } + Zero + Var(1) + // Univ::Max(Zero, Var(1)) -> TagN(2, 1, 0) + Zero + Var(1) // = 0b01_0_00000 = 0x40, then 0x00 (Zero), then 0xC1 (Var(1)) let mut buf = Vec::new(); univ::put_univ(&Univ::max(Univ::zero(), Univ::var(1)), &mut buf); @@ -248,7 +209,7 @@ mod doc_examples { #[test] fn expr_var_0() { - // Expr::Var(0) -> Tag4 { flag: 0x1, size: 0 } -> 0x10 + // Expr::Var(0) -> TagN(4, 0x1, 0) -> 0x10 let mut buf = Vec::new(); serialize::put_expr(&Expr::Var(0), &mut buf); assert_eq!(buf, vec![0x10], "Expr::Var(0) should be 0x10"); @@ -256,7 +217,7 @@ mod doc_examples { #[test] fn expr_sort_0() { - // Expr::Sort(0) -> Tag4 { flag: 0x0, size: 0 } -> 0x00 + // Expr::Sort(0) -> TagN(4, 0x0, 0) -> 0x00 let mut buf = Vec::new(); serialize::put_expr(&Expr::Sort(0), &mut buf); assert_eq!(buf, vec![0x00], "Expr::Sort(0) should be 0x00"); @@ -264,7 +225,7 @@ mod doc_examples { #[test] fn expr_ref_no_univs() { - // Expr::Ref(0, []) -> Tag4 { flag: 0x2, size: 0 } + idx(0) + // Expr::Ref(0, []) -> TagN(4, 0x2, 0) + idx(0) // = 0x20 + 0x00 let mut buf = Vec::new(); serialize::put_expr(&Expr::Ref(0, vec![]), &mut buf); @@ -277,7 +238,7 @@ mod doc_examples { #[test] fn expr_share_5() { - // Expr::Share(5) -> Tag4 { flag: 0xB, size: 5 } -> 0xB5 + // Expr::Share(5) -> TagN(4, 0xB, 5) -> 0xB5 let mut buf = Vec::new(); serialize::put_expr(&Expr::Share(5), &mut buf); assert_eq!(buf, vec![0xB5], "Expr::Share(5) should be 0xB5"); @@ -286,7 +247,7 @@ mod doc_examples { #[test] fn expr_app_telescope() { // App(App(App(f, a), b), c) with f=Var(3), a=Var(2), b=Var(1), c=Var(0) - // -> Tag4 { flag: 0x7, size: 3 } + f + a + b + c + // -> TagN(4, 0x7, 3) + f + a + b + c let expr = Expr::app( Expr::app(Expr::app(Expr::var(3), Expr::var(2)), Expr::var(1)), Expr::var(0), @@ -315,7 +276,7 @@ mod doc_examples { assert_eq!( buf, vec![0x83, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x10], - "Lam telescope carries explicit v3 input contracts" + "Lam telescope carries explicit input contracts" ); } @@ -325,7 +286,7 @@ mod doc_examples { #[test] fn eval_claim_tag() { - // Eval claim -> Tag4 { flag: 0xE, size: 3 } -> 0xE3 (single byte) + // Eval claim -> TagN(4, 0xE, 3) -> 0xE3 (single byte) let claim = Claim::Eval { input: Address::hash(b"input"), output: Address::hash(b"output"), @@ -340,7 +301,7 @@ mod doc_examples { #[test] fn eval_proof_tag() { - // Eval proof -> Tag4 { flag: 0xF, size: 0 } -> 0xF0 (single byte) + // Eval proof -> TagN(4, 0xF, 0) -> 0xF0 (single byte) let proof = Proof::new( Claim::Eval { input: Address::hash(b"input"), @@ -360,7 +321,7 @@ mod doc_examples { #[test] fn check_claim_tag() { - // Check claim -> Tag4 { flag: 0xE, size: 4 } -> 0xE4 + // Check claim -> TagN(4, 0xE, 4) -> 0xE4 let claim = Claim::Check { const_addr: Address::hash(b"value"), assumptions: None }; let mut buf = Vec::new(); @@ -371,7 +332,7 @@ mod doc_examples { #[test] fn check_proof_tag() { - // Check proof -> Tag4 { flag: 0xF, size: 1 } -> 0xF1 + // Check proof -> TagN(4, 0xF, 1) -> 0xF1 let proof = Proof::new( Claim::Check { const_addr: Address::hash(b"value"), assumptions: None }, vec![5, 6, 7], @@ -448,7 +409,7 @@ mod doc_examples { #[test] fn constant_defn_tag() { - // Constant with Defn -> Tag4 { flag: 0xD, size: 0 } -> 0xD0 + // Constant with Defn -> TagN(4, 0xD, 0) -> 0xD0 use constant::{Constant, ConstantInfo, DefKind, Definition}; use ix_common::env::DefinitionSafety; @@ -466,7 +427,7 @@ mod doc_examples { #[test] fn constant_muts_tag() { - // Muts with 3 entries -> Tag4 { flag: 0xC, size: 3 } -> 0xC3 + // Muts with 3 entries -> TagN(4, 0xC, 3) -> 0xC3 use constant::{Constant, ConstantInfo, DefKind, Definition, MutConst}; use ix_common::env::DefinitionSafety; @@ -493,14 +454,14 @@ mod doc_examples { #[test] fn env_tag() { - // Env -> Tag4 { flag: 0xE, size: VERSION } -> 0xE3 for v3 + // Env -> TagN(4, 0xE, VERSION) -> 0xE4 for version 4 let env = Env::new(); let mut buf = Vec::new(); env.put(&mut buf).unwrap(); let header = (Env::FLAG << 4) | u8::try_from(Env::VERSION).unwrap(); assert_eq!( buf[0], header, - "Env should start with {header:#04X} (flag=E, size=format version)" + "Env should start with {header:#04X} (flag=E, value=format version)" ); } } diff --git a/crates/ixon/src/metadata.rs b/crates/ixon/src/metadata.rs index dd2a8fd3e..4af694d72 100644 --- a/crates/ixon/src/metadata.rs +++ b/crates/ixon/src/metadata.rs @@ -18,7 +18,7 @@ use ix_common::env::{self, BinderInfo, Name}; use super::env::AuxLayout; use super::expr::Expr; use super::serialize::{get_expr, put_expr}; -use super::tag::Tag0; +use super::tag::TagN; use super::univ::{Univ, get_univ, put_univ}; // =========================================================================== @@ -34,7 +34,8 @@ pub enum CallSiteEntry { /// Argument exists in canonical form at App-spine position `canon_idx`. /// `meta` is the arena index for this argument's metadata subtree. Kept { canon_idx: u64, meta: u64 }, - /// Argument was collapsed. Expression stored in `ConstantMeta.meta_sharing[sharing_idx]`. + /// Argument was collapsed. Expression stored in `ConstantMeta.meta_sharing[sharing_idx]` + /// (a direct index, not offset by the primary sharing table's length). /// `meta` is the arena index for this argument's metadata subtree /// (may differ from the representative's metadata — different names, refs, etc.). Collapsed { sharing_idx: u64, meta: u64 }, @@ -234,20 +235,39 @@ pub struct UnivPatch { /// Per-constant metadata wrapper: variant payload + extension tables. /// -/// Extension tables (`meta_sharing`, `meta_refs`, `meta_univs`) form a -/// virtual address space extending the primary `Constant` tables. They are -/// used by `CallSite` nodes in the metadata arena for call-site surgery -/// roundtrip: collapsed argument expressions reference these tables via -/// `Share(idx)`, `Ref(idx)`, and universe indices — and by `univ_patches` +/// Extension tables (`meta_sharing`, `meta_refs`, `meta_univs`) extend the +/// index spaces of the primary `Constant` tables (for a projection, the +/// tables of its `Muts` block). They are used by `CallSite` nodes in the +/// metadata arena for call-site surgery roundtrip — collapsed argument +/// expressions use `Ref(idx)` and universe indices in the extended spaces, +/// and `Share(idx)` as specified on `meta_sharing` — and by `univ_patches` /// for original level spellings (canonicity §10.6). /// -/// At decompile time, extension tables are appended to the block cache, -/// creating a contiguous address space. +/// At decompile time `meta_refs`/`meta_univs` are appended to the block +/// cache's primary tables, creating contiguous index spaces; `meta_sharing` +/// is kept in its own table and read by the rule on that field. #[derive(Clone, Debug, PartialEq, Eq)] pub struct ConstantMeta { pub info: ConstantMetaInfo, - /// Compiled Ixon expressions for collapsed call-site arguments. - /// May contain `Share(idx)` references into the extended sharing table. + /// Compiled Ixon expressions for collapsed call-site arguments and + /// rewritten call-site heads, indexed DIRECTLY (no offset) by + /// `CallSiteEntry::Collapsed.sharing_idx` and + /// `orig_head = Some((sharing_idx, _))`. + /// + /// Extended index space for `Share` (a reader rule; the bytes are + /// unchanged). Let the primary table `sharing` have `p` entries and this + /// table `q`. A `Share(i)` occurring inside an expression of + /// `meta_sharing[j]` denotes primary entry `i` when `i < p` (expanded + /// against the primary table only: shares nested in a primary entry stay + /// primary) and `meta_sharing[i - p]` when `p <= i < p + j`. Entry `j` + /// may reference every primary entry and only the metadata entries + /// before it; `i >= p + q` (out of range) and `p + j <= i < p + q` (a + /// forward or self reference) are reader errors, so expansion is well + /// founded. A `Share` in a primary expression always denotes a primary + /// entry: metadata never changes how primary bytes decode. Readers: the + /// Rust and Lean decompilers (`ix_compile::decompile::ShareScope`, Lean + /// `Ix.DecompileM.ShareScope`); kernel ingress never reads this table. + /// The compilers emit no `Share` here today. pub meta_sharing: Vec>, /// Extension refs table (addresses referenced by collapsed arg expressions). pub meta_refs: Vec
, @@ -400,7 +420,7 @@ impl ConstantMeta { buf: &mut Vec, ) -> Result<(), String> { self.info.put_with(idx, buf)?; - // Extension tables (backward-compatible: 0-length for old constants) + // Extension tables (each empty when the constant has none) put_vec_len(self.meta_sharing.len(), buf); for expr in &self.meta_sharing { put_expr(expr, buf); @@ -413,14 +433,14 @@ impl ConstantMeta { for univ in &self.meta_univs { put_univ(univ, buf); } - // Level-spelling patches (canonicity §10.6): per entry, Tag0 - // arena_idx, Tag0 len, Tag0 virtual univ indices. + // Level-spelling patches (canonicity §10.6): per entry, TagN + // arena_idx, TagN len, TagN virtual univ indices. put_vec_len(self.univ_patches.len(), buf); for patch in &self.univ_patches { - Tag0::new(patch.arena_idx).put(buf); + TagN::put(0, 0, patch.arena_idx, buf); put_vec_len(patch.univ_idxs.len(), buf); for idx in &patch.univ_idxs { - Tag0::new(*idx).put(buf); + TagN::put(0, 0, *idx, buf); } } Ok(()) @@ -462,11 +482,11 @@ impl ConstantMeta { let patches_len = get_vec_len(buf)?; let mut univ_patches = Vec::with_capacity(patches_len); for _ in 0..patches_len { - let arena_idx = Tag0::get(buf)?.size; + let arena_idx = TagN::get(0, buf)?.value; let idxs_len = get_vec_len(buf)?; let mut univ_idxs = Vec::with_capacity(idxs_len); for _ in 0..idxs_len { - univ_idxs.push(Tag0::get(buf)?.size); + univ_idxs.push(TagN::get(0, buf)?.value); } univ_patches.push(UnivPatch { arena_idx, univ_idxs }); } @@ -550,8 +570,8 @@ fn deser_u8(buf: &mut &[u8]) -> Option { Some(x) } -fn deser_tag0(buf: &mut &[u8]) -> Option { - Tag0::get(buf).ok().map(|t| t.size) +fn deser_tagn0(buf: &mut &[u8]) -> Option { + TagN::get(0, buf).ok().map(|t| t.value) } fn deser_addr(buf: &mut &[u8]) -> Option
{ @@ -580,8 +600,8 @@ fn deser_substring( ) -> Option { let str_addr = deser_addr(buf)?; let s = String::from_utf8(ixon_env.get_blob(&str_addr)?).ok()?; - let start_pos = bignat::Nat::from(deser_tag0(buf)?); - let stop_pos = bignat::Nat::from(deser_tag0(buf)?); + let start_pos = bignat::Nat::from(deser_tagn0(buf)?); + let stop_pos = bignat::Nat::from(deser_tagn0(buf)?); Some(env::Substring { str: s, start_pos, stop_pos }) } @@ -592,9 +612,9 @@ fn deser_source_info( match deser_u8(buf)? { 0 => { let leading = deser_substring(buf, ixon_env)?; - let leading_pos = bignat::Nat::from(deser_tag0(buf)?); + let leading_pos = bignat::Nat::from(deser_tagn0(buf)?); let trailing = deser_substring(buf, ixon_env)?; - let trailing_pos = bignat::Nat::from(deser_tag0(buf)?); + let trailing_pos = bignat::Nat::from(deser_tagn0(buf)?); Some(env::SourceInfo::Original( leading, leading_pos, @@ -603,8 +623,8 @@ fn deser_source_info( )) }, 1 => { - let start = bignat::Nat::from(deser_tag0(buf)?); - let end = bignat::Nat::from(deser_tag0(buf)?); + let start = bignat::Nat::from(deser_tagn0(buf)?); + let end = bignat::Nat::from(deser_tagn0(buf)?); let canonical = deser_u8(buf)? != 0; Some(env::SourceInfo::Synthetic(start, end, canonical)) }, @@ -624,7 +644,7 @@ fn deser_preresolved( }, 1 => { let name = ixon_env.get_name(&deser_addr(buf)?)?; - let count = deser_tag0(buf)? as usize; + let count = deser_tagn0(buf)? as usize; let mut fields = Vec::with_capacity(count); for _ in 0..count { let addr = deser_addr(buf)?; @@ -645,7 +665,7 @@ fn deser_syntax( 1 => { let info = deser_source_info(buf, ixon_env)?; let kind = ixon_env.get_name(&deser_addr(buf)?)?; - let arg_count = deser_tag0(buf)? as usize; + let arg_count = deser_tagn0(buf)? as usize; let mut args = Vec::with_capacity(arg_count); for _ in 0..arg_count { args.push(deser_syntax(buf, ixon_env)?); @@ -662,7 +682,7 @@ fn deser_syntax( let info = deser_source_info(buf, ixon_env)?; let raw_val = deser_substring(buf, ixon_env)?; let val = ixon_env.get_name(&deser_addr(buf)?)?; - let pr_count = deser_tag0(buf)? as usize; + let pr_count = deser_tagn0(buf)? as usize; let mut preresolved = Vec::with_capacity(pr_count); for _ in 0..pr_count { preresolved.push(deser_preresolved(buf, ixon_env)?); @@ -720,19 +740,19 @@ fn get_address_raw(buf: &mut &[u8]) -> Result { } fn put_u64(x: u64, buf: &mut Vec) { - Tag0::new(x).put(buf); + TagN::put(0, 0, x, buf); } fn get_u64(buf: &mut &[u8]) -> Result { - Ok(Tag0::get(buf)?.size) + Ok(TagN::get(0, buf)?.value) } pub(super) fn put_vec_len(len: usize, buf: &mut Vec) { - Tag0::new(len as u64).put(buf); + TagN::put(0, 0, len as u64, buf); } pub(super) fn get_vec_len(buf: &mut &[u8]) -> Result { - Ok(Tag0::get(buf)?.size as usize) + Ok(TagN::get(0, buf)?.value as usize) } // =========================================================================== @@ -769,7 +789,7 @@ impl IxonByteSerde for BinderInfo { // `ReducibilityHints` has no `IxonByteSerde` impl: its only wire home // is the env-level §3 section, which fuses the variant and height into -// a single Tag0 value (see `serialize.rs::fuse_hint`). +// a single TagN value (see `serialize.rs::fuse_hint`). // =========================================================================== // Indexed serialization (Address -> u64 index) @@ -969,89 +989,266 @@ fn get_mdata_stack_indexed( } // =========================================================================== -// ExprMetaData indexed serialization +// ExprMeta (arena) indexed serialization // =========================================================================== +// +// Wire format of an arena (`docs/Ixon.md`, "ExprMeta Arena"): +// +// arena := len node_0 … node_{len-1} +// node_i := tag payload, tag = kind << 3 | mask +// +// Kinds: 0 Leaf, 1 App, 2..5 Binder (2 + BinderInfo), 6 LetBinder, 7 Ref, +// 8 Prj, 9 Mdata, 10 CallSite, 11 EtaCallSite. The payload is the node's +// fields in declaration order. Child references are never absolute: +// +// * The *structural* slots (App fun/arg, Binder type/body, Let +// type/value/body, Prj child, Mdata child) may be **implicit**: bit `s` of +// `mask` set means slot `s` is not written and refers to the node the +// post-order cursor expects. The cursor `top` starts at `i` and visits the +// slots last to first; an implicit slot is node `top - 1`, after which +// `top` becomes `lo[top - 1]`; `lo[i]` is `top` after the last slot (the +// first index of node `i`'s contiguous post-order block; `lo[i] = i` for a +// node without structural slots). A tree allocated bottom-up in post-order +// writes no child references at all. +// * Every other reference (a structural slot whose bit is clear, and every +// call-site reference) is **explicit**: TagN (`f = 0`) of the backward +// delta `(i - 1 - c) mod 2^64`. Forward references are representable +// (wrapping), so every arena of `u64` indices has an encoding. +// +// The writer marks a slot implicit exactly when its child is `top - 1`, and +// the reader rejects an explicit slot equal to `top - 1` and an implicit +// slot with `top = 0`, so each arena has exactly one encoding. Mirrors +// `Ixon.putExprMetaArenaIndexed` / `getExprMetaArenaIndexed`. + +const EM_LEAF: u8 = 0; +const EM_APP: u8 = 1; +const EM_BINDER: u8 = 2; +const EM_LET: u8 = 6; +const EM_REF: u8 = 7; +const EM_PRJ: u8 = 8; +const EM_MDATA: u8 = 9; +const EM_CALL_SITE: u8 = 10; +const EM_ETA_CALL_SITE: u8 = 11; + +/// Number of structural (possibly implicit) child slots of a node kind. +fn em_slot_count(kind: u8) -> Option { + match kind { + EM_LEAF | EM_REF | EM_CALL_SITE | EM_ETA_CALL_SITE => Some(0), + EM_APP | 2..=5 => Some(2), + EM_LET => Some(3), + EM_PRJ | EM_MDATA => Some(1), + _ => None, + } +} impl ExprMetaData { - // Tag 0: Leaf (no payload) - // Tag 1: App { children: [u32, u32] } - // Tags 2-5: Binder with BinderInfo packed into tag (2 + variant) - // Tag 6: LetBinder { name_idx, children: [u32, u32, u32] } - // Tag 7: Ref { name_idx } - // Tag 8: Prj { struct_name_idx, child: u32 } - // Tag 9: Mdata { kvmap_count, kvmaps..., child: u32 } + /// The structural child slots, in field order. + fn structural_slots(&self) -> &[u64] { + match self { + Self::App { children } | Self::Binder { children, .. } => children, + Self::LetBinder { children, .. } => children, + Self::Prj { child, .. } | Self::Mdata { child, .. } => { + std::slice::from_ref(child) + }, + Self::Leaf + | Self::Ref { .. } + | Self::CallSite { .. } + | Self::EtaCallSite { .. } => &[], + } + } +} - pub fn put_with( +/// The implicit-slot mask of node `i` and its block start `lo[i]`. +fn em_implicit_mask(node: &ExprMetaData, i: u64, lo: &[u64]) -> (u8, u64) { + let mut top = i; + let mut mask = 0u8; + for (s, &c) in node.structural_slots().iter().enumerate().rev() { + if top > 0 && c == top - 1 { + mask |= 1 << s; + top = lo[(top - 1) as usize]; + } + } + (mask, top) +} + +/// Explicit reference from node `i` to node `c`: the backward delta +/// `(i - 1 - c) mod 2^64` as a TagN (`f = 0`) integer. +fn put_em_ref(i: u64, c: u64, buf: &mut Vec) { + put_u64(i.wrapping_sub(1).wrapping_sub(c), buf); +} + +fn get_em_ref(i: u64, buf: &mut &[u8]) -> Result { + Ok(i.wrapping_sub(1).wrapping_sub(get_u64(buf)?)) +} + +/// Structural slot `s` of node `i`: written only when not implicit. +fn put_em_slot(i: u64, mask: u8, s: u32, c: u64, buf: &mut Vec) { + if mask & (1 << s) == 0 { + put_em_ref(i, c, buf); + } +} + +/// Structural slot `s` of node `i`: read when explicit, a placeholder +/// (resolved by [`em_resolve_slots`]) when implicit. +fn get_em_slot( + i: u64, + mask: u8, + s: u32, + buf: &mut &[u8], +) -> Result { + if mask & (1 << s) == 0 { get_em_ref(i, buf) } else { Ok(0) } +} + +/// Resolve the implicit slots of node `i` in place and return `lo[i]`. +fn em_resolve_slots( + slots: &mut [u64], + mask: u8, + i: u64, + lo: &[u64], +) -> Result { + let mut top = i; + for s in (0..slots.len()).rev() { + if mask & (1 << s) != 0 { + if top == 0 { + return Err(format!( + "ExprMeta::get: node {i}: implicit child slot {s} with no \ + preceding node" + )); + } + slots[s] = top - 1; + top = lo[(top - 1) as usize]; + } else if top > 0 && slots[s] == top - 1 { + return Err(format!( + "ExprMeta::get: node {i}: explicit child slot {s} refers to the \ + implicit position {} (noncanonical)", + top - 1 + )); + } + } + Ok(top) +} + +fn put_em_entries(i: u64, entries: &[CallSiteEntry], buf: &mut Vec) { + put_vec_len(entries.len(), buf); + for entry in entries { + match entry { + CallSiteEntry::Kept { canon_idx, meta } => { + put_u8(0, buf); + put_u64(*canon_idx, buf); + put_em_ref(i, *meta, buf); + }, + CallSiteEntry::Collapsed { sharing_idx, meta } => { + put_u8(1, buf); + put_u64(*sharing_idx, buf); + put_em_ref(i, *meta, buf); + }, + } + } +} + +fn get_em_entries( + i: u64, + buf: &mut &[u8], +) -> Result, String> { + let n_entries = get_vec_len(buf)?; + let mut entries = Vec::with_capacity(n_entries.min(buf.len())); + for _ in 0..n_entries { + let entry = match get_u8(buf)? { + 0 => { + let canon_idx = get_u64(buf)?; + let meta = get_em_ref(i, buf)?; + CallSiteEntry::Kept { canon_idx, meta } + }, + 1 => { + let sharing_idx = get_u64(buf)?; + let meta = get_em_ref(i, buf)?; + CallSiteEntry::Collapsed { sharing_idx, meta } + }, + x => return Err(format!("CallSiteEntry::get: invalid tag {x}")), + }; + entries.push(entry); + } + Ok(entries) +} + +fn put_em_refs(i: u64, refs: &[u64], buf: &mut Vec) { + put_vec_len(refs.len(), buf); + for &c in refs { + put_em_ref(i, c, buf); + } +} + +fn get_em_refs(i: u64, buf: &mut &[u8]) -> Result, String> { + let len = get_vec_len(buf)?; + let mut v = Vec::with_capacity(len.min(buf.len())); + for _ in 0..len { + v.push(get_em_ref(i, buf)?); + } + Ok(v) +} + +impl ExprMetaData { + /// Write node `i` with its implicit-slot `mask` (see the module comment + /// above). + fn put_node( &self, + i: u64, + mask: u8, idx: NamePut<'_>, buf: &mut Vec, ) -> Result<(), String> { match self { - Self::Leaf => put_u8(0, buf), + Self::Leaf => put_u8(EM_LEAF << 3, buf), Self::App { children } => { - put_u8(1, buf); - put_u64(children[0], buf); - put_u64(children[1], buf); + put_u8((EM_APP << 3) | mask, buf); + put_em_slot(i, mask, 0, children[0], buf); + put_em_slot(i, mask, 1, children[1], buf); }, Self::Binder { name, info, children } => { - let tag = 2 + let kind = EM_BINDER + match info { BinderInfo::Default => 0u8, BinderInfo::Implicit => 1, BinderInfo::StrictImplicit => 2, BinderInfo::InstImplicit => 3, }; - put_u8(tag, buf); + put_u8((kind << 3) | mask, buf); put_idx(name, idx, buf)?; - put_u64(children[0], buf); - put_u64(children[1], buf); + put_em_slot(i, mask, 0, children[0], buf); + put_em_slot(i, mask, 1, children[1], buf); }, Self::LetBinder { name, children } => { - put_u8(6, buf); + put_u8((EM_LET << 3) | mask, buf); put_idx(name, idx, buf)?; - put_u64(children[0], buf); - put_u64(children[1], buf); - put_u64(children[2], buf); + put_em_slot(i, mask, 0, children[0], buf); + put_em_slot(i, mask, 1, children[1], buf); + put_em_slot(i, mask, 2, children[2], buf); }, Self::Ref { name } => { - put_u8(7, buf); + put_u8(EM_REF << 3, buf); put_idx(name, idx, buf)?; }, Self::Prj { struct_name, child } => { - put_u8(8, buf); + put_u8((EM_PRJ << 3) | mask, buf); put_idx(struct_name, idx, buf)?; - put_u64(*child, buf); + put_em_slot(i, mask, 0, *child, buf); }, Self::Mdata { mdata, child } => { - put_u8(9, buf); + put_u8((EM_MDATA << 3) | mask, buf); put_mdata_stack_indexed(mdata, idx, buf)?; - put_u64(*child, buf); + put_em_slot(i, mask, 0, *child, buf); }, Self::CallSite { name, entries, canon_meta, orig_head } => { - put_u8(10, buf); + put_u8(EM_CALL_SITE << 3, buf); put_idx(name, idx, buf)?; - put_vec_len(entries.len(), buf); - for entry in entries { - match entry { - CallSiteEntry::Kept { canon_idx, meta } => { - put_u8(0, buf); - put_u64(*canon_idx, buf); - put_u64(*meta, buf); - }, - CallSiteEntry::Collapsed { sharing_idx, meta } => { - put_u8(1, buf); - put_u64(*sharing_idx, buf); - put_u64(*meta, buf); - }, - } - } - put_u64_vec(canon_meta, buf); + put_em_entries(i, entries, buf); + put_em_refs(i, canon_meta, buf); match orig_head { None => put_u8(0, buf), Some((sharing_idx, meta)) => { put_u8(1, buf); put_u64(*sharing_idx, buf); - put_u64(*meta, buf); + put_em_ref(i, *meta, buf); }, } }, @@ -1062,147 +1259,114 @@ impl ExprMetaData { canon_meta, wrapper_meta, } => { - put_u8(11, buf); + put_u8(EM_ETA_CALL_SITE << 3, buf); put_u64(*n_synth, buf); put_idx(name, idx, buf)?; - put_vec_len(entries.len(), buf); - for entry in entries { - match entry { - CallSiteEntry::Kept { canon_idx, meta } => { - put_u8(0, buf); - put_u64(*canon_idx, buf); - put_u64(*meta, buf); - }, - CallSiteEntry::Collapsed { sharing_idx, meta } => { - put_u8(1, buf); - put_u64(*sharing_idx, buf); - put_u64(*meta, buf); - }, - } - } - put_u64_vec(canon_meta, buf); - put_u64(*wrapper_meta, buf); + put_em_entries(i, entries, buf); + put_em_refs(i, canon_meta, buf); + put_em_ref(i, *wrapper_meta, buf); }, } Ok(()) } - pub fn get_with(buf: &mut &[u8], rev: NameGet<'_>) -> Result { - match get_u8(buf)? { - 0 => Ok(Self::Leaf), - 1 => { - let c0 = get_u64(buf)?; - let c1 = get_u64(buf)?; - Ok(Self::App { children: [c0, c1] }) + /// Read node `i`, given the block starts `lo[0..i]`; returns the node + /// and `lo[i]`. + fn get_node( + buf: &mut &[u8], + rev: NameGet<'_>, + i: u64, + lo: &[u64], + ) -> Result<(Self, u64), String> { + let tag = get_u8(buf)?; + let kind = tag >> 3; + let mask = tag & 7; + match em_slot_count(kind) { + Some(n) if u32::from(mask) < (1 << n) => {}, + _ => return Err(format!("ExprMetaData::get: invalid tag {tag}")), + } + let mut node = match kind { + EM_LEAF => Self::Leaf, + EM_APP => { + let c0 = get_em_slot(i, mask, 0, buf)?; + let c1 = get_em_slot(i, mask, 1, buf)?; + Self::App { children: [c0, c1] } }, - tag @ 2..=5 => { - let info = match tag { + 2..=5 => { + let info = match kind { 2 => BinderInfo::Default, 3 => BinderInfo::Implicit, 4 => BinderInfo::StrictImplicit, - 5 => BinderInfo::InstImplicit, - _ => unreachable!(), + _ => BinderInfo::InstImplicit, }; let name = get_idx(buf, rev)?; - let c0 = get_u64(buf)?; - let c1 = get_u64(buf)?; - Ok(Self::Binder { name, info, children: [c0, c1] }) - }, - 6 => { - let name = get_idx(buf, rev)?; - let c0 = get_u64(buf)?; - let c1 = get_u64(buf)?; - let c2 = get_u64(buf)?; - Ok(Self::LetBinder { name, children: [c0, c1, c2] }) + let c0 = get_em_slot(i, mask, 0, buf)?; + let c1 = get_em_slot(i, mask, 1, buf)?; + Self::Binder { name, info, children: [c0, c1] } }, - 7 => { + EM_LET => { let name = get_idx(buf, rev)?; - Ok(Self::Ref { name }) + let c0 = get_em_slot(i, mask, 0, buf)?; + let c1 = get_em_slot(i, mask, 1, buf)?; + let c2 = get_em_slot(i, mask, 2, buf)?; + Self::LetBinder { name, children: [c0, c1, c2] } }, - 8 => { + EM_REF => Self::Ref { name: get_idx(buf, rev)? }, + EM_PRJ => { let struct_name = get_idx(buf, rev)?; - let child = get_u64(buf)?; - Ok(Self::Prj { struct_name, child }) + let child = get_em_slot(i, mask, 0, buf)?; + Self::Prj { struct_name, child } }, - 9 => { + EM_MDATA => { let mdata = get_mdata_stack_indexed(buf, rev)?; - let child = get_u64(buf)?; - Ok(Self::Mdata { mdata, child }) + let child = get_em_slot(i, mask, 0, buf)?; + Self::Mdata { mdata, child } }, - 10 => { + EM_CALL_SITE => { let name = get_idx(buf, rev)?; - let n_entries = get_vec_len(buf)?; - let mut entries = Vec::with_capacity(n_entries); - for _ in 0..n_entries { - let entry = match get_u8(buf)? { - 0 => { - let canon_idx = get_u64(buf)?; - let meta = get_u64(buf)?; - CallSiteEntry::Kept { canon_idx, meta } - }, - 1 => { - let sharing_idx = get_u64(buf)?; - let meta = get_u64(buf)?; - CallSiteEntry::Collapsed { sharing_idx, meta } - }, - x => return Err(format!("CallSiteEntry::get: invalid tag {x}")), - }; - entries.push(entry); - } - let canon_meta = get_u64_vec(buf)?; + let entries = get_em_entries(i, buf)?; + let canon_meta = get_em_refs(i, buf)?; let orig_head = match get_u8(buf)? { 0 => None, 1 => { let sharing_idx = get_u64(buf)?; - let meta = get_u64(buf)?; + let meta = get_em_ref(i, buf)?; Some((sharing_idx, meta)) }, x => { return Err(format!("CallSite::get: invalid orig_head tag {x}")); }, }; - Ok(Self::CallSite { name, entries, canon_meta, orig_head }) + Self::CallSite { name, entries, canon_meta, orig_head } }, - 11 => { + _ => { let n_synth = get_u64(buf)?; let name = get_idx(buf, rev)?; - let n_entries = get_vec_len(buf)?; - let mut entries = Vec::with_capacity(n_entries); - for _ in 0..n_entries { - let entry = match get_u8(buf)? { - 0 => { - let canon_idx = get_u64(buf)?; - let meta = get_u64(buf)?; - CallSiteEntry::Kept { canon_idx, meta } - }, - 1 => { - let sharing_idx = get_u64(buf)?; - let meta = get_u64(buf)?; - CallSiteEntry::Collapsed { sharing_idx, meta } - }, - x => return Err(format!("CallSiteEntry::get: invalid tag {x}")), - }; - entries.push(entry); - } - let canon_meta = get_u64_vec(buf)?; - let wrapper_meta = get_u64(buf)?; - Ok(Self::EtaCallSite { - n_synth, - name, - entries, - canon_meta, - wrapper_meta, - }) + let entries = get_em_entries(i, buf)?; + let canon_meta = get_em_refs(i, buf)?; + let wrapper_meta = get_em_ref(i, buf)?; + Self::EtaCallSite { n_synth, name, entries, canon_meta, wrapper_meta } }, - x => Err(format!("ExprMetaData::get: invalid tag {x}")), - } + }; + let top = match &mut node { + Self::App { children } | Self::Binder { children, .. } => { + em_resolve_slots(children, mask, i, lo)? + }, + Self::LetBinder { children, .. } => { + em_resolve_slots(children, mask, i, lo)? + }, + Self::Prj { child, .. } | Self::Mdata { child, .. } => { + em_resolve_slots(std::slice::from_mut(child), mask, i, lo)? + }, + Self::Leaf + | Self::Ref { .. } + | Self::CallSite { .. } + | Self::EtaCallSite { .. } => i, + }; + Ok((node, top)) } } -// =========================================================================== -// ExprMeta (arena) indexed serialization -// =========================================================================== - impl ExprMeta { pub fn put_with( &self, @@ -1210,17 +1374,26 @@ impl ExprMeta { buf: &mut Vec, ) -> Result<(), String> { put_vec_len(self.nodes.len(), buf); - for node in &self.nodes { - node.put_with(idx, buf)?; + let mut lo: Vec = Vec::with_capacity(self.nodes.len()); + for (i, node) in self.nodes.iter().enumerate() { + let i = i as u64; + let (mask, top) = em_implicit_mask(node, i, &lo); + node.put_node(i, mask, idx, buf)?; + lo.push(top); } Ok(()) } pub fn get_with(buf: &mut &[u8], rev: NameGet<'_>) -> Result { let len = get_vec_len(buf)?; - let mut nodes = Vec::with_capacity(len); - for _ in 0..len { - nodes.push(ExprMetaData::get_with(buf, rev)?); + // Every node takes at least one byte. + let cap = len.min(buf.len()); + let mut nodes = Vec::with_capacity(cap); + let mut lo: Vec = Vec::with_capacity(cap); + for i in 0..len { + let (node, top) = ExprMetaData::get_node(buf, rev, i as u64, &lo)?; + nodes.push(node); + lo.push(top); } Ok(ExprMeta { nodes }) } @@ -1324,7 +1497,7 @@ impl ConstantMetaInfo { } // Option: 0 tag = None, 1 tag = Some(perm_vec, // ctor_vec, evaporated_vec). The usize vecs are written as - // Vec via Tag0 so the serialized form is target-word-size + // Vec via TagN so the serialized form is target-word-size // independent; `evaporated` is one u8 (0/1) per entry. match aux_layout { None => put_u8(0, buf), @@ -1589,4 +1762,214 @@ mod tests { ExprMeta::get_with(&mut buf.as_slice(), NameGet::Indexed(&rev)).unwrap(); assert_eq!(arena, recovered); } + + /// Names for the arena byte vectors: index 0 and 1 (one-byte indices in + /// every integer code). + fn vec_names() -> (Address, Address, NameIndex, NameReverseIndex) { + let a = Address::from_slice(&[1u8; 32]).unwrap(); + let b = Address::from_slice(&[2u8; 32]).unwrap(); + let mut idx = NameIndex::new(); + idx.insert(a.clone(), 0); + idx.insert(b.clone(), 1); + (a.clone(), b.clone(), idx, vec![a, b]) + } + + fn arena_bytes(arena: &ExprMeta, idx: &NameIndex) -> Vec { + let mut buf = Vec::new(); + arena.put_with(NamePut::Indexed(idx), &mut buf).unwrap(); + buf + } + + fn arena_from( + bytes: &[u8], + rev: &NameReverseIndex, + ) -> Result { + let mut slice = bytes; + let arena = ExprMeta::get_with(&mut slice, NameGet::Indexed(rev))?; + assert!(slice.is_empty(), "trailing bytes"); + Ok(arena) + } + + /// Check `arena` against its expected bytes in both directions. + fn check_vector(arena: &ExprMeta, bytes: &[u8]) { + let (_, _, idx, rev) = vec_names(); + assert_eq!(arena_bytes(arena, &idx), bytes); + assert_eq!(&arena_from(bytes, &rev).unwrap(), arena); + } + + /// A post-order tree (`fun (x : T) => f x`): every child is implicit and + /// no reference is written. + #[test] + fn arena_vector_post_order_tree() { + let (f, t, _, _) = vec_names(); + let arena = ExprMeta { + nodes: vec![ + ExprMetaData::Ref { name: t }, + ExprMetaData::Ref { name: f.clone() }, + ExprMetaData::Leaf, + ExprMetaData::App { children: [1, 2] }, + ExprMetaData::Binder { + name: f, + info: BinderInfo::Default, + children: [0, 3], + }, + ], + }; + check_vector( + &arena, + &[0x05, 0x38, 0x01, 0x38, 0x00, 0x00, 0x0B, 0x13, 0x00], + ); + } + + /// Shared nodes: explicit backward deltas next to implicit slots. + #[test] + fn arena_vector_dag() { + let (a, b, _, _) = vec_names(); + let arena = ExprMeta { + nodes: vec![ + ExprMetaData::Leaf, + // arg implicit (node 0); fun explicit: Δ = 1 - 1 - 0 = 0. + ExprMetaData::App { children: [0, 0] }, + // value implicit (node 1); type and body explicit (Δ = 1). + ExprMetaData::LetBinder { name: a, children: [0, 1, 0] }, + // child 1 is not the cursor (2): explicit, Δ = 1. + ExprMetaData::Prj { struct_name: b, child: 1 }, + ExprMetaData::Mdata { mdata: vec![], child: 3 }, + ], + }; + check_vector( + &arena, + &[ + 0x05, 0x00, 0x0A, 0x00, 0x32, 0x00, 0x01, 0x01, 0x40, 0x01, 0x01, 0x49, + 0x00, + ], + ); + } + + /// Call-site references are always explicit; a forward reference wraps + /// to a 9-byte TagN delta. + #[test] + fn arena_vector_call_sites_and_forward() { + let (a, b, _, _) = vec_names(); + let arena = ExprMeta { + nodes: vec![ + ExprMetaData::Leaf, + ExprMetaData::CallSite { + name: a.clone(), + entries: vec![ + CallSiteEntry::Kept { canon_idx: 0, meta: 0 }, + CallSiteEntry::Collapsed { sharing_idx: 1, meta: 0 }, + ], + canon_meta: vec![0], + orig_head: Some((2, 0)), + }, + ExprMetaData::EtaCallSite { + n_synth: 1, + name: b, + entries: vec![CallSiteEntry::Kept { canon_idx: 0, meta: 1 }], + canon_meta: vec![1], + wrapper_meta: 1, + }, + // Δ = 3 - 1 - 7 wraps to 2^64 - 5. + ExprMetaData::Prj { struct_name: a, child: 7 }, + ], + }; + check_vector( + &arena, + &[ + 0x04, 0x00, // leaf + 0x50, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, + 0x02, 0x00, // callSite + 0x58, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, // eta + 0x40, 0x00, 0xC3, 0x7B, 0xBF, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, + 0xFF, // prj (TagN f = 0 rung 6: 2^64 - 5 - R5 = 0xFFFFFFFE_FEFEBF7B) + ], + ); + } + + /// The reader accepts exactly the writer's encoding. + #[test] + fn arena_rejects_noncanonical() { + let (_, _, _, rev) = vec_names(); + // App with both slots explicit, the argument at the implicit position. + assert!(arena_from(&[0x02, 0x00, 0x08, 0x00, 0x00], &rev).is_err()); + // Implicit slot with no preceding node. + assert!(arena_from(&[0x01, 0x09, 0x00], &rev).is_err()); + // Mask bits beyond the kind's slots, and unknown kinds. + assert!(arena_from(&[0x01, 0x01], &rev).is_err()); + assert!(arena_from(&[0x02, 0x00, 0x0C], &rev).is_err()); + assert!(arena_from(&[0x01, 0x39, 0x00], &rev).is_err()); + assert!(arena_from(&[0x01, 0x60], &rev).is_err()); + // The same arenas, written canonically, are accepted. + assert!(arena_from(&[0x02, 0x00, 0x0A, 0x00], &rev).is_ok()); + } + + /// Pseudo-random arenas (every kind, arbitrary references including + /// forward and self references) roundtrip, and re-encoding the decoded + /// arena reproduces the bytes. + #[test] + fn arena_random_roundtrip() { + let (a, b, idx, rev) = vec_names(); + let mut s: u64 = 0x9E37_79B9_7F4A_7C15; + let mut next = |m: u64| { + s = s.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1); + (s >> 33) % m + }; + for _ in 0..2000 { + let n = next(24); + let mut nodes = Vec::new(); + for i in 0..n { + // Mostly post-order-ish (just below), sometimes anywhere. + let r = |next: &mut dyn FnMut(u64) -> u64| match next(4) { + 0 => next(n + 2), + _ => i.saturating_sub(1 + next(3)), + }; + let name = if next(2) == 0 { a.clone() } else { b.clone() }; + let node = match next(9) { + 0 => ExprMetaData::Leaf, + 1 => ExprMetaData::App { children: [r(&mut next), r(&mut next)] }, + 2 => ExprMetaData::Binder { + name, + info: BinderInfo::InstImplicit, + children: [r(&mut next), r(&mut next)], + }, + 3 => ExprMetaData::LetBinder { + name, + children: [r(&mut next), r(&mut next), r(&mut next)], + }, + 4 => ExprMetaData::Ref { name }, + 5 => ExprMetaData::Prj { struct_name: name, child: r(&mut next) }, + 6 => ExprMetaData::Mdata { + mdata: vec![vec![(name, DataValue::OfBool(true))]], + child: r(&mut next), + }, + 7 => ExprMetaData::CallSite { + name, + entries: vec![CallSiteEntry::Kept { + canon_idx: 3, + meta: r(&mut next), + }], + canon_meta: vec![r(&mut next), r(&mut next)], + orig_head: Some((4, r(&mut next))), + }, + _ => ExprMetaData::EtaCallSite { + n_synth: 2, + name, + entries: vec![CallSiteEntry::Collapsed { + sharing_idx: 5, + meta: r(&mut next), + }], + canon_meta: vec![], + wrapper_meta: r(&mut next), + }, + }; + nodes.push(node); + } + let arena = ExprMeta { nodes }; + let bytes = arena_bytes(&arena, &idx); + let back = arena_from(&bytes, &rev).unwrap(); + assert_eq!(back, arena); + assert_eq!(arena_bytes(&back, &idx), bytes); + } + } } diff --git a/crates/ixon/src/proof.rs b/crates/ixon/src/proof.rs index 05a27e702..4c5ab6f9b 100644 --- a/crates/ixon/src/proof.rs +++ b/crates/ixon/src/proof.rs @@ -3,7 +3,7 @@ //! Claims assert properties about committed constants (type-checking, evaluation, //! or selective field revelation). Proofs pair a claim with opaque proof bytes. //! -//! `RevealConstantInfo` uses bitmask-based serialization: a mask (Tag0) encodes +//! `RevealConstantInfo` uses bitmask-based serialization: a mask (TagN) encodes //! which fields are present, followed by only the present field values in bit //! order. This enables revealing specific fields of a committed constant without //! exposing the full structure. @@ -12,7 +12,8 @@ use ix_common::address::Address; use ix_common::env::{DefinitionSafety, QuotKind}; use super::constant::DefKind; -use super::tag::{Tag0, Tag4}; +use super::env::Env; +use super::tag::TagN; // ============================================================================ // Reveal info types (per-variant selective-field structures) @@ -188,18 +189,15 @@ pub struct Proof { } // ============================================================================ -// Tag4 variant layout for flags 0xE (data + claims) and 0xF (proofs) +// TagN variant layout for flags 0xE (data + claims) and 0xF (proofs) // ============================================================================ -/// Tag4 flag for envs, commitments, AssumptionTree, and claims (0xE). +/// TagN flag for commitments, AssumptionTree, and claims (0xE). /// -/// Variants 0–7 fit in single-byte tags (`0xE0`–`0xE7`) and are all -/// taken. Variant 8 (Catalog) is the first — and so far only — -/// multi-byte tag under 0xE: it encodes as `0xE8 0x08` (large bit set, -/// one size byte). `docs/Ixon.md`'s single-byte-tag note carries the -/// exception. +/// The header is `TagN(4, 0xE, variant)`. Variants 0–7 are in rung 1, the +/// single bytes `0xE0`–`0xE7`; from 8 on the header is two bytes (rung 2), +/// so Catalog is `E8 00` and Resource `E8 01`. /// -/// - 0: Env (on-disk env serialization) /// - 1: Comm (commitment, handled in `comm.rs`) /// - 2: AssumptionTree (recursive merkle-tree data, see `assumption_tree.rs`) /// - 3: Eval claim @@ -207,10 +205,15 @@ pub struct Proof { /// - 5: CheckEnv claim /// - 6: Reveal claim /// - 7: Contains claim -/// - 8: Catalog claim (2-byte tag `0xE8 0x08`) +/// - 8: Catalog claim (`E8 00`) +/// - 9: Resource claim (`E8 01`) +/// +/// The `.ixe` header also uses flag 0xE, with the format version as the +/// value (`Env::VERSION`): version 4 is the byte `0xE4`, the same byte as +/// the Check claim tag. Readers know which object they read; nothing +/// dispatches on the first byte. pub const FLAG_CLAIM: u8 = 0xE; -pub const VARIANT_ENV: u64 = 0; // VARIANT 1 = Comm (handled in comm.rs) pub const VARIANT_ASSUMPTION_TREE: u64 = 2; pub const VARIANT_EVAL_CLAIM: u64 = 3; @@ -221,8 +224,8 @@ pub const VARIANT_CONTAINS_CLAIM: u64 = 7; pub const VARIANT_CATALOG_CLAIM: u64 = 8; pub const VARIANT_RESOURCE_CLAIM: u64 = 9; -/// Tag4 flag for ZK proofs (0xF). All variants in single-byte tags -/// (`0xF0`–`0xF5`). Slots 6-7 reserved for future proof variants. +/// TagN flag for ZK proofs (0xF). Every variant is in rung 1, a single-byte +/// tag (`0xF0`–`0xF6`); slot 7 (`0xF7`) is the last free single byte. /// /// Proof bytes are uniform opaque ZK proofs — witness data (e.g., /// merkle paths for Contains) is prover-side scratch consumed by the @@ -234,6 +237,7 @@ pub const VARIANT_RESOURCE_CLAIM: u64 = 9; /// - 3: Reveal proof /// - 4: Contains proof /// - 5: Catalog proof +/// - 6: Resource proof pub const FLAG_PROOF: u8 = 0xF; pub const VARIANT_EVAL_PROOF: u64 = 0; @@ -350,7 +354,7 @@ fn get_bool_field(buf: &mut &[u8]) -> Result { // ============================================================================ impl RevealConstructorInfo { - /// Serialize: mask (Tag0) + field values in mask order. + /// Serialize: mask (TagN) + field values in mask order. pub fn put(&self, buf: &mut Vec) { let mask = compute_mask(&[ self.is_unsafe.is_some(), @@ -360,21 +364,21 @@ impl RevealConstructorInfo { self.fields.is_some(), self.typ.is_some(), ]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(u) = self.is_unsafe { put_bool_field(u, buf); } if let Some(l) = self.lvls { - Tag0::new(l).put(buf); + TagN::put(0, 0, l, buf); } if let Some(c) = self.cidx { - Tag0::new(c).put(buf); + TagN::put(0, 0, c, buf); } if let Some(p) = self.params { - Tag0::new(p).put(buf); + TagN::put(0, 0, p, buf); } if let Some(f) = self.fields { - Tag0::new(f).put(buf); + TagN::put(0, 0, f, buf); } if let Some(t) = &self.typ { buf.extend_from_slice(t.as_bytes()); @@ -382,13 +386,17 @@ impl RevealConstructorInfo { } pub fn get(buf: &mut &[u8]) -> Result { - let mask = Tag0::get(buf)?.size; + let mask = TagN::get(0, buf)?.value; let is_unsafe = if mask & 1 != 0 { Some(get_bool_field(buf)?) } else { None }; - let lvls = if mask & 2 != 0 { Some(Tag0::get(buf)?.size) } else { None }; - let cidx = if mask & 4 != 0 { Some(Tag0::get(buf)?.size) } else { None }; - let params = if mask & 8 != 0 { Some(Tag0::get(buf)?.size) } else { None }; - let fields = if mask & 16 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + let lvls = + if mask & 2 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; + let cidx = + if mask & 4 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; + let params = + if mask & 8 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; + let fields = + if mask & 16 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let typ = if mask & 32 != 0 { Some(get_address(buf)?) } else { None }; Ok(RevealConstructorInfo { is_unsafe, lvls, cidx, params, fields, typ }) } @@ -400,14 +408,14 @@ impl RevealConstructorInfo { impl RevealRecursorRule { pub fn put(&self, buf: &mut Vec) { - Tag0::new(self.rule_idx).put(buf); - Tag0::new(self.fields).put(buf); + TagN::put(0, 0, self.rule_idx, buf); + TagN::put(0, 0, self.fields, buf); buf.extend_from_slice(self.rhs.as_bytes()); } pub fn get(buf: &mut &[u8]) -> Result { - let rule_idx = Tag0::get(buf)?.size; - let fields = Tag0::get(buf)?.size; + let rule_idx = TagN::get(0, buf)?.value; + let fields = TagN::get(0, buf)?.value; let rhs = get_address(buf)?; Ok(RevealRecursorRule { rule_idx, fields, rhs }) } @@ -418,7 +426,7 @@ impl RevealRecursorRule { // ============================================================================ fn put_rules(rules: &[RevealRecursorRule], buf: &mut Vec) { - Tag0::new(rules.len() as u64).put(buf); + TagN::put(0, 0, rules.len() as u64, buf); for rule in rules { rule.put(buf); } @@ -426,7 +434,7 @@ fn put_rules(rules: &[RevealRecursorRule], buf: &mut Vec) { fn get_rules(buf: &mut &[u8]) -> Result, String> { let count = - usize::try_from(Tag0::get(buf)?.size).map_err(|e| e.to_string())?; + usize::try_from(TagN::get(0, buf)?.value).map_err(|e| e.to_string())?; let mut rules = Vec::with_capacity(count); for _ in 0..count { rules.push(RevealRecursorRule::get(buf)?); @@ -435,9 +443,9 @@ fn get_rules(buf: &mut &[u8]) -> Result, String> { } fn put_ctors(ctors: &[(u64, RevealConstructorInfo)], buf: &mut Vec) { - Tag0::new(ctors.len() as u64).put(buf); + TagN::put(0, 0, ctors.len() as u64, buf); for (idx, info) in ctors { - Tag0::new(*idx).put(buf); + TagN::put(0, 0, *idx, buf); info.put(buf); } } @@ -446,10 +454,10 @@ fn get_ctors( buf: &mut &[u8], ) -> Result, String> { let count = - usize::try_from(Tag0::get(buf)?.size).map_err(|e| e.to_string())?; + usize::try_from(TagN::get(0, buf)?.value).map_err(|e| e.to_string())?; let mut ctors = Vec::with_capacity(count); for _ in 0..count { - let idx = Tag0::get(buf)?.size; + let idx = TagN::get(0, buf)?.value; let info = RevealConstructorInfo::get(buf)?; ctors.push((idx, info)); } @@ -472,7 +480,7 @@ impl RevealMutConstInfo { typ.is_some(), value.is_some(), ]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(k) = kind { put_def_kind(*k, buf); } @@ -480,7 +488,7 @@ impl RevealMutConstInfo { put_def_safety(*s, buf); } if let Some(l) = lvls { - Tag0::new(*l).put(buf); + TagN::put(0, 0, *l, buf); } if let Some(t) = typ { buf.extend_from_slice(t.as_bytes()); @@ -499,18 +507,18 @@ impl RevealMutConstInfo { typ.is_some(), ctors.is_some(), ]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(u) = is_unsafe { put_bool_field(*u, buf); } if let Some(l) = lvls { - Tag0::new(*l).put(buf); + TagN::put(0, 0, *l, buf); } if let Some(p) = params { - Tag0::new(*p).put(buf); + TagN::put(0, 0, *p, buf); } if let Some(i) = indices { - Tag0::new(*i).put(buf); + TagN::put(0, 0, *i, buf); } if let Some(t) = typ { buf.extend_from_slice(t.as_bytes()); @@ -542,7 +550,7 @@ impl RevealMutConstInfo { typ.is_some(), rules.is_some(), ]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(k) = k { put_bool_field(*k, buf); } @@ -550,19 +558,19 @@ impl RevealMutConstInfo { put_bool_field(*u, buf); } if let Some(l) = lvls { - Tag0::new(*l).put(buf); + TagN::put(0, 0, *l, buf); } if let Some(p) = params { - Tag0::new(*p).put(buf); + TagN::put(0, 0, *p, buf); } if let Some(i) = indices { - Tag0::new(*i).put(buf); + TagN::put(0, 0, *i, buf); } if let Some(m) = motives { - Tag0::new(*m).put(buf); + TagN::put(0, 0, *m, buf); } if let Some(m) = minors { - Tag0::new(*m).put(buf); + TagN::put(0, 0, *m, buf); } if let Some(t) = typ { buf.extend_from_slice(t.as_bytes()); @@ -576,14 +584,14 @@ impl RevealMutConstInfo { pub fn get(buf: &mut &[u8]) -> Result { let variant = get_u8(buf)?; - let mask = Tag0::get(buf)?.size; + let mask = TagN::get(0, buf)?.value; match variant { 0 => { let kind = if mask & 1 != 0 { Some(get_def_kind(buf)?) } else { None }; let safety = if mask & 2 != 0 { Some(get_def_safety(buf)?) } else { None }; let lvls = - if mask & 4 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 4 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let typ = if mask & 8 != 0 { Some(get_address(buf)?) } else { None }; let value = if mask & 16 != 0 { Some(get_address(buf)?) } else { None }; Ok(Self::Defn { kind, safety, lvls, typ, value }) @@ -592,11 +600,11 @@ impl RevealMutConstInfo { let is_unsafe = if mask & 1 != 0 { Some(get_bool_field(buf)?) } else { None }; let lvls = - if mask & 2 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 2 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let params = - if mask & 4 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 4 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let indices = - if mask & 8 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 8 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let typ = if mask & 16 != 0 { Some(get_address(buf)?) } else { None }; let ctors = if mask & 32 != 0 { Some(get_ctors(buf)?) } else { None }; Ok(Self::Indc { is_unsafe, lvls, params, indices, typ, ctors }) @@ -606,15 +614,15 @@ impl RevealMutConstInfo { let is_unsafe = if mask & 2 != 0 { Some(get_bool_field(buf)?) } else { None }; let lvls = - if mask & 4 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 4 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let params = - if mask & 8 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 8 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let indices = - if mask & 16 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 16 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let motives = - if mask & 32 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 32 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let minors = - if mask & 64 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 64 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let typ = if mask & 128 != 0 { Some(get_address(buf)?) } else { None }; let rules = if mask & 256 != 0 { Some(get_rules(buf)?) } else { None }; Ok(Self::Recr { @@ -639,7 +647,7 @@ impl RevealMutConstInfo { // ============================================================================ impl RevealConstantInfo { - /// Serialize: variant byte + mask (Tag0) + field values in mask order. + /// Serialize: variant byte + mask (TagN) + field values in mask order. pub fn put(&self, buf: &mut Vec) { match self { Self::Defn { kind, safety, lvls, typ, value } => { @@ -651,7 +659,7 @@ impl RevealConstantInfo { typ.is_some(), value.is_some(), ]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(k) = kind { put_def_kind(*k, buf); } @@ -659,7 +667,7 @@ impl RevealConstantInfo { put_def_safety(*s, buf); } if let Some(l) = lvls { - Tag0::new(*l).put(buf); + TagN::put(0, 0, *l, buf); } if let Some(t) = typ { buf.extend_from_slice(t.as_bytes()); @@ -691,7 +699,7 @@ impl RevealConstantInfo { typ.is_some(), rules.is_some(), ]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(k) = k { put_bool_field(*k, buf); } @@ -699,19 +707,19 @@ impl RevealConstantInfo { put_bool_field(*u, buf); } if let Some(l) = lvls { - Tag0::new(*l).put(buf); + TagN::put(0, 0, *l, buf); } if let Some(p) = params { - Tag0::new(*p).put(buf); + TagN::put(0, 0, *p, buf); } if let Some(i) = indices { - Tag0::new(*i).put(buf); + TagN::put(0, 0, *i, buf); } if let Some(m) = motives { - Tag0::new(*m).put(buf); + TagN::put(0, 0, *m, buf); } if let Some(m) = minors { - Tag0::new(*m).put(buf); + TagN::put(0, 0, *m, buf); } if let Some(t) = typ { buf.extend_from_slice(t.as_bytes()); @@ -724,12 +732,12 @@ impl RevealConstantInfo { buf.push(2); let mask = compute_mask(&[is_unsafe.is_some(), lvls.is_some(), typ.is_some()]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(u) = is_unsafe { put_bool_field(*u, buf); } if let Some(l) = lvls { - Tag0::new(*l).put(buf); + TagN::put(0, 0, *l, buf); } if let Some(t) = typ { buf.extend_from_slice(t.as_bytes()); @@ -739,12 +747,12 @@ impl RevealConstantInfo { buf.push(3); let mask = compute_mask(&[kind.is_some(), lvls.is_some(), typ.is_some()]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(k) = kind { put_quot_kind(*k, buf); } if let Some(l) = lvls { - Tag0::new(*l).put(buf); + TagN::put(0, 0, *l, buf); } if let Some(t) = typ { buf.extend_from_slice(t.as_bytes()); @@ -754,12 +762,12 @@ impl RevealConstantInfo { buf.push(4); let mask = compute_mask(&[idx.is_some(), cidx.is_some(), block.is_some()]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(i) = idx { - Tag0::new(*i).put(buf); + TagN::put(0, 0, *i, buf); } if let Some(c) = cidx { - Tag0::new(*c).put(buf); + TagN::put(0, 0, *c, buf); } if let Some(b) = block { buf.extend_from_slice(b.as_bytes()); @@ -768,9 +776,9 @@ impl RevealConstantInfo { Self::RPrj { idx, block } => { buf.push(5); let mask = compute_mask(&[idx.is_some(), block.is_some()]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(i) = idx { - Tag0::new(*i).put(buf); + TagN::put(0, 0, *i, buf); } if let Some(b) = block { buf.extend_from_slice(b.as_bytes()); @@ -779,9 +787,9 @@ impl RevealConstantInfo { Self::IPrj { idx, block } => { buf.push(6); let mask = compute_mask(&[idx.is_some(), block.is_some()]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(i) = idx { - Tag0::new(*i).put(buf); + TagN::put(0, 0, *i, buf); } if let Some(b) = block { buf.extend_from_slice(b.as_bytes()); @@ -790,9 +798,9 @@ impl RevealConstantInfo { Self::DPrj { idx, block } => { buf.push(7); let mask = compute_mask(&[idx.is_some(), block.is_some()]); - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if let Some(i) = idx { - Tag0::new(*i).put(buf); + TagN::put(0, 0, *i, buf); } if let Some(b) = block { buf.extend_from_slice(b.as_bytes()); @@ -801,11 +809,11 @@ impl RevealConstantInfo { Self::Muts { components } => { buf.push(8); let mask: u64 = if components.is_empty() { 0 } else { 1 }; - Tag0::new(mask).put(buf); + TagN::put(0, 0, mask, buf); if !components.is_empty() { - Tag0::new(components.len() as u64).put(buf); + TagN::put(0, 0, components.len() as u64, buf); for (idx, info) in components { - Tag0::new(*idx).put(buf); + TagN::put(0, 0, *idx, buf); info.put(buf); } } @@ -815,7 +823,7 @@ impl RevealConstantInfo { pub fn get(buf: &mut &[u8]) -> Result { let variant = get_u8(buf)?; - let mask = Tag0::get(buf)?.size; + let mask = TagN::get(0, buf)?.value; match variant { 0 => { // Defn @@ -823,7 +831,7 @@ impl RevealConstantInfo { let safety = if mask & 2 != 0 { Some(get_def_safety(buf)?) } else { None }; let lvls = - if mask & 4 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 4 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let typ = if mask & 8 != 0 { Some(get_address(buf)?) } else { None }; let value = if mask & 16 != 0 { Some(get_address(buf)?) } else { None }; Ok(Self::Defn { kind, safety, lvls, typ, value }) @@ -834,15 +842,15 @@ impl RevealConstantInfo { let is_unsafe = if mask & 2 != 0 { Some(get_bool_field(buf)?) } else { None }; let lvls = - if mask & 4 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 4 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let params = - if mask & 8 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 8 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let indices = - if mask & 16 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 16 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let motives = - if mask & 32 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 32 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let minors = - if mask & 64 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 64 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let typ = if mask & 128 != 0 { Some(get_address(buf)?) } else { None }; let rules = if mask & 256 != 0 { Some(get_rules(buf)?) } else { None }; Ok(Self::Recr { @@ -862,7 +870,7 @@ impl RevealConstantInfo { let is_unsafe = if mask & 1 != 0 { Some(get_bool_field(buf)?) } else { None }; let lvls = - if mask & 2 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 2 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let typ = if mask & 4 != 0 { Some(get_address(buf)?) } else { None }; Ok(Self::Axio { is_unsafe, lvls, typ }) }, @@ -870,44 +878,48 @@ impl RevealConstantInfo { // Quot let kind = if mask & 1 != 0 { Some(get_quot_kind(buf)?) } else { None }; let lvls = - if mask & 2 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 2 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let typ = if mask & 4 != 0 { Some(get_address(buf)?) } else { None }; Ok(Self::Quot { kind, lvls, typ }) }, 4 => { // CPrj - let idx = if mask & 1 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + let idx = + if mask & 1 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let cidx = - if mask & 2 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 2 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let block = if mask & 4 != 0 { Some(get_address(buf)?) } else { None }; Ok(Self::CPrj { idx, cidx, block }) }, 5 => { // RPrj - let idx = if mask & 1 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + let idx = + if mask & 1 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let block = if mask & 2 != 0 { Some(get_address(buf)?) } else { None }; Ok(Self::RPrj { idx, block }) }, 6 => { // IPrj - let idx = if mask & 1 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + let idx = + if mask & 1 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let block = if mask & 2 != 0 { Some(get_address(buf)?) } else { None }; Ok(Self::IPrj { idx, block }) }, 7 => { // DPrj - let idx = if mask & 1 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + let idx = + if mask & 1 != 0 { Some(TagN::get(0, buf)?.value) } else { None }; let block = if mask & 2 != 0 { Some(get_address(buf)?) } else { None }; Ok(Self::DPrj { idx, block }) }, 8 => { // Muts let components = if mask & 1 != 0 { - let count = - usize::try_from(Tag0::get(buf)?.size).map_err(|e| e.to_string())?; + let count = usize::try_from(TagN::get(0, buf)?.value) + .map_err(|e| e.to_string())?; let mut comps = Vec::with_capacity(count); for _ in 0..count { - let idx = Tag0::get(buf)?.size; + let idx = TagN::get(0, buf)?.value; let info = RevealMutConstInfo::get(buf)?; comps.push((idx, info)); } @@ -955,11 +967,16 @@ fn validator_for_variant(variant: u64) -> u8 { } } fn put_scope(validator: u8, buf: &mut Vec) { - buf.extend_from_slice(&[3, validator]); + buf.extend_from_slice(&[Env::OBJECT_FORMAT, validator]); } fn get_scope(validator: u8, buf: &mut &[u8]) -> Result<(), String> { - if get_u8(buf)? != 3 { - return Err("claim: unsupported object format".into()); + let format = get_u8(buf)?; + if format != Env::OBJECT_FORMAT { + return Err(format!( + "claim: unsupported object format {format}, expected {} — regenerate \ + the claim", + Env::OBJECT_FORMAT + )); } if get_u8(buf)? != validator { return Err("claim: wrong validator identity".into()); @@ -969,7 +986,7 @@ fn get_scope(validator: u8, buf: &mut &[u8]) -> Result<(), String> { impl Claim { pub fn put(&self, buf: &mut Vec) { - Tag4::new(FLAG_CLAIM, self.proof_variant_size() + 3).put(buf); + TagN::put(4, FLAG_CLAIM, self.proof_variant_size() + 3, buf); put_scope(validator_for_variant(self.proof_variant_size() + 3), buf); match self { Claim::Eval { input, output, assumptions } => { @@ -994,7 +1011,7 @@ impl Claim { buf.extend_from_slice(const_addr.as_bytes()); }, Claim::Catalog { members, content, assumptions } => { - // First multi-byte claim tag: 0xE8 0x08 on the wire. + // A two-byte claim tag: `E8 00` on the wire. buf.extend_from_slice(members.as_bytes()); buf.extend_from_slice(content.as_bytes()); put_opt_addr(assumptions, buf); @@ -1007,15 +1024,15 @@ impl Claim { } pub fn get(buf: &mut &[u8]) -> Result { - let tag = Tag4::get(buf)?; + let tag = TagN::get(4, buf)?; if tag.flag != FLAG_CLAIM { return Err(format!( "Claim::get: expected flag 0x{:X}, got 0x{:X}", FLAG_CLAIM, tag.flag )); } - get_scope(validator_for_variant(tag.size), buf)?; - match tag.size { + get_scope(validator_for_variant(tag.value), buf)?; + match tag.value { VARIANT_EVAL_CLAIM => { let input = get_address(buf)?; let output = get_address(buf)?; @@ -1102,7 +1119,7 @@ impl Proof { let proof_size = self.claim.proof_variant_size(); // Proofs live under flag 0xF; claim payload is the same body as the // matching Claim variant. - Tag4::new(FLAG_PROOF, proof_size).put(buf); + TagN::put(4, FLAG_PROOF, proof_size, buf); put_scope(validator_for_variant(proof_size + 3), buf); match &self.claim { Claim::Eval { input, output, assumptions } => { @@ -1137,20 +1154,20 @@ impl Proof { }, } // Opaque ZK proof bytes: length prefix + data - Tag0::new(self.proof.len() as u64).put(buf); + TagN::put(0, 0, self.proof.len() as u64, buf); buf.extend_from_slice(&self.proof); } pub fn get(buf: &mut &[u8]) -> Result { - let tag = Tag4::get(buf)?; + let tag = TagN::get(4, buf)?; if tag.flag != FLAG_PROOF { return Err(format!( "Proof::get: expected flag 0x{:X}, got 0x{:X}", FLAG_PROOF, tag.flag )); } - get_scope(validator_for_variant(tag.size.wrapping_add(3)), buf)?; - let claim = match tag.size { + get_scope(validator_for_variant(tag.value.wrapping_add(3)), buf)?; + let claim = match tag.value { VARIANT_EVAL_PROOF => { let input = get_address(buf)?; let output = get_address(buf)?; @@ -1194,8 +1211,8 @@ impl Proof { }; // Opaque ZK proof bytes - let len = usize::try_from(Tag0::get(buf)?.size) - .map_err(|_e| "Proof::get: Tag0 size overflows usize".to_string())?; + let len = usize::try_from(TagN::get(0, buf)?.value) + .map_err(|_e| "Proof::get: TagN size overflows usize".to_string())?; if buf.len() < len { return Err(format!( "Proof::get: need {} bytes for proof data, have {}", @@ -1493,7 +1510,7 @@ mod tests { /// The catalog claim's exact wire form is a cross-serializer /// commitment (the Rust↔Lean digest-parity gate pins the same bytes - /// from the Lean side): the first multi-byte claim tag `0xE8 0x08`, + /// from the Lean side): the first multi-byte claim tag, TagN `0xE8 0x00`, /// then members ‖ content ‖ opt-assumptions. A drift here changes /// every catalog digest. #[test] @@ -1507,7 +1524,7 @@ mod tests { assumptions: Some(asm.clone()), }; let (addr, bytes) = claim.commit(); - let mut expected = vec![0xE8, 0x08, 3, 1]; + let mut expected = vec![0xE8, 0x00, 4, 1]; expected.extend_from_slice(members.as_bytes()); expected.extend_from_slice(content.as_bytes()); expected.push(0x01); @@ -1519,7 +1536,7 @@ mod tests { // two serializers cannot drift on the large-tag path unnoticed. assert_eq!( addr.hex(), - "1ae7fec8efde892b6b540888df70d53977a264bbc84be300d4335ce04c916072", + "8c4fa4fa2e88fc73c72fbb624696485ec252c6685247541b40a59b221f83dbf4", "catalog claim digest drifted" ); // Unconditional form: trailing 0x00, same 2-byte tag. @@ -1527,7 +1544,7 @@ mod tests { let mut buf = Vec::new(); claim_none.put(&mut buf); assert_eq!(buf.len(), 2 + 2 + 32 + 32 + 1); - assert_eq!(&buf[0..2], &[0xE8, 0x08]); + assert_eq!(&buf[0..2], &[0xE8, 0x00]); assert_eq!(*buf.last().unwrap(), 0x00); // The proof wrapper stays a single-byte tag: 0xF5. let proof = Proof::new(claim_none, Vec::new()); @@ -1748,19 +1765,19 @@ mod tests { assert!(proof_roundtrip(&proof)); } - // ---------- Tag4 flag/size dispatch ---------- + // ---------- TagN flag/size dispatch ---------- - fn parse_tag(bytes: &[u8]) -> Tag4 { - Tag4::get(&mut &bytes[..]).unwrap() + fn parse_tag(bytes: &[u8]) -> TagN { + TagN::get(4, &mut &bytes[..]).unwrap() } - fn claim_tag(claim: &Claim) -> Tag4 { + fn claim_tag(claim: &Claim) -> TagN { let mut buf = Vec::new(); claim.put(&mut buf); parse_tag(&buf) } - fn proof_tag(proof: &Proof) -> Tag4 { + fn proof_tag(proof: &Proof) -> TagN { let mut buf = Vec::new(); proof.put(&mut buf); parse_tag(&buf) @@ -1801,7 +1818,7 @@ mod tests { for (claim, expected_size) in cases { let tag = claim_tag(&claim); assert_eq!(tag.flag, FLAG_CLAIM, "claim must use flag 0xE"); - assert_eq!(tag.size, expected_size); + assert_eq!(tag.value, expected_size); } } @@ -1841,7 +1858,7 @@ mod tests { let proof = Proof::new(claim, vec![0]); let tag = proof_tag(&proof); assert_eq!(tag.flag, FLAG_PROOF, "proof must use flag 0xF"); - assert_eq!(tag.size, expected_size); + assert_eq!(tag.value, expected_size); } } @@ -1859,7 +1876,7 @@ mod tests { let b = Address::hash(b"b"); let asm = Address::hash(b"asm"); - // Single-byte Tag4 + payload + 1 opt byte (+ 32 if Some). + // Single-byte TagN + payload + 1 opt byte (+ 32 if Some). assert_eq!( claim_bytes(&Claim::Eval { input: a.clone(), @@ -1910,7 +1927,7 @@ mod tests { #[test] fn test_claim_first_byte() { - // Single-byte Tag4 encoding: size 0-7 fits in one byte (0xE0..0xE7). + // Single-byte TagN encoding: size 0-7 fits in one byte (0xE0..0xE7). let a = Address::hash(b"a"); let b = Address::hash(b"b"); let reveal_info = RevealConstantInfo::Defn { @@ -1984,7 +2001,7 @@ mod tests { }; let mut buf = Vec::new(); claim.put(&mut buf); - assert_eq!(buf[0], 0xE6); // Tag4: flag=0xE, size=6 (Reveal claim) + assert_eq!(buf[0], 0xE6); // TagN f=4: flag=0xE, value=6 (Reveal claim) // buf[3..35] = comm_addr (32 bytes) assert_eq!(buf[35], 0x00); // RevealConstantInfo variant: Definition assert_eq!(buf[36], 0x02); // mask: bit 1 (safety) @@ -2038,8 +2055,8 @@ mod tests { assert_eq!(buf[0], 0xE6); assert_eq!(buf[35], 0x08); // RevealConstantInfo variant: Muts assert_eq!(buf[36], 0x01); // mask: bit 0 (components) - assert_eq!(buf[37], 0x01); // Tag0: 1 component revealed - assert_eq!(buf[38], 0x02); // Tag0: component index 2 + assert_eq!(buf[37], 0x01); // TagN f=0: 1 component revealed + assert_eq!(buf[38], 0x02); // TagN f=0: component index 2 assert_eq!(buf[39], 0x00); // RevealMutConstInfo variant: Definition assert_eq!(buf[40], 0x02); // mask: bit 1 (safety) assert_eq!(buf[41], 0x01); // DefinitionSafety::Safe @@ -2165,9 +2182,9 @@ mod tests { } } #[test] - fn v3_claim_fixtures_and_strict_scope() { + fn v4_claim_fixtures_and_strict_scope() { for line in - include_str!("../../../Tests/Fixtures/ixon-v3/claims.tsv").lines() + include_str!("../../../Tests/Fixtures/ixon-v4/claims.tsv").lines() { if line.starts_with('#') || line.is_empty() { continue; @@ -2194,11 +2211,23 @@ mod tests { assert!(Claim::from_bytes(&trailing).is_err()); let header = if claim.proof_variant_size() + 3 >= 8 { 2 } else { 1 }; let mut old_format = bytes.clone(); - old_format[header] = 2; - assert!(Claim::from_bytes(&old_format).is_err()); + old_format[header] = 3; + let err = Claim::from_bytes(&old_format).unwrap_err(); + assert!( + err.starts_with("claim: unsupported object format 3, expected 4"), + "{err}" + ); let mut wrong_validator = bytes.clone(); wrong_validator[header + 1] = 255; assert!(Claim::from_bytes(&wrong_validator).is_err()); + // A proof carries the same scope after its one-byte header (every + // proof variant is below 8): object format 3 is rejected there too. + let mut proof_bytes = Vec::new(); + Proof::new(claim.clone(), vec![1, 2, 3]).put(&mut proof_bytes); + assert_eq!(proof_bytes[1], Env::OBJECT_FORMAT); + proof_bytes[1] = 3; + let err = Proof::get(&mut proof_bytes.as_slice()).unwrap_err(); + assert!(err.contains("unsupported object format 3"), "{err}"); assert!(proof_roundtrip(&Proof::new(claim, vec![1, 2, 3]))); } } diff --git a/crates/ixon/src/resource.rs b/crates/ixon/src/resource.rs index 1f82de783..cc9d4a3ca 100644 --- a/crates/ixon/src/resource.rs +++ b/crates/ixon/src/resource.rs @@ -1,4 +1,4 @@ -//! Resource checking for Ixon v3. Mirrors `Ix/Resource/{Basic,Check}.lean`. +//! Resource checking for Ixon. Mirrors `Ix/Resource/{Basic,Check}.lean`. //! //! The address adapter supplies a globally indexed program whose erased types //! have been checked. External interfaces and special primitives are explicit @@ -1596,7 +1596,7 @@ mod tests { #[test] fn shared_resource_acceptance_and_rejection_fixtures() { let mut count = 0; - for line in include_str!("../../../Tests/Fixtures/ixon-v3/resource.tsv") + for line in include_str!("../../../Tests/Fixtures/ixon-v4/resource.tsv") .lines() .filter(|l| !l.starts_with('#') && !l.is_empty()) { diff --git a/crates/ixon/src/resource/addressed.rs b/crates/ixon/src/resource/addressed.rs index 75ec7a548..5532474fb 100644 --- a/crates/ixon/src/resource/addressed.rs +++ b/crates/ixon/src/resource/addressed.rs @@ -8,12 +8,12 @@ use crate::constant::{ defn_proj_constant, indc_proj_constant, recr_proj_constant, }; use crate::env::Env; -use crate::tag::Tag0; +use crate::tag::TagN; use ix_common::address::Address; use ix_common::env::DefinitionSafety; use rustc_hash::FxHashMap; -pub const VALIDATOR_ID: &str = "ixon-v3/resource-v1"; +pub const VALIDATOR_ID: &str = "ixon-v4/resource-v1"; #[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct Profile { @@ -49,7 +49,7 @@ impl Profile { pub fn bytes(&self) -> Vec { let mut bytes = format!("{VALIDATOR_ID}/profile\0").into_bytes(); for list in [&self.assumptions, &self.shareable_types, &self.choices] { - Tag0::new(list.len() as u64).put(&mut bytes); + TagN::put(0, 0, list.len() as u64, &mut bytes); for address in list { bytes.extend_from_slice(address.as_bytes()); } @@ -63,8 +63,8 @@ impl Profile { }, } } - Tag0::new(self.limits.depth as u64).put(&mut bytes); - Tag0::new(self.limits.steps as u64).put(&mut bytes); + TagN::put(0, 0, self.limits.depth as u64, &mut bytes); + TagN::put(0, 0, self.limits.steps as u64, &mut bytes); bytes } @@ -79,7 +79,7 @@ impl Profile { .strip_prefix(prefix.as_bytes()) .ok_or("resource profile: wrong validator identifier")?; fn list(bytes: &mut &[u8]) -> Result, String> { - let count = Tag0::get(bytes)?.size; + let count = TagN::get(0, bytes)?.value; if count > (bytes.len() / 32) as u64 { return Err("resource profile: impossible address count".into()); } @@ -117,9 +117,9 @@ impl Profile { nat_type: optional(&mut bytes)?, string_type: optional(&mut bytes)?, limits: Limits { - depth: usize::try_from(Tag0::get(&mut bytes)?.size) + depth: usize::try_from(TagN::get(0, &mut bytes)?.value) .map_err(|_error| "resource profile: depth overflow")?, - steps: usize::try_from(Tag0::get(&mut bytes)?.size) + steps: usize::try_from(TagN::get(0, &mut bytes)?.value) .map_err(|_error| "resource profile: steps overflow")?, }, }; @@ -675,6 +675,15 @@ mod tests { use crate::constant::{Axiom, Constructor, DefKind, Inductive, RecursorRule}; use crate::univ::Univ; + /// The validator identity and the wire-format id move with the format + /// version: a version bump cannot leave profile addresses in the old + /// domain. + #[test] + fn validator_id_follows_the_wire_format() { + assert_eq!(crate::WIRE_FORMAT_ID, format!("ixon-v{}", Env::VERSION)); + assert_eq!(VALIDATOR_ID, format!("{}/resource-v1", crate::WIRE_FORMAT_ID)); + } + fn store(env: &Env, c: Constant) -> Address { let addr = c.commit().0; env.store_const(addr.clone(), c); @@ -1000,7 +1009,7 @@ mod tests { ), ]; let fixture = - include_str!("../../../../Tests/Fixtures/ixon-v3/addressed.tsv"); + include_str!("../../../../Tests/Fixtures/ixon-v4/addressed.tsv"); for (name, constant) in cases { let (address, bytes) = constant.commit(); let hex: String = bytes.iter().map(|b| format!("{b:02x}")).collect(); diff --git a/crates/ixon/src/serialize.rs b/crates/ixon/src/serialize.rs index 20e6ea25c..4bdd3354e 100644 --- a/crates/ixon/src/serialize.rs +++ b/crates/ixon/src/serialize.rs @@ -1,7 +1,7 @@ //! Serialization for Ixon types. //! //! This module provides serialization/deserialization for all Ixon types -//! using the Tag4/Tag2/Tag0 encoding schemes. +//! using the TagN integer code (`tag::TagN`) for every integer field. #![allow(clippy::cast_possible_truncation)] #![allow(clippy::map_err_ignore)] @@ -23,7 +23,7 @@ use super::contract::{ }; use super::expr::Expr; use super::metadata::IxonByteSerde; -use super::tag::{Tag0, Tag4}; +use super::tag::TagN; use super::univ::{Univ, get_univ, put_univ}; // ============================================================================ @@ -65,11 +65,11 @@ fn get_bool(buf: &mut &[u8]) -> Result { } fn put_u64(x: u64, buf: &mut Vec) { - Tag0::new(x).put(buf); + TagN::put(0, 0, x, buf); } fn get_u64(buf: &mut &[u8]) -> Result { - Ok(Tag0::get(buf)?.size) + Ok(TagN::get(0, buf)?.value) } fn put_bytes(bytes: &[u8], buf: &mut Vec) { @@ -101,7 +101,7 @@ fn get_opt_addr(buf: &mut &[u8]) -> Result, String> { } /// Read the `.ixe` header shared by every Env reader: -/// `Tag4(0xE, VERSION)`, the 32-byte consts merkle root, the bundle +/// `TagN(0xE, VERSION)`, the 32-byte consts merkle root, the bundle /// `main` pointer, and the strictly ascending assumptions list. /// Centralized so the four readers (`get`, `get_anon`, `get_anon_mmap`, /// `parse_lazy_index`) cannot drift. `ctx` labels errors with the @@ -110,7 +110,7 @@ fn read_env_header( buf: &mut &[u8], ctx: &str, ) -> Result<(Address, Option
, Vec
), String> { - let tag = Tag4::get(buf)?; + let tag = TagN::get(4, buf)?; if tag.flag != Env::FLAG { return Err(format!( "{ctx}: expected flag 0x{:X}, got 0x{:X}", @@ -118,17 +118,17 @@ fn read_env_header( tag.flag )); } - if tag.size != Env::VERSION { + if tag.value != Env::VERSION { return Err(format!( "{ctx}: expected .ixe format version {}, got {} — recompile the \ artifact", Env::VERSION, - tag.size + tag.value )); } let stored_root = get_address(buf)?; // A pre-bundle-format `.ixe` has the §1 blob count here, so this - // byte is that count's Tag0 head — flag the likely cause when it + // byte is that count's TagN head — flag the likely cause when it // isn't a valid opt tag. (.ixe files are regenerated artifacts.) let main = get_opt_addr(buf).map_err(|e| { format!( @@ -217,7 +217,7 @@ const PRE_COMPACT_KEYS: &str = const PRE_NORMAL_LEVELS: &str = " — possibly a pre-normal-levels .ixe; recompile it"; -/// Fuse a `ReducibilityHints` into a single Tag0-encodable value: +/// Fuse a `ReducibilityHints` into a single TagN-encodable value: /// 0 = Opaque, 1 = Abbrev, h + 2 = Regular(h). Keeps the common /// small-height Regular case in one wire byte. fn fuse_hint(hint: &ReducibilityHints) -> u64 { @@ -279,7 +279,7 @@ fn read_hints_section( {consts_len}{PRE_COMPACT_KEYS}" )); } - // Each hint entry needs at least two bytes (Tag0 delta + Tag0 hint). + // Each hint entry needs at least two bytes (TagN delta + TagN hint). if n > buf.len() / 2 { return Err(format!("{reader}: hint count {n} exceeds remaining buffer")); } @@ -361,33 +361,34 @@ pub fn put_expr(e: &Expr, buf: &mut Vec) { }, }; match e { - Expr::Sort(n) => Tag4::new(Expr::FLAG_SORT, *n).put(buf), - Expr::Var(n) => Tag4::new(Expr::FLAG_VAR, *n).put(buf), - Expr::Str(n) => Tag4::new(Expr::FLAG_STR, *n).put(buf), - Expr::Nat(n) => Tag4::new(Expr::FLAG_NAT, *n).put(buf), - Expr::Share(n) => Tag4::new(Expr::FLAG_SHARE, *n).put(buf), + Expr::Sort(n) => TagN::put(4, Expr::FLAG_SORT, *n, buf), + Expr::Var(n) => TagN::put(4, Expr::FLAG_VAR, *n, buf), + Expr::Str(n) => TagN::put(4, Expr::FLAG_STR, *n, buf), + Expr::Nat(n) => TagN::put(4, Expr::FLAG_NAT, *n, buf), + Expr::Share(n) => TagN::put(4, Expr::FLAG_SHARE, *n, buf), Expr::Ref(n, levels) | Expr::Rec(n, levels) => { - Tag4::new( + TagN::put( + 4, if matches!(e, Expr::Ref(..)) { Expr::FLAG_REF } else { Expr::FLAG_REC }, levels.len() as u64, - ) - .put(buf); + buf, + ); put_u64(*n, buf); for level in levels { put_u64(*level, buf); } }, Expr::Prj(t, field, value) => { - Tag4::new(Expr::FLAG_PRJ, *field).put(buf); + TagN::put(4, Expr::FLAG_PRJ, *field, buf); put_u64(*t, buf); work.push(Work::Expr(value)); }, Expr::App(..) => { - Tag4::new(Expr::FLAG_APP, e.app_telescope_count()).put(buf); + TagN::put(4, Expr::FLAG_APP, e.app_telescope_count(), buf); let mut head = e; while let Expr::App(f, a) = head { work.push(Work::Expr(a)); @@ -397,11 +398,12 @@ pub fn put_expr(e: &Expr, buf: &mut Vec) { }, Expr::Lam(..) | Expr::All(..) => { let all = matches!(e, Expr::All(..)); - Tag4::new( + TagN::put( + 4, if all { Expr::FLAG_ALL } else { Expr::FLAG_LAM }, if all { e.all_telescope_count() } else { e.lam_telescope_count() }, - ) - .put(buf); + buf, + ); let mut body = e; let mut binders = vec![]; loop { @@ -424,7 +426,7 @@ pub fn put_expr(e: &Expr, buf: &mut Vec) { work.extend(binders.into_iter().rev()); }, Expr::Let(c, ty, value, body) => { - Tag4::new(Expr::FLAG_LET, c.flags()).put(buf); + TagN::put(4, Expr::FLAG_LET, c.flags(), buf); put_binder_contract(&c.binder, buf); work.extend([Work::Expr(body), Work::Expr(value), Work::Expr(ty)]); }, @@ -467,22 +469,22 @@ pub fn get_expr(buf: &mut &[u8]) -> Result, String> { while let Some(next) = work.pop() { match next { GetExprFrame::Parse => { - let tag = Tag4::get(buf)?; + let tag = TagN::get(4, buf)?; match tag.flag { - Expr::FLAG_SORT => results.push(Expr::sort(tag.size)), - Expr::FLAG_VAR => results.push(Expr::var(tag.size)), - Expr::FLAG_STR => results.push(Expr::str(tag.size)), - Expr::FLAG_NAT => results.push(Expr::nat(tag.size)), - Expr::FLAG_SHARE => results.push(Expr::share(tag.size)), + Expr::FLAG_SORT => results.push(Expr::sort(tag.value)), + Expr::FLAG_VAR => results.push(Expr::var(tag.value)), + Expr::FLAG_STR => results.push(Expr::str(tag.value)), + Expr::FLAG_NAT => results.push(Expr::nat(tag.value)), + Expr::FLAG_SHARE => results.push(Expr::share(tag.value)), Expr::FLAG_REF | Expr::FLAG_REC => { let index = get_u64(buf)?; - if tag.size > buf.len() as u64 { + if tag.value > buf.len() as u64 { return Err( "get_expr: universe count exceeds remaining bytes".into(), ); } - let mut levels = Vec::with_capacity(tag.size as usize); - for _ in 0..tag.size { + let mut levels = Vec::with_capacity(tag.value as usize); + for _ in 0..tag.value { levels.push(get_u64(buf)?); } results.push(if tag.flag == Expr::FLAG_REF { @@ -493,39 +495,39 @@ pub fn get_expr(buf: &mut &[u8]) -> Result, String> { }, Expr::FLAG_PRJ => { work.extend([ - GetExprFrame::Prj(get_u64(buf)?, tag.size), + GetExprFrame::Prj(get_u64(buf)?, tag.value), GetExprFrame::Parse, ]); }, Expr::FLAG_APP | Expr::FLAG_LAM | Expr::FLAG_ALL => { - if tag.size == 0 { + if tag.value == 0 { return Err("get_expr: empty telescope".into()); } let minimum = if tag.flag == Expr::FLAG_APP { 1 } else { 2 }; - if tag.size > (buf.len() / minimum) as u64 { + if tag.value > (buf.len() / minimum) as u64 { return Err( "get_expr: telescope count exceeds remaining bytes".into(), ); } if tag.flag == Expr::FLAG_APP { work.extend([ - GetExprFrame::CheckApp(tag.size), + GetExprFrame::CheckApp(tag.value), GetExprFrame::Parse, ]); } else { work.push(GetExprFrame::Groups { all: tag.flag == Expr::FLAG_ALL, groups: vec![], - remaining: tag.size, + remaining: tag.value, }); } }, Expr::FLAG_LET => { - if tag.size > 3 { + if tag.value > 3 { return Err("get_expr: invalid let flags".into()); } let binder = get_binder_contract(buf)?; - let contract = LetContract::from_flags(tag.size, binder) + let contract = LetContract::from_flags(tag.value, binder) .ok_or("get_expr: invalid let flags")?; work.extend([ GetExprFrame::Let(contract), @@ -1027,16 +1029,16 @@ impl Constant { pub fn put(&self, buf: &mut Vec) { match &self.info { ConstantInfo::Muts(mutuals) => { - // Use FLAG_MUTS (0xC) with entry count in size field - Tag4::new(Self::FLAG_MUTS, mutuals.len() as u64).put(buf); + // Use FLAG_MUTS (0xC) with the entry count as the TagN value + TagN::put(4, Self::FLAG_MUTS, mutuals.len() as u64, buf); // Entries directly (no length prefix - it's in the tag) for m in mutuals { m.put(buf); } }, _ => { - // Use FLAG (0xD) with variant in size field (always 0-7, fits in 1 byte) - Tag4::new(Self::FLAG, self.info.variant().unwrap()).put(buf); + // Use FLAG (0xD) with the variant as the TagN value (0-7: one byte) + TagN::put(4, Self::FLAG, self.info.variant().unwrap(), buf); self.info.put(buf); }, } @@ -1046,19 +1048,19 @@ impl Constant { } pub fn get(buf: &mut &[u8]) -> Result { - let tag = Tag4::get(buf)?; + let tag = TagN::get(4, buf)?; let info = match tag.flag { Self::FLAG_MUTS => { - // Muts: size field is entry count - let mut mutuals = Vec::with_capacity(capped_capacity(tag.size, buf)); - for _ in 0..tag.size { + // Muts: the TagN value is the entry count + let mut mutuals = Vec::with_capacity(capped_capacity(tag.value, buf)); + for _ in 0..tag.value { mutuals.push(MutConst::get(buf)?); } ConstantInfo::Muts(mutuals) }, Self::FLAG => { - // Non-Muts: size field is variant - ConstantInfo::get(tag.size, buf)? + // Non-Muts: the TagN value is the variant + ConstantInfo::get(tag.value, buf)? }, _ => { return Err(format!( @@ -1239,7 +1241,7 @@ use super::metadata::{ /// Serialize an `AuxLayout` side-table entry. /// /// Encoding: two Vec telescopes. `usize` is written/read as `u64` -/// (via `put_u64` / `Tag0`) to avoid target-word-size divergence in +/// (via `put_u64` / `TagN`) to avoid target-word-size divergence in /// cross-platform serialized envs. pub fn put_aux_layout(layout: &AuxLayout, buf: &mut Vec) { put_u64(layout.perm.len() as u64, buf); @@ -1328,7 +1330,7 @@ pub fn put_named_indexed( Ok(()) } -/// How §5 resolves its Tag0 constant indices back to addresses: from a +/// How §5 resolves its TagN constant indices back to addresses: from a /// plain address vector (the full readers' §2 scan order) or from the /// lazy index's §2 windows (cursor/lazy readers). Mirrors [`NameGet`]. #[derive(Clone, Copy)] @@ -1537,16 +1539,25 @@ use super::merkle::merkle_root_canonical_sorted; use super::merkle::{merkle_root_canonical, zero_address}; impl Env { - /// Tag4 flag for Env (0xE). + /// TagN flag for Env (0xE). pub const FLAG: u8 = 0xE; - /// `.ixe` format version, carried in the header's Tag4 size field + /// `.ixe` format version, carried as the value of the header TagN /// (versions < 8 cost zero extra bytes). Any change to serialized /// bytes bumps this. Readers reject a mismatch; there is no /// back-compat reading of old versions — `.ixe` files are - /// regenerated artifacts. Mirrors `Ixon.Env.VERSION` in + /// regenerated artifacts. Version 4 is the TagN format; its header + /// is the single byte `0xE4`. Mirrors `Ixon.Env.VERSION` in /// `Ix/Ixon.lean`. - pub const VERSION: u64 = 3; + pub const VERSION: u64 = 4; + + /// Object-format byte bound by claim, proof and catalog scopes: the + /// format version as one byte, so an object produced under another + /// version is rejected. Mirrors `Ixon.Env.OBJECT_FORMAT`. + pub const OBJECT_FORMAT: u8 = { + assert!(Self::VERSION <= u8::MAX as u64); + Self::VERSION as u8 + }; /// Serialize an Env to bytes. /// @@ -1572,8 +1583,8 @@ impl Env { || std::env::var("IX_COMPILE_DBG").is_ok(); let overall_start = std::time::Instant::now(); - // Header: Tag4 with flag=0xE, size=VERSION (format version) - Tag4::new(Self::FLAG, Self::VERSION).put(buf); + // Header: TagN with flag=0xE, value=VERSION (format version) + TagN::put(4, Self::FLAG, Self::VERSION, buf); // ───────────────────────────────────────────────────────────────────── // Canonical merkle root over consts.keys() @@ -1672,12 +1683,12 @@ impl Env { for addr in &const_addrs { if let Some(entry) = self.consts.get(addr) { put_address(addr, buf); - // Length-prefix sidecar (Tag0) so lazy loaders can slice each - // constant without parsing its Tag4 envelope. The length is + // Length-prefix sidecar (TagN) so lazy loaders can slice each + // constant without parsing its TagN envelope. The length is // NOT part of the content-addressed bytes — `Address::hash` is // computed only over `raw_bytes()`. let bytes = entry.value().raw_bytes(); - Tag0::new(bytes.len() as u64).put(buf); + TagN::put(0, 0, bytes.len() as u64, buf); buf.extend_from_slice(bytes); } } @@ -1705,7 +1716,7 @@ impl Env { // Entries are keyed by rank in §2's ascending-address order, // delta-coded against the previous entry (the address sort below // is load-bearing: it makes the ranks strictly ascending), with - // the hint fused into one Tag0 value — 2-3 bytes per entry + // the hint fused into one TagN value — 2-3 bytes per entry // instead of a redundant 32-byte address. // ───────────────────────────────────────────────────────────────────── let sec_start = std::time::Instant::now(); @@ -1938,9 +1949,9 @@ impl Env { }; } - // Header: Tag4 (flag=0xE, size=VERSION) + the caller-supplied + // Header: TagN (flag=0xE, value=VERSION) + the caller-supplied // canonical merkle root over consts.keys(). - Tag4::new(Self::FLAG, Self::VERSION).put(&mut buf); + TagN::put(4, Self::FLAG, Self::VERSION, &mut buf); put_address(root, &mut buf); if verbose { eprintln!( @@ -2000,7 +2011,7 @@ impl Env { if let Some(entry) = self.consts.get(addr) { put_address(addr, &mut buf); let bytes = entry.value().raw_bytes(); - Tag0::new(bytes.len() as u64).put(&mut buf); + TagN::put(0, 0, bytes.len() as u64, &mut buf); emit!(); w.write_all(bytes) .map_err(|e| format!("Env::put_file: write const: {e}"))?; @@ -2223,7 +2234,7 @@ impl Env { Vec::with_capacity(capped_capacity(num_consts, buf)); for i in 0..num_consts { let addr = get_address(buf)?; - let len = Tag0::get(buf)?.size as usize; + let len = TagN::get(0, buf)?.value as usize; if buf.len() < len { return Err(format!( "Env::get: need {} bytes for constant, have {}", @@ -2542,7 +2553,7 @@ impl Env { let num_consts = get_u64(&mut buf)?; for i in 0..num_consts { let addr = get_address(&mut buf)?; - let len = Tag0::get(&mut buf)?.size as usize; + let len = TagN::get(0, &mut buf)?.value as usize; // Position of the body within `data` = bytes consumed so far. let offset = data.len() - buf.len(); if buf.len() < len { @@ -2776,7 +2787,7 @@ impl Env { Vec::with_capacity(capped_capacity(num_consts, buf)); for i in 0..num_consts { let addr = get_address(buf)?; - let len = Tag0::get(buf)?.size as usize; + let len = TagN::get(0, buf)?.value as usize; if buf.len() < len { return Err(format!( "Env::get_anon: need {} bytes for constant, have {}", @@ -2939,7 +2950,7 @@ impl Env { Vec::with_capacity(capped_capacity(num_consts, buf)); for i in 0..num_consts { let addr = get_address(&mut buf)?; - let len = Tag0::get(&mut buf)?.size as usize; + let len = TagN::get(0, &mut buf)?.value as usize; if buf.len() < len { return Err(format!( "Env::get_anon_mmap: need {} bytes for constant, have {}", @@ -3031,10 +3042,10 @@ impl Env { ) -> Result<(usize, usize, usize, usize, usize, usize, usize), String> { let mut buf = Vec::new(); - // Header: tag (flag=0xE, size=VERSION) + merkle root (32 bytes, + // Header: tag (flag=0xE, value=VERSION) + merkle root (32 bytes, // `zero_address()` sentinel for empty const sets) + bundle fields // (matches Env::put layout). - Tag4::new(Self::FLAG, Self::VERSION).put(&mut buf); + TagN::put(4, Self::FLAG, Self::VERSION, &mut buf); let mut const_addrs: Vec
= self.consts.iter().map(|e| e.key().clone()).collect(); const_addrs.sort_unstable(); @@ -3065,7 +3076,7 @@ impl Env { for entry in self.consts.iter() { put_address(entry.key(), &mut buf); let bytes = entry.value().raw_bytes(); - Tag0::new(bytes.len() as u64).put(&mut buf); + TagN::put(0, 0, bytes.len() as u64, &mut buf); buf.extend_from_slice(bytes); } let consts_size = buf.len() - before_consts; @@ -3267,7 +3278,7 @@ mod tests { use quickcheck::{Arbitrary, Gen}; use quickcheck_macros::quickcheck; - fn v3_fixture_exprs() -> Vec<(&'static str, Arc)> { + fn v4_fixture_exprs() -> Vec<(&'static str, Arc)> { use crate::contract::LetKind; use crate::expr::Uses; let binder = |uses, value| BinderContract { uses, value }; @@ -3357,13 +3368,50 @@ mod tests { ), ("reference", Expr::reference(0, vec![])), ("recursion", Expr::rec(2, vec![0, 1])), + // The last and first value of every TagN rung, f = 4 (an expression + // header) and f = 0 (a Ref index); the bytes are derived by hand in + // the fixture file. + ("tagn4_rung1_last", Expr::var(7)), + ("tagn4_rung2_first", Expr::var(8)), + ("tagn4_rung2_last", Expr::var(1031)), + ("tagn4_rung3_first", Expr::var(1032)), + ("tagn4_rung3_last", Expr::var(66567)), + ("tagn4_rung4_first", Expr::var(66568)), + ("tagn4_rung4_last", Expr::var(16843783)), + ("tagn4_rung5_first", Expr::var(16843784)), + ("tagn4_rung5_last", Expr::var(4311811079)), + ("tagn4_rung6_first", Expr::var(4311811080)), + ("tagn4_rung6_last", Expr::var(u64::MAX)), + ("tagn0_rung1_last", Expr::reference(127, vec![])), + ("tagn0_rung2_first", Expr::reference(128, vec![])), + ("tagn0_rung2_last", Expr::reference(16511, vec![])), + ("tagn0_rung3_first", Expr::reference(16512, vec![])), + ("tagn0_rung3_last", Expr::reference(82047, vec![])), + ("tagn0_rung4_first", Expr::reference(82048, vec![])), + ("tagn0_rung4_last", Expr::reference(16859263, vec![])), + ("tagn0_rung5_first", Expr::reference(16859264, vec![])), + ("tagn0_rung5_last", Expr::reference(4311826559, vec![])), + ("tagn0_rung6_first", Expr::reference(4311826560, vec![])), + ("tagn0_rung6_last", Expr::reference(u64::MAX, vec![])), + ( + "app_telescope_8", + (0..8).rev().fold(Expr::var(8), |f, i| Expr::app(f, Expr::var(i))), + ), + ("ref_univs_8", Expr::reference(0, (0..8).collect())), + ("share_rung3", Expr::share(1032)), ] } #[test] - fn v3_independent_golden_expressions() { - let file = include_str!("../../../Tests/Fixtures/ixon-v3/expressions.txt"); - for (name, expr) in v3_fixture_exprs() { + fn v4_independent_golden_expressions() { + let file = include_str!("../../../Tests/Fixtures/ixon-v4/expressions.txt"); + // Every row of the file is a case here (and in the Lean golden test). + let rows = file + .lines() + .filter(|line| !line.is_empty() && !line.starts_with('#')) + .count(); + assert_eq!(rows, v4_fixture_exprs().len(), "fixture rows without a case"); + for (name, expr) in v4_fixture_exprs() { let line = file .lines() .find(|line| line.starts_with(&format!("{name} "))) @@ -3394,7 +3442,7 @@ mod tests { } #[test] - fn v3_exhaustive_mode_bytes_and_hashes() { + fn exhaustive_mode_bytes_are_distinct() { use crate::contract::LetKind; use crate::expr::Uses; let values = [ @@ -3414,7 +3462,7 @@ mod tests { put_expr(&lam, &mut bytes); assert_eq!(bytes, [0x81, input_code, 0x00, 0x10]); assert_eq!(get_expr(&mut bytes.as_slice()).unwrap(), lam); - assert!(hashes.insert(crate::sharing::hash_expr(&lam))); + assert!(hashes.insert(bytes.clone())); for (result_code, result) in values.into_iter().enumerate() { let all = Expr::all_contract(input, result, Expr::sort(0), Expr::var(0)); @@ -3425,7 +3473,7 @@ mod tests { [0x91, input_code + 16 * result_code as u8, 0x00, 0x10] ); assert_eq!(get_expr(&mut bytes.as_slice()).unwrap(), all); - assert!(hashes.insert(crate::sharing::hash_expr(&all))); + assert!(hashes.insert(bytes.clone())); } for non_dep in [false, true] { for kind in [LetKind::Value, LetKind::BorrowShared] { @@ -3450,7 +3498,7 @@ mod tests { ] ); assert_eq!(get_expr(&mut bytes.as_slice()).unwrap(), let_expr); - assert!(hashes.insert(crate::sharing::hash_expr(&let_expr))); + assert!(hashes.insert(bytes.clone())); } } } @@ -3459,7 +3507,7 @@ mod tests { } #[test] - fn rejects_noncanonical_v3_exprs() { + fn rejects_malformed_exprs() { let malformed: &[&[u8]] = &[ &[0x70], &[0x80], @@ -3468,11 +3516,13 @@ mod tests { &[0x81, 0x07, 0x00, 0x81, 0x07, 0x00, 0x10], // nonmaximal lambda &[0x91, 0x17, 0x00, 0x91, 0x17, 0x00, 0x10], // nonmaximal forall &[0xA4, 0x07, 0x00, 0x10, 0x10], // reserved let flag - &[0x18, 0x00], // nonminimal Tag4 - &[0x28, 0x07, 0x00], // nonminimal reference telescope count - &[0x20, 0x80, 0x00], // nonminimal Tag0 + &[0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], // TagN > u64 + &[0x1F, 0x00, 0x00, 0x00], // truncated nine-byte TagN + &[0x1D, 0x00, 0x00], // truncated four-byte TagN + &[0x18], // truncated two-byte TagN + &[0x20, 0xFF], // reference index: invalid TagN code (f = 0) &[0x87, 0x07, 0x00, 0x10], // impossible binder count - &[0x77, 0x10], // impossible argument count + &[0x77, 0x10], // impossible argument count ]; for bytes in malformed { let mut input = *bytes; @@ -3658,12 +3708,13 @@ mod tests { let env = Env::new(); let mut buf = Vec::new(); env.put(&mut buf).unwrap(); - // Versions < 8 encode inline in the Tag4 head byte. + // Versions < 8 encode inline in the TagN head byte. assert_eq!(buf[0], (Env::FLAG << 4) | (Env::VERSION as u8)); - // A pre-versioning header (size 0) and a future version must both - // be rejected, with an error naming the versions, on every reader - // path through `read_env_header`. - for wrong in [0u8, Env::VERSION as u8 + 1] { + assert_eq!(buf[0], 0xE4, "the version 4 header is the byte 0xE4"); + // A pre-versioning header (size 0), the previous version (3) and a + // future version must all be rejected, with an error naming the + // versions, on every reader path through `read_env_header`. + for wrong in [0u8, 3, Env::VERSION as u8 + 1] { let mut bad = buf.clone(); bad[0] = (Env::FLAG << 4) | wrong; for err in [ @@ -3672,7 +3723,10 @@ mod tests { Env::parse_lazy_index(&bad).map(|_| ()).unwrap_err(), ] { assert!( - err.contains("format version"), + err.contains(&format!( + "expected .ixe format version {}, got {wrong}", + Env::VERSION + )), "expected a format-version error, got: {err}" ); } @@ -3812,7 +3866,7 @@ mod tests { // anon_hints — keyed by stored constant addresses: §3 writes each // key as its §2 rank, so out-of-consts keys are a writer error. - // Regular heights span the fused-hint Tag0 1↔2-byte boundary + // Regular heights span the fused-hint TagN 1↔2-byte boundary // (fused = h + 2 crosses 127 at h = 126). if !const_addrs.is_empty() { let num_hints = gen_range(g, 0..4); @@ -3823,9 +3877,9 @@ mod tests { 1 => ReducibilityHints::Abbrev, _ => { let h: u32 = Arbitrary::arbitrary(g); - // Bias half the heights to the Tag0 1↔2-byte wire boundary + // Bias half the heights to the TagN 1↔2-byte wire boundary // (fused = h + 2 crosses 127 at h = 126); keep the rest - // full-range for the multi-byte Tag0 paths. + // full-range for the multi-byte TagN paths. ReducibilityHints::Regular(if bool::arbitrary(g) { h % 200 } else { @@ -4021,7 +4075,7 @@ mod tests { addr } - /// Extract the stored merkle root from a serialized env. The Tag4 + /// Extract the stored merkle root from a serialized env. The TagN /// header byte (flag `0xE`, size = format version) is followed by /// exactly 32 bytes of root (no opt-tag). fn parse_stored_root(buf: &[u8]) -> Vec { @@ -4114,7 +4168,7 @@ mod tests { let n = get_u64(&mut cur).unwrap(); assert!(n >= 1, "need at least one const to locate"); let _addr = get_address(&mut cur).unwrap(); - let _len = Tag0::get(&mut cur).unwrap(); + let _len = TagN::get(0, &mut cur).unwrap(); buf.len() - cur.len() } @@ -4526,14 +4580,14 @@ mod tests { ] { assert_eq!(unfuse_hint(fuse_hint(&h)).unwrap(), h); } - // Wire widths at the Tag0 1↔2-byte boundary: fused = h + 2. + // Wire widths at the TagN 1↔2-byte boundary: fused = h + 2. let width = |h: &ReducibilityHints| { let mut b = Vec::new(); put_u64(fuse_hint(h), &mut b); b.len() }; assert_eq!(width(&Regular(125)), 1, "fused 127 fits one byte"); - assert_eq!(width(&Regular(126)), 2, "fused 128 needs the large form"); + assert_eq!(width(&Regular(126)), 2, "fused 128 needs a two-byte TagN"); // Heights beyond u32 are malformed. assert!(unfuse_hint(u64::from(u32::MAX) + 3).is_err()); assert!(unfuse_hint(u64::MAX).is_err()); @@ -4548,7 +4602,7 @@ mod tests { let n = get_u64(&mut cur).unwrap(); for _ in 0..n { let _addr = get_address(&mut cur).unwrap(); - let len = Tag0::get(&mut cur).unwrap().size as usize; + let len = TagN::get(0, &mut cur).unwrap().value as usize; cur = &cur[len..]; } let start = buf.len() - cur.len(); @@ -4678,14 +4732,14 @@ mod tests { fn old_format_hints_section_detected() { let buf = two_hint_env_bytes(); // Simulate a pre-compact-keys §3: count=1, then a raw 32-byte - // address + tag byte + Tag0 height. The first address byte (0x00) + // address + tag byte + TagN height. The first address byte (0x00) // parses as a zero delta, so every reader fails immediately with // the recompile hint. let mut custom = Vec::new(); put_u64(1, &mut custom); custom.extend_from_slice(&[0u8; 32]); custom.push(2); - Tag0::new(5).put(&mut custom); + TagN::put(0, 0, 5, &mut custom); assert_all_readers_reject( &splice_hints(&buf, &custom), &["pre-compact-keys", "recompile"], @@ -4706,11 +4760,11 @@ mod tests { assert_eq!(n, 2); let first_start = buf.len() - cur.len(); let _addr = get_address(&mut cur).unwrap(); - let len = Tag0::get(&mut cur).unwrap().size as usize; + let len = TagN::get(0, &mut cur).unwrap().value as usize; cur = &cur[len..]; let second_start = buf.len() - cur.len(); let _addr = get_address(&mut cur).unwrap(); - let len = Tag0::get(&mut cur).unwrap().size as usize; + let len = TagN::get(0, &mut cur).unwrap().value as usize; cur = &cur[len..]; let second_end = buf.len() - cur.len(); let mut swapped = buf[..first_start].to_vec(); @@ -4723,7 +4777,7 @@ mod tests { #[test] fn named_indices_out_of_range_rejected() { // One named entry whose §5 name_idx / const_idx bytes get bumped - // out of range (both are single-byte Tag0 values in this env). + // out of range (both are single-byte TagN values in this env). let env = Env::new(); let a = store_canonical(&env, defn_const(vec![])); let name = n_test("Target"); @@ -4742,7 +4796,7 @@ mod tests { // name_idx out of range: full + lazy readers reject... let mut bad = buf.clone(); - assert_eq!(bad[name_idx_off] & 0x80, 0, "expected small Tag0"); + assert_eq!(bad[name_idx_off] & 0x80, 0, "expected a one-byte TagN"); bad[name_idx_off] = 0x7F; let err = Env::get(&mut bad.as_slice()).expect_err("get accepted"); assert!(err.contains("name index"), "got: {err}"); @@ -4758,7 +4812,7 @@ mod tests { // const_idx out of range. let mut bad = buf.clone(); - assert_eq!(bad[const_idx_off] & 0x80, 0, "expected small Tag0"); + assert_eq!(bad[const_idx_off] & 0x80, 0, "expected a one-byte TagN"); bad[const_idx_off] = 0x7F; let err = Env::get(&mut bad.as_slice()).expect_err("get accepted"); assert!(err.contains("constant index"), "got: {err}"); @@ -4893,7 +4947,7 @@ mod tests { env.put(&mut buf).unwrap(); // Locate the first entry's meta_len byte: after the §5 count, - // name_idx, const_idx, and fused hint (all 1-byte Tag0s here). + // name_idx, const_idx, and fused hint (all one-byte TagNs here). let index = Env::parse_lazy_index(&buf).unwrap(); let mut cur: &[u8] = &buf[index.named_section_offset..]; let _count = get_u64(&mut cur).unwrap(); @@ -4901,7 +4955,7 @@ mod tests { let _const_idx = get_u64(&mut cur).unwrap(); let _hint = get_u64(&mut cur).unwrap(); let len_off = buf.len() - cur.len(); - assert_eq!(buf[len_off] & 0x80, 0, "expected small Tag0 meta_len"); + assert_eq!(buf[len_off] & 0x80, 0, "expected a one-byte TagN meta_len"); // Shrink the length: parsers consume more than the header says. let mut bad = buf.clone(); diff --git a/crates/ixon/src/sharing.rs b/crates/ixon/src/sharing.rs deleted file mode 100644 index 953c0c90e..000000000 --- a/crates/ixon/src/sharing.rs +++ /dev/null @@ -1,828 +0,0 @@ -//! Sharing analysis for expression deduplication within mutual blocks. -//! -//! This module provides alpha-invariant sharing analysis using Merkle-tree hashing. -//! Expressions that are structurally identical get the same hash, and we decide -//! which subterms to share based on a profitability heuristic. - -#![allow(clippy::cast_possible_truncation)] -#![allow(clippy::cast_precision_loss)] -#![allow(clippy::cast_possible_wrap)] -#![allow(clippy::match_same_arms)] - -use std::sync::Arc; - -use indexmap::IndexSet; -use rustc_hash::FxHashMap; - -use super::expr::Expr; -use super::tag::{Tag0, Tag4}; - -/// Information about a subterm for sharing analysis. -#[derive(Debug)] -pub struct SubtermInfo { - /// Base size of this node alone (Tag4 header, not including children) for Ixon format - pub base_size: usize, - /// Size in a fully hash-consed store (32-byte key + value with hash references) - pub hash_consed_size: usize, - /// Number of occurrences within this block - pub usage_count: usize, - /// Canonical representative expression - pub expr: Arc, - /// Hashes of child subterms (for topological ordering) - pub children: Vec, -} - -/// Canonical scalar/contract data for one node, followed by fixed-size -/// child hashes in structural order. All three mode axes are semantic. -fn put_node_header(expr: &Expr, buf: &mut Vec) { - match expr { - Expr::Sort(_) - | Expr::Var(_) - | Expr::Ref(..) - | Expr::Rec(..) - | Expr::Str(_) - | Expr::Nat(_) - | Expr::Share(_) => crate::serialize::put_expr(expr, buf), - Expr::Prj(t, field, _) => { - Tag4::new(Expr::FLAG_PRJ, *field).put(buf); - Tag0::new(*t).put(buf); - }, - Expr::App(..) => Tag4::new(Expr::FLAG_APP, 1).put(buf), - Expr::Lam(c, ..) => { - Tag4::new(Expr::FLAG_LAM, 1).put(buf); - buf.push(c.to_bits()); - }, - Expr::All(c, v, ..) => { - Tag4::new(Expr::FLAG_ALL, 1).put(buf); - buf.push(crate::contract::pack_all_contract(*c, *v)); - }, - Expr::Let(c, ..) => { - Tag4::new(Expr::FLAG_LET, c.flags()).put(buf); - buf.push(c.binder.to_bits()); - }, - } -} - -fn hash_node( - expr: &Expr, - child_hashes: &FxHashMap<*const Expr, blake3::Hash>, - buf: &mut Vec, -) -> (blake3::Hash, Vec, usize) { - buf.clear(); - put_node_header(expr, buf); - let children: Vec<_> = get_children(expr) - .iter() - .map(|child| { - let hash = child_hashes[&(child.as_ref() as *const Expr)]; - buf.extend_from_slice(hash.as_bytes()); - hash - }) - .collect(); - (blake3::hash(buf), children, buf.len()) -} - -fn compute_base_size(expr: &Expr) -> usize { - let mut buf = Vec::with_capacity(16); - put_node_header(expr, &mut buf); - buf.len() -} - -fn get_children(expr: &Expr) -> Vec<&Arc> { - expr.children() -} - -/// Analyze expressions for sharing opportunities within a block. -/// -/// Returns a map from content hash to SubtermInfo, and a map from pointer to hash. -/// Uses a two-phase algorithm: -/// 1. Build DAG structure via post-order traversal with Merkle-tree hashing -/// 2. Propagate usage counts structurally from roots to leaves (O(n) total) -/// -/// If `track_hash_consed_size` is true, computes the hash-consed size for each -/// subterm (32-byte key + value). This adds overhead and can be disabled when -/// only sharing analysis is needed. -pub fn analyze_block( - exprs: &[Arc], - track_hash_consed_size: bool, -) -> ( - FxHashMap, - FxHashMap<*const Expr, blake3::Hash>, - Vec, -) { - let mut info_map: FxHashMap = FxHashMap::default(); - let mut ptr_to_hash: FxHashMap<*const Expr, blake3::Hash> = - FxHashMap::default(); - let mut hash_buf: Vec = Vec::with_capacity(128); - - // Phase 1: Build DAG structure via post-order traversal - // Don't compute usage counts here - just build the hash→children mapping - enum Frame<'a> { - Visit(&'a Arc), - Process(&'a Arc), - } - - for root in exprs { - let mut stack: Vec> = vec![Frame::Visit(root)]; - - while let Some(frame) = stack.pop() { - match frame { - Frame::Visit(arc_expr) => { - let ptr = arc_expr.as_ref() as *const Expr; - - // Already processed this pointer - just skip - // Usage counts will be computed in phase 2 - if ptr_to_hash.contains_key(&ptr) { - continue; - } - - // Push process frame, then children (in reverse for correct order) - stack.push(Frame::Process(arc_expr)); - for child in get_children(arc_expr).into_iter().rev() { - stack.push(Frame::Visit(child)); - } - }, - Frame::Process(arc_expr) => { - let ptr = arc_expr.as_ref() as *const Expr; - if ptr_to_hash.contains_key(&ptr) { - continue; - } - - let (hash, children, value_size) = - hash_node(arc_expr.as_ref(), &ptr_to_hash, &mut hash_buf); - - // Add to ptr_to_hash cache - ptr_to_hash.insert(ptr, hash); - - // Add to info_map if not already present (same content hash from different pointer) - info_map.entry(hash).or_insert_with(|| { - let base_size = compute_base_size(arc_expr.as_ref()); - let hash_consed_size = - if track_hash_consed_size { 32 + value_size } else { 0 }; - SubtermInfo { - base_size, - hash_consed_size, - usage_count: 0, // Will be computed in phase 2 - expr: arc_expr.clone(), - children, - } - }); - }, - } - } - } - - // Phase 2: Propagate usage counts structurally from roots to leaves - // This is O(n) total - no subtree walks needed - // - // Algorithm: - // 1. Each root expression contributes 1 to its hash's count - // 2. Process in reverse topological order (roots first, leaves last) - // 3. For each node, add its count to each child's count (with multiplicity) - - // Count root contributions - for root in exprs { - let ptr = root.as_ref() as *const Expr; - if let Some(hash) = ptr_to_hash.get(&ptr) - && let Some(info) = info_map.get_mut(hash) - { - info.usage_count += 1; - } - } - - // Get topological order (leaves first) and reverse it (roots first) - let topo_order = topological_sort(&info_map); - - // Propagate counts from roots to leaves - for hash in topo_order.iter().rev() { - // Get this node's count and children - let (count, children) = { - let info = info_map.get(hash).unwrap(); - (info.usage_count, info.children.clone()) - }; - - // Add this node's count to each child (with multiplicity from children array) - for child_hash in children { - if let Some(child_info) = info_map.get_mut(&child_hash) { - child_info.usage_count += count; - } - } - } - - (info_map, ptr_to_hash, topo_order) -} - -/// Compute the hash of a single expression. -/// This is useful for testing hash compatibility with Lean. -pub fn hash_expr(expr: &Arc) -> blake3::Hash { - let (_info_map, ptr_to_hash, _) = - analyze_block(std::slice::from_ref(expr), false); - let ptr = expr.as_ref() as *const Expr; - *ptr_to_hash.get(&ptr).expect("Expression not found in ptr_to_hash") -} - -/// Topological sort of subterms (leaves first, parents last). -/// CRITICAL: Keys are sorted by hash bytes for deterministic output. -/// This ensures Lean and Rust produce the same topological order. -pub fn topological_sort( - info_map: &FxHashMap, -) -> Vec { - #[derive(Clone, Copy, PartialEq, Eq)] - enum VisitState { - InProgress, - Done, - } - - let mut state: FxHashMap = FxHashMap::default(); - let mut result: Vec = Vec::new(); - - fn visit( - hash: blake3::Hash, - info_map: &FxHashMap, - state: &mut FxHashMap, - result: &mut Vec, - ) { - match state.get(&hash) { - Some(VisitState::Done) => return, - Some(VisitState::InProgress) => return, // Cycle (shouldn't happen) - _ => {}, - } - - state.insert(hash, VisitState::InProgress); - - if let Some(info) = info_map.get(&hash) { - for child in &info.children { - visit(*child, info_map, state, result); - } - } - - state.insert(hash, VisitState::Done); - result.push(hash); - } - - // Sort keys deterministically by hash bytes (lexicographic comparison) - let mut sorted_keys: Vec = info_map.keys().cloned().collect(); - sorted_keys.sort_by_key(|h| *h.as_bytes()); - - for hash in sorted_keys { - visit(hash, info_map, &mut state, &mut result); - } - - result -} - -/// Compute effective sizes for all subterms in topological order. -/// Returns a map from hash to effective size (total serialized bytes). -pub fn compute_effective_sizes( - info_map: &FxHashMap, - topo_order: &[blake3::Hash], -) -> FxHashMap { - let mut sizes: FxHashMap = FxHashMap::default(); - - for hash in topo_order { - if let Some(info) = info_map.get(hash) { - let mut size = info.base_size; - for child_hash in &info.children { - size += sizes.get(child_hash).copied().unwrap_or(0); - } - sizes.insert(*hash, size); - } - } - - sizes -} - -/// Analyze sharing statistics for debugging pathological cases. -/// Returns a summary of why sharing may not be effective. -#[allow(dead_code)] -pub fn analyze_sharing_stats( - info_map: &FxHashMap, - topo_order: &[blake3::Hash], -) -> SharingStats { - let effective_sizes = compute_effective_sizes(info_map, topo_order); - - let total_subterms = info_map.len(); - let mut usage_distribution: FxHashMap = FxHashMap::default(); - let mut size_distribution: FxHashMap = FxHashMap::default(); - let mut total_usage: usize = 0; - let mut unique_subterms = 0; - let mut shared_subterms = 0; - - for (hash, info) in info_map.iter() { - total_usage += info.usage_count; - *usage_distribution.entry(info.usage_count).or_insert(0) += 1; - - let size = effective_sizes.get(hash).copied().unwrap_or(0); - let size_bucket = match size { - 0..=1 => 1, - 2..=4 => 4, - 5..=10 => 10, - 11..=50 => 50, - 51..=100 => 100, - _ => 1000, - }; - *size_distribution.entry(size_bucket).or_insert(0) += 1; - - if info.usage_count == 1 { - unique_subterms += 1; - } else { - shared_subterms += 1; - } - } - - // Count candidates at each filtering stage - let candidates_usage_ge_2: usize = - info_map.values().filter(|info| info.usage_count >= 2).count(); - - let candidates_positive_potential: usize = info_map - .iter() - .filter(|(_, info)| info.usage_count >= 2) - .filter(|(hash, info)| { - let term_size = effective_sizes.get(hash).copied().unwrap_or(0); - let n = info.usage_count; - let potential = (n as isize - 1) * (term_size as isize) - (n as isize); - potential > 0 - }) - .count(); - - // Simulate actual sharing to count how many pass - let mut simulated_shared = 0; - let mut candidates: Vec<_> = info_map - .iter() - .filter(|(_, info)| info.usage_count >= 2) - .filter_map(|(hash, info)| { - let term_size = *effective_sizes.get(hash)?; - let n = info.usage_count; - let potential = (n as isize - 1) * (term_size as isize) - (n as isize); - if potential > 0 { Some((term_size, n)) } else { None } - }) - .collect(); - - candidates.sort_unstable_by(|a, b| { - let pot_a = (a.1 as isize - 1) * (a.0 as isize); - let pot_b = (b.1 as isize - 1) * (b.0 as isize); - pot_b.cmp(&pot_a) - }); - - for (term_size, usage_count) in candidates { - let next_ref_size = - Tag4::new(Expr::FLAG_SHARE, simulated_shared as u64).encoded_size(); - let n = usage_count as isize; - let savings = (n - 1) * (term_size as isize) - n * (next_ref_size as isize); - if savings > 0 { - simulated_shared += 1; - } - // Don't break - process all candidates - } - - SharingStats { - total_subterms, - unique_subterms, - shared_subterms, - total_usage, - candidates_usage_ge_2, - candidates_positive_potential, - actually_shared: simulated_shared, - usage_distribution, - size_distribution, - } -} - -/// Statistics about sharing analysis. -#[derive(Debug)] -pub struct SharingStats { - pub total_subterms: usize, - pub unique_subterms: usize, - pub shared_subterms: usize, - pub total_usage: usize, - pub candidates_usage_ge_2: usize, - pub candidates_positive_potential: usize, - pub actually_shared: usize, - pub usage_distribution: FxHashMap, - pub size_distribution: FxHashMap, -} - -impl std::fmt::Display for SharingStats { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - writeln!(f, "=== Sharing Analysis ===")?; - writeln!(f, "Total unique subterms: {}", self.total_subterms)?; - writeln!(f, " - Unique (usage=1): {}", self.unique_subterms)?; - writeln!(f, " - Shared (usage>=2): {}", self.shared_subterms)?; - writeln!(f, "Total usage count: {}", self.total_usage)?; - writeln!( - f, - "Average usage: {:.2}", - if self.total_subterms > 0 { - self.total_usage as f64 / self.total_subterms as f64 - } else { - 0.0 - } - )?; - writeln!(f)?; - writeln!(f, "Filtering pipeline:")?; - writeln!( - f, - " 1. Candidates with usage >= 2: {}", - self.candidates_usage_ge_2 - )?; - writeln!( - f, - " 2. With positive potential: {}", - self.candidates_positive_potential - )?; - writeln!(f, " 3. Actually shared: {}", self.actually_shared)?; - writeln!(f)?; - writeln!(f, "Usage distribution:")?; - let mut usage_counts: Vec<_> = self.usage_distribution.iter().collect(); - usage_counts.sort_by_key(|(k, _)| *k); - for (usage, count) in usage_counts.iter().take(10) { - writeln!(f, " usage={}: {} subterms", usage, count)?; - } - if usage_counts.len() > 10 { - writeln!(f, " ... and {} more buckets", usage_counts.len() - 10)?; - } - writeln!(f)?; - writeln!(f, "Size distribution (effective_size buckets):")?; - let mut size_counts: Vec<_> = self.size_distribution.iter().collect(); - size_counts.sort_by_key(|(k, _)| *k); - for (size_bucket, count) in size_counts { - writeln!(f, " size<={}: {} subterms", size_bucket, count)?; - } - Ok(()) - } -} - -/// Decide which subterms to share based on profitability. -/// -/// Sharing is profitable when: `(N - 1) * term_size > N * share_ref_size` -/// where N is usage count, term_size is effective size, and share_ref_size -/// is the size of a Share(idx) reference at the current index. -/// -/// Optimized from O(k×n) to O(n log n) by pre-sorting candidates. -pub fn decide_sharing( - info_map: &FxHashMap, - topo_order: &[blake3::Hash], -) -> IndexSet { - let effective_sizes = compute_effective_sizes(info_map, topo_order); - - // Pre-filter and sort candidates by potential savings (assuming minimal ref_size=1) - // This gives us a stable ordering since relative savings don't change as ref_size grows - let mut candidates: Vec<_> = info_map - .iter() - .filter(|(_, info)| info.usage_count >= 2) - .filter_map(|(hash, info)| { - let term_size = *effective_sizes.get(hash)?; - let n = info.usage_count; - // Potential savings assuming ref_size = 1 (minimum) - let potential = (n as isize - 1) * (term_size as isize) - (n as isize); - if potential > 0 { Some((*hash, term_size, n)) } else { None } - }) - .collect(); - - // Sort by decreasing gross benefit, with hash bytes as tie-breaker for determinism - candidates.sort_unstable_by(|a, b| { - let gross_a = (a.2 as isize - 1) * (a.1 as isize); - let gross_b = (b.2 as isize - 1) * (b.1 as isize); - match gross_b.cmp(&gross_a) { - std::cmp::Ordering::Equal => a.0.as_bytes().cmp(b.0.as_bytes()), - other => other, - } - }); - - let mut shared: IndexSet = IndexSet::new(); - - // Process ALL candidates - don't break early! - // The early-break was incorrect: ref_size growth affects candidates differently - // based on their usage count. A high-usage small term may become unprofitable - // while a low-usage large term remains profitable. - for (hash, term_size, usage_count) in candidates { - let next_idx = shared.len(); - let next_ref_size = - Tag4::new(Expr::FLAG_SHARE, next_idx as u64).encoded_size(); - let n = usage_count as isize; - let savings = (n - 1) * (term_size as isize) - n * (next_ref_size as isize); - - if savings > 0 { - shared.insert(hash); - } - } - - shared -} - -/// Rewrite expressions to use Share(idx) references for shared subterms. -/// -/// Returns the rewritten expressions and the sharing vector. -pub fn build_sharing_vec( - exprs: &[Arc], - shared_hashes: &IndexSet, - ptr_to_hash: &FxHashMap<*const Expr, blake3::Hash>, - info_map: &FxHashMap, - topo_order: &[blake3::Hash], -) -> (Vec>, Vec>) { - // CRITICAL: Re-sort shared_hashes in topological order (leaves first). - // decide_sharing returns hashes sorted by gross benefit (large terms first), - // but we need leaves first so that when serializing sharing[i], all its - // children are already available as Share(j) for j < i. - let shared_in_topo_order: Vec = - topo_order.iter().copied().filter(|h| shared_hashes.contains(h)).collect(); - - // Build sharing vector incrementally to avoid forward references. - // When building sharing[i], only Share(j) for j < i is allowed. - let mut sharing_vec: Vec> = Vec::with_capacity(shared_hashes.len()); - let mut hash_to_idx: FxHashMap = FxHashMap::default(); - let mut cache: FxHashMap<*const Expr, Arc> = FxHashMap::default(); - - for h in &shared_in_topo_order { - let info = info_map.get(h).expect("shared hash must be in info_map"); - // No cache.clear() needed: rewrite_expr checks hash_to_idx BEFORE the - // cache, so newly-shareable expressions are always caught even if the - // cache has a stale entry from a prior iteration. Topological order - // guarantees all children of `h` were already added to hash_to_idx, - // so their cached rewrites (containing correct Share references) remain - // valid. - let rewritten = - rewrite_expr(&info.expr, &hash_to_idx, ptr_to_hash, &mut cache); - - let idx = sharing_vec.len() as u64; - sharing_vec.push(rewritten); - // Now add this hash to the map for subsequent entries - hash_to_idx.insert(*h, idx); - } - - // Rewrite the root expressions (can use all Share indices) - let rewritten_exprs: Vec> = exprs - .iter() - .map(|e| rewrite_expr(e, &hash_to_idx, ptr_to_hash, &mut cache)) - .collect(); - - (rewritten_exprs, sharing_vec) -} - -enum RewriteFrame<'a> { - Visit(&'a Arc), - Build(&'a Arc), -} - -/// Iterative reconstruction preserves every contract while changing -/// only expression children. The hash includes every mode and let flag. -fn rewrite_expr( - expr: &Arc, - hash_to_idx: &FxHashMap, - ptr_to_hash: &FxHashMap<*const Expr, blake3::Hash>, - cache: &mut FxHashMap<*const Expr, Arc>, -) -> Arc { - let mut stack = vec![RewriteFrame::Visit(expr)]; - let mut results: Vec> = vec![]; - while let Some(frame) = stack.pop() { - match frame { - RewriteFrame::Visit(e) => { - let ptr = e.as_ref() as *const Expr; - if let Some(hash) = ptr_to_hash.get(&ptr) - && let Some(&idx) = hash_to_idx.get(hash) - { - let share = Expr::share(idx); - cache.insert(ptr, share.clone()); - results.push(share); - continue; - } - if let Some(cached) = cache.get(&ptr) { - results.push(cached.clone()); - continue; - } - let children = get_children(e); - if children.is_empty() { - cache.insert(ptr, e.clone()); - results.push(e.clone()); - } else { - stack.push(RewriteFrame::Build(e)); - stack.extend(children.into_iter().rev().map(RewriteFrame::Visit)); - } - }, - RewriteFrame::Build(original) => { - let children = get_children(original); - let start = results.len() - children.len(); - let changed = children - .iter() - .zip(&results[start..]) - .any(|(old, new)| !Arc::ptr_eq(old, new)); - let rebuilt: Vec<_> = results.drain(start..).collect(); - let result = if !changed { - original.clone() - } else { - Arc::new( - original - .with_children(&rebuilt) - .expect("sharing rewrite child count"), - ) - }; - cache.insert(original.as_ref() as *const Expr, result.clone()); - results.push(result); - }, - } - } - results.pop().expect("sharing rewrite result") -} - -#[cfg(test)] -mod tests { - use super::*; - - /// Test that demonstrates the early-break bug in decide_sharing. - /// - /// The bug: decide_sharing sorts candidates by "gross benefit" (n-1)*size - /// and breaks on the first unprofitable candidate. However, as ref_size - /// grows (1 byte for idx<8, 2 bytes for idx>=8), a high-usage small-size - /// term may become unprofitable while a low-usage large-size term remains - /// profitable. - /// - /// At ref_size=2 (idx >= 8): - /// - Term A: size=2, n=10, gross=18, savings = 18 - 20 = -2 < 0 (triggers break!) - /// - Term B: size=5, n=2, gross=5, savings = 5 - 4 = 1 > 0 (profitable but skipped) - /// - /// We need 8 filler terms with gross > 18 to fill indices 0-7 first. - #[test] - fn test_early_break_bug() { - // Filler: 8 unique terms with gross > 18 - // Var(256)..Var(263), each appearing 10 times - // size=3 (256 fits in 2 bytes after Tag4 header), n=10, gross=9*3=27 > 18 - let mut all_exprs: Vec> = Vec::new(); - - for i in 0..8u64 { - let var = Expr::var(256 + i); // size=3 - for _ in 0..10 { - all_exprs.push(var.clone()); - } - } - - // Term A: Var(10), appearing 10 times - // size=2 (10 < 256, so fits in Tag4 with 2-byte encoding), n=10, gross=9*2=18 - // At ref_size=2 (idx >= 8): savings = 18 - 20 = -2 < 0 (triggers break!) - let term_a = Expr::var(10); - for _ in 0..10 { - all_exprs.push(term_a.clone()); - } - - // Term B: All(Var(0), All(Var(1), Var(2))) appearing 2 times - // This has effective_size = 1 + 1 + (1 + 1 + 1) = 5 - // gross = 1*5 = 5 < 18 ✓ (comes after A in sort order) - // At ref_size=2: savings = 5 - 4 = 1 > 0 ✓ (profitable!) - let term_b = Expr::all(Expr::var(0), Expr::all(Expr::var(1), Expr::var(2))); - all_exprs.push(term_b.clone()); - all_exprs.push(term_b.clone()); - - // Analyze all expressions together - let (info_map, ptr_to_hash, topo_order) = analyze_block(&all_exprs, false); - let shared = decide_sharing(&info_map, &topo_order); - - // Verify term_a was found with usage_count=10 - let term_a_ptr = term_a.as_ref() as *const Expr; - let term_a_hash = ptr_to_hash.get(&term_a_ptr); - if let Some(hash) = term_a_hash { - let info = info_map.get(hash).unwrap(); - assert_eq!(info.usage_count, 10, "term_a should have usage_count=10"); - } - - // Find term B's hash - it's the outer All(Var(0), ...) - let term_b_ptr = term_b.as_ref() as *const Expr; - let term_b_hash = ptr_to_hash.get(&term_b_ptr); - - if let Some(hash) = term_b_hash { - let info = info_map.get(hash).unwrap(); - assert_eq!(info.usage_count, 2, "term_b should have usage_count=2"); - - // Compute effective size - let sizes = compute_effective_sizes(&info_map, &topo_order); - let term_b_size = sizes.get(hash).copied().unwrap_or(0); - - // This assertion will FAIL with buggy code (early break) and PASS with fix - assert!( - shared.contains(hash), - "Term B (effective_size={}, n=2, gross={}) should be shared. \ - At ref_size=2, savings = {} - 4 = {} > 0. \ - But early-break bug skips it after term A fails. \ - shared.len()={}", - term_b_size, - term_b_size, // gross = (n-1)*size = 1*size - term_b_size, - term_b_size as isize - 4, - shared.len() - ); - } - } - - #[test] - fn test_analyze_simple() { - // Create a simple expression: App(Var(0), Var(0)) - // Var(0) should have usage_count = 2 - let var0 = Expr::var(0); - let app = Expr::app(var0.clone(), var0); - - let (info_map, ptr_to_hash, _topo_order) = analyze_block(&[app], false); - - // Should have 2 unique subterms: Var(0) and App(Var(0), Var(0)) - assert_eq!(info_map.len(), 2); - - // Find Var(0) info - it should have usage_count = 2 - let var_hash = ptr_to_hash.values().find(|h| { - info_map - .get(*h) - .is_some_and(|info| matches!(info.expr.as_ref(), Expr::Var(0))) - }); - assert!(var_hash.is_some()); - let var_info = info_map.get(var_hash.unwrap()).unwrap(); - assert_eq!(var_info.usage_count, 2); - } - - #[test] - fn test_decide_sharing_simple() { - // Create expression with repeated subterm - let ty = Expr::sort(0); - let lam1 = Expr::lam(ty.clone(), Expr::var(0)); - let lam2 = Expr::lam(ty.clone(), Expr::var(1)); - let app = Expr::app(lam1, lam2); - - let (info_map, _, topo_order) = analyze_block(&[app], false); - let shared = decide_sharing(&info_map, &topo_order); - - // ty (Sort(0)) appears twice, might be shared depending on size - // This is a basic smoke test - assert!(shared.len() <= info_map.len()); - } - - #[test] - fn test_topological_sort() { - let var0 = Expr::var(0); - let var1 = Expr::var(1); - let app = Expr::app(var0, var1); - - let (info_map, _, topo) = analyze_block(&[app], false); - - // Should have all hashes - assert_eq!(topo.len(), info_map.len()); - - // Leaves (Var) should come before App - let app_hash = info_map - .iter() - .find(|(_, info)| matches!(info.expr.as_ref(), Expr::App(..))) - .map(|(h, _)| *h); - - if let Some(app_h) = app_hash { - let app_pos = topo.iter().position(|h| *h == app_h).unwrap(); - // App should be last (after its children) - for child_hash in &info_map.get(&app_h).unwrap().children { - let child_pos = topo.iter().position(|h| h == child_hash).unwrap(); - assert!( - child_pos < app_pos, - "Child should come before parent in topo order" - ); - } - } - } - - #[test] - fn test_build_sharing_vec() { - // Create expression with a shared subterm: App(App(var0, var0), var0) - // var0 appears 3 times, should be shared - let var0 = Expr::var(0); - let app1 = Expr::app(var0.clone(), var0.clone()); - let app2 = Expr::app(app1, var0); - - let (info_map, ptr_to_hash, topo_order) = - analyze_block(std::slice::from_ref(&app2), false); - let shared = decide_sharing(&info_map, &topo_order); - - // If var0 is shared, verify it - if !shared.is_empty() { - let (rewritten, sharing_vec) = build_sharing_vec( - &[app2], - &shared, - &ptr_to_hash, - &info_map, - &topo_order, - ); - - // Sharing vec should have the shared expressions - assert_eq!(sharing_vec.len(), shared.len()); - - // Rewritten should have at least one Share reference if sharing happened - assert_eq!(rewritten.len(), 1); - } - } - - #[test] - fn test_roundtrip_with_sharing() { - use crate::serialize::{get_expr, put_expr}; - - // Create a simple expression with potential sharing - let var0 = Expr::var(0); - let var1 = Expr::var(1); - let app = Expr::app(var0, var1); - - // Serialize and deserialize without sharing - let mut buf = Vec::new(); - put_expr(&app, &mut buf); - let recovered = get_expr(&mut buf.as_slice()).unwrap(); - - assert_eq!(app.as_ref(), recovered.as_ref()); - } -} diff --git a/crates/ixon/src/sharing_exact.rs b/crates/ixon/src/sharing_exact.rs new file mode 100644 index 000000000..21a1298a1 --- /dev/null +++ b/crates/ixon/src/sharing_exact.rs @@ -0,0 +1,856 @@ +//! Sharing tables of anonymous Constants: the canonical construction and its +//! reference searches (`docs/sharing-minimum.md`). +//! +//! The compiler shares every block with the tiered canonical construction +//! ([`canonical_sharing_tiered`], `tiered`; Lean +//! `Ix.Sharing.Exact.canonicalSharingTiered`): phase 1 is the exact +//! uniform-width optimizer (`uniform`) at widths 1, 2 and 3, phase 2 +//! allocates the table slots, phase 3 re-materializes every part under the +//! real TagN widths, and the candidate with the fewest bytes wins. +//! +//! The rest of this module is the global exact minimum of +//! `docs/sharing-minimum.md` §3, computed by the width-state search +//! ([`optimize_sharing`], [`normalize_constant_sharing`], `search`). It is +//! exponential in the candidates and is a test oracle for small inputs, not +//! on the compiler path. Given a resolved anonymous Constant (or its ordered +//! expanded roots), it returns the feasible backward-reference sharing +//! encoding with the lexicographically least key +//! +//! ```text +//! K(e) = (L(e), Q(e), bytes(e)) +//! ``` +//! +//! where `L` is the byte length of the complete serialized Constant, `Q` the +//! vector of structural term IDs (§3.2) of the table entries in stored order +//! and `bytes` the serialized Constant. All non-sharing fields, root order and +//! the refs/univs tables are fixed; only the table sequence and per-occurrence +//! inline/reference choices vary. A table entry may reference only earlier +//! entries (the backward-reference class of §3.1); this module does not claim +//! optimality over forward-acyclic tables. +//! +//! Structure: +//! - [`SharingDag`] (`dag`): collision-independent hash-consing of the +//! expanded roots with §3.2 structural IDs, built from expanded roots or by +//! bounded, validated expansion of an existing table; also the re-expansion +//! checks of an encoding. +//! - `cost`: exact serialized lengths of expressions and Constants, mirroring +//! the writers of `serialize.rs`, and the [`Len`] overflow sentinel. +//! - `roots`: the ordered roots of a `ConstantInfo` and its reassembly. +//! - `dict`: the fixed-dictionary recurrence `C_M` (§5) with explicit +//! telescope cuts, its incremental and lazy evaluations of a growing +//! dictionary, and byte-least materialization. +//! - `search`: the sparse width-state dynamic program (§6) with the proved +//! reductions R1/R2, the optimistic-dictionary lower bound (§4.1) and a +//! materialization lower bound (the test oracle above). +//! - `uniform`: the exact optimizer for a uniform Share width (phase 1). +//! - `tiered`: the canonical tiered construction, its checks and its +//! checked mode ([`ExactSharingLimits::full_check`]). +//! - `par`: deterministic task splitting for [`Parallelism`]; `prof`: phase +//! timers behind the `sharing-profile` feature. +//! - `oracle` (tests only): a tiny exhaustive reference search; `mss` (tests +//! only): the maximal-structural-sharing reference encoding. +//! +//! Every limit in [`ExactSharingLimits`] is enforced with deterministic +//! counters where it applies (`max_candidates` and the layer and transition +//! limits bound the width-state search only); exhausting one returns +//! [`SharingError::ResourceExhausted`] and never a best-so-far encoding. +//! Lengths use checked arithmetic or the exact overflow sentinel [`Len`]. +//! +//! # Pinned interpretations +//! +//! These choices are part of the canonical result and must match any other +//! implementation of the rule: +//! +//! - **ID domain.** Structural IDs number exactly the distinct subterms +//! reachable from the ordered roots after expansion. Entries of an +//! incoming table that no root reaches are validated but do not receive +//! IDs, so they cannot influence `Q`. +//! - **Admission.** Expansion accepts only the backward-reference class: +//! a Share in entry `i` must name an entry `< i`, a Share in a root must +//! name an entry `< len`. Out-of-range, forward and cyclic references are +//! [`MalformedSharing`] errors, including in unreachable entries. +//! [`optimize_sharing`] rejects any Share leaf in its input. +//! - **Byte tie.** For a fixed table sequence each entry and root is +//! materialized as its byte-least minimum-length representation. This +//! equals the rule: an inline constructor precedes a Share of the same +//! length (flags `0x0..=0xA` < `0xB`); among telescope prefixes of one +//! node the least TagN header bytes win (distinct prefix lengths always +//! differ inside the header); then children independently. +//! - **Variable length.** [`ExactSharingResult::variable_len`] is the sum of +//! the root encodings, the table's TagN count and the entry encodings; the +//! rest of the Constant is fixed and checked against `Constant::put`. +//! +//! Pruning (the §4.1 bound strengthened with `share_width(k)` for future +//! entries, the materialization bound, and the greedy upper bound seed) +//! never changes a successful result, only which inputs finish +//! within the limits; `search` documents the proofs. + +mod cost; +mod dag; +mod dict; +mod par; +mod prof; +mod roots; +mod search; +mod tiered; +mod uniform; + +#[cfg(test)] +mod mss; +#[cfg(test)] +mod oracle; +#[cfg(test)] +mod tests; + +use std::fmt; +use std::sync::Arc; + +pub use cost::{ + Len, byte_count, constant_fixed_len, constant_len, expr_len, expr_len_with, + share_width, sharing_table_len, tag0_len, tag4_len, +}; +pub use dag::{Children, Node, NodeKey, SharingDag, TermId}; +pub use dict::{FixedDictionary, dictionary_cost, materialize_with_dictionary}; +// Diagnostic only (empty without the `sharing-profile` feature). +#[doc(hidden)] +pub use prof::profile_report; +pub use roots::{ + constant_info_root_count, constant_info_root_exprs, rebuild_constant_info, +}; +pub use search::{candidate_terms, sequence_len}; +pub use tiered::{ + ShareLayout, TAGN_RUNG1_END, TAGN_RUNG2_END, TAGN_RUNG3_END, TAGN_RUNG4_END, + TAGN_RUNG5_END, TieredSharingResult, TieredStats, canonical_sharing_tiered, + layout_bytes, normalize_constant_bytes_tiered, + normalize_constant_sharing_tiered, normalize_constant_sharing_tiered_par, + tagn_width, +}; +pub use uniform::{ + UniformSharingResult, normalize_constant_sharing_uniform, + optimize_sharing_uniform, +}; +// The first-tier search of phase 2, for the tests; not part of the API. +#[cfg(test)] +pub(crate) use tiered::first_tier; + +use crate::constant::Constant; +use crate::expr::Expr; + +/// Deterministic resource limits and search options. Exhausting a limit is +/// an error. Limits and the pruning and checking options can change success +/// into failure but never the bytes of a success. +/// +/// The defaults are a safety net, not a budget: each production limit is at +/// least 2^8 times the previous default, under which every Mathlib constant +/// built. `max_candidates` bounds only the exhaustive width-state search (a +/// test oracle, not the compiler path) and stays at 2^16; the canonical +/// construction records its candidate count without limiting it, as Lean +/// does. A run that reaches a limit fails closed and names it +/// ([`Resource::key`]); [`ExactSharingLimits::with_overrides`] raises it. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ExactSharingLimits { + /// Pointer-distinct input expression nodes visited during expansion. + pub max_input_nodes: u64, + /// Distinct structural nodes interned (including unreachable entries). + pub max_distinct_nodes: u64, + /// Maximum height of the expanded DAG. + pub max_height: u64, + /// Sharing candidates remaining after reductions R1/R2 (the width-state + /// search only). + pub max_candidates: u64, + /// Width states created by the dynamic program. + pub max_states: u64, + /// States in one layer (entries stored) of the dynamic program. + pub max_layer_states: u64, + /// Candidate transitions examined. + pub max_transitions: u64, + /// Node evaluations, spine steps and marking steps, per candidate of the + /// tiered construction. Its phase 3 charges one evaluation of the whole + /// table when the order is closed under stored descendants (one pass), and + /// one evaluation per table prefix otherwise, so the two paths charge + /// different amounts for the same output (see `tiered`). + pub max_work: u64, + /// Length of the complete serialized output. + pub max_output_bytes: u64, + /// Cells `(components + 1) * (cap + 1)` of the uniform optimizer's + /// table-count knapsack (Lean `maxKnapsackCells`), checked before it runs + /// and counted separately from `max_states`. + pub max_knapsack_cells: u64, + /// Prune states by proved lower bounds. Disabling it explores every + /// reachable width state (a reference mode for tests). + pub lower_bound_pruning: bool, + /// Seed the upper bound with a deterministic greedy table sequence. + /// Affects pruning only. + pub greedy_upper_bound: bool, + /// Also prune by the materialization bound (see `search`), in addition to + /// the §4.1 dictionary bound. + pub materialization_bound: bool, + /// Uniform-width search: use the plain subset enumeration of each + /// component instead of the reclassifying branch and bound. A test + /// oracle, not on the compiler path (off by default; the Lean optimality + /// theorems assume it is off). The result must not change. + pub uniform_subset_search: bool, + /// Tiered construction: build and check every candidate, not only the + /// returned one, and cross-check every shortcut against the computation + /// it replaces (the checked mode; see `tiered`, "Checks"). Off on the + /// compiler path; on in the unit tests, the Lean/Rust FFI parity hooks and + /// `sharing_corpus --full-check`. The output, the statistics and the + /// outcome of every limit are those of the default mode; a discrepancy is + /// an [`SharingError::Internal`] error. + pub full_check: bool, + /// Tiered construction: run phase 3 per table prefix for every candidate, + /// also when the order is closed under stored descendants (the reference + /// of the one-pass phase 3; off by default). The bytes do not change; the + /// `work` charged does (see `max_work`). + pub phase3_per_prefix: bool, +} + +/// Thread budgets for the tiered construction inside one constant (Rust +/// only; [`normalize_constant_sharing_tiered_par`]). A budget is the number of +/// tasks a level is split into on the current rayon pool; 0 and 1 run that +/// level sequentially, and [`Parallelism::SEQUENTIAL`] is the reference path +/// of every other entry point. Every budget gives byte-identical output. +/// +/// * `widths`: the three phase-1 widths of the best of three run as separate +/// tasks, each under its own meter (as in the sequential path), and are +/// compared afterwards by the same rule. An error at any width fails the +/// call with the error of the lowest failing width, as sequentially. +/// * `components`: the uncertain components of phase 1 are searched as +/// separate tasks and their tables combined in component order. Each +/// component counts its `states_created` and `work` on a meter of its own; +/// the counts are then added to the call's meter in component order, +/// checking `states_created` and then `work` after each component. The +/// totals equal the sequential ones and a call fails if and only if the +/// sequential call fails, but when both counters reach their limits within +/// the same component the reported resource can differ from the sequential +/// path's (which reports whichever was reached first). +/// * `materialize`: the per-prefix phase 3 (an order not closed under +/// stored descendants, [`ExactSharingLimits::phase3_per_prefix`], and the +/// per-prefix reference of [`ExactSharingLimits::full_check`]) evaluates +/// the entries (each under the entries before it) and the roots as +/// separate tasks; their work is charged in entry order afterwards, so +/// counters, errors and output equal the sequential path's. The one-pass +/// phase 3, which every order of Init and Mathlib takes, has no tasks to +/// split and ignores this budget. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Parallelism { + pub widths: usize, + pub components: usize, + pub materialize: usize, +} + +impl Parallelism { + /// Every level sequential (the reference). + pub const SEQUENTIAL: Parallelism = + Parallelism { widths: 1, components: 1, materialize: 1 }; +} + +impl Default for Parallelism { + fn default() -> Self { + Self::SEQUENTIAL + } +} + +impl Default for ExactSharingLimits { + fn default() -> Self { + ExactSharingLimits { + max_input_nodes: 1 << 40, + max_distinct_nodes: 1 << 32, + max_height: 1 << 32, + max_candidates: 1 << 16, + max_states: 1 << 40, + max_layer_states: 1 << 40, + max_transitions: 1 << 40, + max_work: 1 << 56, + max_output_bytes: 1 << 40, + max_knapsack_cells: 1 << 28, + greedy_upper_bound: true, + lower_bound_pruning: true, + materialization_bound: true, + uniform_subset_search: false, + full_check: false, + phase3_per_prefix: false, + } + } +} + +impl ExactSharingLimits { + /// No limits except those of the representation itself. + pub fn unbounded() -> Self { + ExactSharingLimits { + max_input_nodes: u64::MAX, + max_distinct_nodes: u64::MAX, + max_height: u64::MAX, + max_candidates: u64::MAX, + max_states: u64::MAX, + max_layer_states: u64::MAX, + max_transitions: u64::MAX, + max_work: u64::MAX, + max_output_bytes: u64::MAX, + max_knapsack_cells: u64::MAX, + ..Self::default() + } + } + + /// Limit keys of the Lean implementation (`Ix.Sharing.Exact.Limits`) that + /// the Rust limits do not have. [`Self::with_overrides`] accepts and + /// ignores them, so one override string serves both compilers; `states`, + /// `transitions` and `output_bytes` name a limit in both. + pub const LEAN_ONLY_KEYS: [&'static str; 6] = [ + "expr_visits", + "depth", + "nodes", + "cost_evals", + "materialize", + "materialize_work", + ]; + + /// Set the limit named `key` ([`Resource::key`]); `false` if the key names + /// no Rust limit. + pub fn set_limit(&mut self, key: &str, value: u64) -> bool { + let slot = match key { + "input_nodes" => &mut self.max_input_nodes, + "distinct_nodes" => &mut self.max_distinct_nodes, + "height" => &mut self.max_height, + "candidates" => &mut self.max_candidates, + "states" => &mut self.max_states, + "layer_states" => &mut self.max_layer_states, + "transitions" => &mut self.max_transitions, + "work" => &mut self.max_work, + "output_bytes" => &mut self.max_output_bytes, + "knapsack_cells" => &mut self.max_knapsack_cells, + _ => return false, + }; + *slot = value; + true + } + + /// Apply a limit override: comma-separated items, each `key=value` + /// ([`Resource::key`] names; values ASCII decimal digits, `2^k` with + /// `k <= 63`, or `max`; no sign or separator) or `unbounded` (every limit + /// at `u64::MAX`), applied left to right. Items, keys and values are + /// trimmed of space, tab, line feed and carriage return only. Lean-only + /// keys ([`Self::LEAN_ONLY_KEYS`]) are accepted and ignored; any other key + /// is an error. This is the grammar of Lean + /// `Ix.Sharing.Exact.Limits.withOverrides`, of `ix compile + /// --sharing-limits` and of `IX_SHARING_LIMITS`; the test list + /// `LIMIT_SPEC_PARITY` pins it for both languages. + pub fn with_overrides(mut self, spec: &str) -> Result { + for raw in spec.split(',') { + let item = trim_ascii(raw); + if item.is_empty() { + continue; + } + if item == "unbounded" { + for key in [ + "input_nodes", + "distinct_nodes", + "height", + "candidates", + "states", + "layer_states", + "transitions", + "work", + "output_bytes", + "knapsack_cells", + ] { + self.set_limit(key, u64::MAX); + } + continue; + } + let Some((key, value)) = item.split_once('=') else { + return Err(format!( + "sharing limit item {item}: expected key=value or unbounded" + )); + }; + let key = trim_ascii(key); + let value = parse_limit_value(value)?; + if !self.set_limit(key, value) && !Self::LEAN_ONLY_KEYS.contains(&key) { + return Err(format!( + "unknown sharing limit {key} (expected input_nodes, distinct_nodes, \ + height, candidates, states, layer_states, transitions, work, \ + output_bytes, knapsack_cells, or a Lean key: {})", + Self::LEAN_ONLY_KEYS.join(", ") + )); + } + } + Ok(self) + } +} + +/// Trim the whitespace Lean `String.trimAscii` trims: space, tab, line feed +/// and carriage return. +fn trim_ascii(s: &str) -> &str { + s.trim_matches(|c: char| matches!(c, ' ' | '\t' | '\n' | '\r')) +} + +/// A limit value: ASCII decimal digits, `2^k` (`k <= 63`, `k` digits) or +/// `max` (`u64::MAX`). No sign, separator or other spelling: the grammar of +/// Lean `parseLimitValue`. +fn parse_limit_value(raw: &str) -> Result { + let s = trim_ascii(raw); + if s == "max" { + return Ok(u64::MAX); + } + let digits = |t: &str| !t.is_empty() && t.bytes().all(|b| b.is_ascii_digit()); + if let Some(k) = s.strip_prefix("2^") { + if !digits(k) { + return Err(format!( + "sharing limit value {s}: expected digits, 2^k or max" + )); + } + return match k.parse::() { + Ok(k) if k <= 63 => Ok(1u64 << k), + Ok(_) => Err(format!("sharing limit value {s}: exponent above 63")), + Err(e) => Err(format!( + "sharing limit value {s}: expected digits, 2^k or max: {e}" + )), + }; + } + if !digits(s) { + return Err(format!( + "sharing limit value {s}: expected digits, 2^k or max" + )); + } + s.parse::().map_err(|e| { + format!( + "sharing limit value {s}: expected digits, 2^k or max (at most 2^64 - \ + 1): {e}" + ) + }) +} + +/// Non-semantic statistics of one invocation. +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct ExactSharingStats { + pub input_nodes: u64, + pub distinct_nodes: u64, + pub height: u64, + pub candidates: u64, + pub states_created: u64, + pub states_expanded: u64, + pub states_pruned: u64, + pub transitions: u64, + pub max_layer: u64, + pub layers: u64, + pub work: u64, + /// Variable length of the greedy seed, when it was computed. + pub greedy_len: Option, + /// Variable length of the unshared encoding (`None` if it overflows). + pub unshared_len: Option, +} + +/// Where a Share reference occurred. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ShareLocation { + Entry(u64), + Root(u64), +} + +/// The input is not a valid backward-reference sharing encoding. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum MalformedSharing { + /// A Share index is not below the table length. + ShareOutOfRange { location: ShareLocation, index: u64, table_len: u64 }, + /// Entry `entry` references a later entry without closing a cycle. + ForwardShare { entry: u64, index: u64 }, + /// Entry `entry` references `index >= entry` and that closes a cycle. + CyclicShare { entry: u64, index: u64 }, + /// A Share leaf in input that must already be expanded. + UnresolvedShare { root: u64, index: u64 }, + /// Reassembly did not consume exactly the ConstantInfo's roots. + RootCountMismatch { expected: u64, actual: u64 }, +} + +/// A value exceeds a representable index or length domain. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum FormatBound { + /// More distinct terms than the `u32` term-ID space. + TermIdSpace { nodes: u64 }, + /// A serialized length reaches `u64::MAX`. + LengthOverflow, + /// A uniform Share width of 0. + UniformWidth { w: u64 }, + /// A telescope spine of length at least `bound` (Lean's `formatBound + /// "telescope spine length" teleSubaddEnd`): below it the TagN Share-flag + /// width is subadditive, which the uniform classes rely on. + TelescopeSpine { bound: u64 }, +} + +/// Which deterministic limit was exhausted. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Resource { + InputNodes, + DistinctNodes, + Height, + Candidates, + States, + LayerStates, + Transitions, + Work, + OutputBytes, + /// The uniform optimizer's table-count knapsack (`max_knapsack_cells`). + KnapsackCells, +} + +impl Resource { + /// The name of the resource in error messages and limit overrides + /// ([`ExactSharingLimits::with_overrides`], `--sharing-limits`). + pub fn key(self) -> &'static str { + match self { + Resource::InputNodes => "input_nodes", + Resource::DistinctNodes => "distinct_nodes", + Resource::Height => "height", + Resource::Candidates => "candidates", + Resource::States => "states", + Resource::LayerStates => "layer_states", + Resource::Transitions => "transitions", + Resource::Work => "work", + Resource::OutputBytes => "output_bytes", + Resource::KnapsackCells => "knapsack_cells", + } + } +} + +/// A deterministic resource limit was reached before certification. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct ResourceExhausted { + pub resource: Resource, + pub limit: u64, +} + +/// Failure of an exact-sharing operation. No variant carries a partial or +/// uncertified encoding. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum SharingError { + Malformed(MalformedSharing), + FormatBound(FormatBound), + ResourceExhausted(ResourceExhausted), + /// An internal invariant failed; this is a bug, reported instead of a + /// wrong answer. + Internal(String), +} + +impl fmt::Display for SharingError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + SharingError::Malformed(m) => write!(f, "malformed sharing: {m:?}"), + SharingError::FormatBound(b) => write!(f, "format bound: {b:?}"), + SharingError::ResourceExhausted(r) => { + write!( + f, + "resource exhausted: {} (limit {})", + r.resource.key(), + r.limit + ) + }, + SharingError::Internal(s) => write!(f, "internal error: {s}"), + } + } +} + +impl std::error::Error for SharingError {} + +/// Deterministic work accounting against [`ExactSharingLimits`]. +pub(crate) struct Meter<'l> { + limits: &'l ExactSharingLimits, + pub(crate) stats: ExactSharingStats, + /// Thread budgets of the tiered construction (sequential by default). + pub(crate) parallel: Parallelism, +} + +impl<'l> Meter<'l> { + pub(crate) fn new(limits: &'l ExactSharingLimits) -> Self { + Meter { + limits, + stats: ExactSharingStats::default(), + parallel: Parallelism::SEQUENTIAL, + } + } + + pub(crate) fn with_parallelism( + limits: &'l ExactSharingLimits, + parallel: Parallelism, + ) -> Self { + Meter { parallel, ..Meter::new(limits) } + } + + pub(crate) fn limits(&self) -> &'l ExactSharingLimits { + self.limits + } + + fn exhausted(resource: Resource, limit: u64) -> SharingError { + SharingError::ResourceExhausted(ResourceExhausted { resource, limit }) + } + + pub(crate) fn input_node(&mut self) -> Result<(), SharingError> { + self.stats.input_nodes = self.stats.input_nodes.saturating_add(1); + if self.stats.input_nodes > self.limits.max_input_nodes { + return Err(Self::exhausted( + Resource::InputNodes, + self.limits.max_input_nodes, + )); + } + Ok(()) + } + + pub(crate) fn distinct_nodes(&mut self, n: u64) -> Result<(), SharingError> { + self.stats.distinct_nodes = self.stats.distinct_nodes.max(n); + if n > self.limits.max_distinct_nodes { + return Err(Self::exhausted( + Resource::DistinctNodes, + self.limits.max_distinct_nodes, + )); + } + Ok(()) + } + + pub(crate) fn height(&mut self, h: u64) -> Result<(), SharingError> { + self.stats.height = self.stats.height.max(h); + if h > self.limits.max_height { + return Err(Self::exhausted(Resource::Height, self.limits.max_height)); + } + Ok(()) + } + + pub(crate) fn candidates(&mut self, k: u64) -> Result<(), SharingError> { + self.stats.candidates = k; + if k > self.limits.max_candidates { + return Err(Self::exhausted( + Resource::Candidates, + self.limits.max_candidates, + )); + } + Ok(()) + } + + pub(crate) fn work(&mut self, n: u64) -> Result<(), SharingError> { + self.stats.work = self.stats.work.saturating_add(n); + if self.stats.work > self.limits.max_work { + return Err(Self::exhausted(Resource::Work, self.limits.max_work)); + } + Ok(()) + } + + pub(crate) fn state(&mut self) -> Result<(), SharingError> { + self.stats.states_created = self.stats.states_created.saturating_add(1); + if self.stats.states_created > self.limits.max_states { + return Err(Self::exhausted(Resource::States, self.limits.max_states)); + } + Ok(()) + } + + pub(crate) fn transition(&mut self) -> Result<(), SharingError> { + self.stats.transitions = self.stats.transitions.saturating_add(1); + if self.stats.transitions > self.limits.max_transitions { + return Err(Self::exhausted( + Resource::Transitions, + self.limits.max_transitions, + )); + } + Ok(()) + } + + pub(crate) fn layer(&mut self, size: u64) -> Result<(), SharingError> { + self.stats.max_layer = self.stats.max_layer.max(size); + if size > self.limits.max_layer_states { + return Err(Self::exhausted( + Resource::LayerStates, + self.limits.max_layer_states, + )); + } + Ok(()) + } + + /// Add the `states_created` and `work` counted on another meter (one + /// parallel task), checking `states_created` and then `work`. + pub(crate) fn absorb( + &mut self, + other: &ExactSharingStats, + ) -> Result<(), SharingError> { + self.stats.states_created = + self.stats.states_created.saturating_add(other.states_created); + if self.stats.states_created > self.limits.max_states { + return Err(Self::exhausted(Resource::States, self.limits.max_states)); + } + self.work(other.work) + } + + pub(crate) fn output(&mut self, len: u64) -> Result<(), SharingError> { + if len > self.limits.max_output_bytes { + return Err(Self::exhausted( + Resource::OutputBytes, + self.limits.max_output_bytes, + )); + } + Ok(()) + } +} + +/// A certified exact-minimum sharing encoding of ordered expanded roots. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ExactSharingResult { + /// Rewritten roots, in input order. + pub roots: Vec>, + /// The sharing table; entry `i` references only entries `< i`. + pub sharing: Vec>, + /// `Q`: structural term ID of each table entry, in stored order. + pub table_terms: Vec, + /// Exact variable bytes: roots + table TagN count + table entries. + pub variable_len: u64, + /// Nonsemantic statistics. + pub stats: ExactSharingStats, +} + +/// Exact minimum sharing of ordered, fully expanded roots (no Share leaves): +/// the width-state search, a test oracle (not the compiler path, which is +/// [`canonical_sharing_tiered`]). +/// +/// The full-Constant key differs from the variable length only by bytes that +/// do not depend on sharing, so the result is the global minimum of any +/// Constant with these ordered roots. +pub fn optimize_sharing( + roots: &[Arc], + limits: &ExactSharingLimits, +) -> Result { + let mut meter = Meter::new(limits); + let dag = SharingDag::build(roots, None, &mut meter)?; + search::optimize(&dag, 0, &mut meter) +} + +/// Expand `c`'s table (validating backward references) and return the +/// exact-minimum Constant together with its search result (the width-state +/// search, a test oracle; see [`optimize_sharing`]). +pub fn normalize_constant_sharing_with_stats( + c: &Constant, + limits: &ExactSharingLimits, +) -> Result<(Constant, ExactSharingResult), SharingError> { + let mut meter = Meter::new(limits); + let roots = constant_info_root_exprs(&c.info); + let dag = SharingDag::build(&roots, Some(&c.sharing), &mut meter)?; + let fixed = constant_fixed_len(c) + .ok_or(SharingError::FormatBound(FormatBound::LengthOverflow))?; + let result = search::optimize(&dag, fixed, &mut meter)?; + let info = rebuild_constant_info(&c.info, &result.roots)?; + let out = Constant { + info, + sharing: result.sharing.clone(), + refs: c.refs.clone(), + univs: c.univs.clone(), + }; + // Fixed-cost accounting: the real serializer must agree with the + // decomposition the search optimized. + let mut bytes = Vec::new(); + out.put(&mut bytes); + let expected = fixed.checked_add(result.variable_len); + if u64::try_from(bytes.len()).ok() != expected { + return Err(SharingError::Internal(format!( + "serialized length {} differs from fixed {fixed} + variable {}", + bytes.len(), + result.variable_len + ))); + } + Ok((out, result)) +} + +/// Expand `c`'s table and return its exact-minimum encoding (the test +/// oracle of [`optimize_sharing`]). +pub fn normalize_constant_sharing( + c: &Constant, + limits: &ExactSharingLimits, +) -> Result { + normalize_constant_sharing_with_stats(c, limits).map(|(c, _)| c) +} + +/// Outcome of [`check_exact_minimum`]. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum ExactMinimumCheck { + /// `c` is its exact-minimum encoding. + Minimum, + /// `c` differs from its exact-minimum encoding `expected`. + NotMinimum { expected: Box }, +} + +/// Whether `c` is byte-identical to its exact-minimum encoding: a check +/// against the width-state search, the test oracle of [`optimize_sharing`] +/// (Lean `checkExactMinimum`). It does not check the compiler's +/// canonical construction ([`canonical_sharing_tiered`]). +pub fn check_exact_minimum( + c: &Constant, + limits: &ExactSharingLimits, +) -> Result { + let expected = normalize_constant_sharing(c, limits)?; + let mut have = Vec::new(); + c.put(&mut have); + let mut want = Vec::new(); + expected.put(&mut want); + Ok(if have == want { + ExactMinimumCheck::Minimum + } else { + ExactMinimumCheck::NotMinimum { expected: Box::new(expected) } + }) +} + +/// Failure of [`normalize_constant_bytes`]. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum NormalizeBytesError { + /// The input is not exactly one wire-valid serialized Constant. + Decode(String), + Sharing(SharingError), +} + +impl fmt::Display for NormalizeBytesError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + NormalizeBytesError::Decode(e) => write!(f, "decode: {e}"), + NormalizeBytesError::Sharing(e) => write!(f, "{e}"), + } + } +} + +impl std::error::Error for NormalizeBytesError {} + +/// Byte-level normalization: decode exactly one serialized Constant (no +/// trailing bytes), expand and validate its table, and return the serialized +/// exact-minimum Constant (the test oracle of [`optimize_sharing`]). +pub fn normalize_constant_bytes( + bytes: &[u8], + limits: &ExactSharingLimits, +) -> Result, NormalizeBytesError> { + let mut input = bytes; + let c = Constant::get(&mut input).map_err(NormalizeBytesError::Decode)?; + if !input.is_empty() { + return Err(NormalizeBytesError::Decode(format!( + "{} trailing bytes after the Constant", + input.len() + ))); + } + let out = normalize_constant_sharing(&c, limits) + .map_err(NormalizeBytesError::Sharing)?; + let mut buf = Vec::new(); + out.put(&mut buf); + Ok(buf) +} + +/// Byte-level uniform-width normalization: decode exactly one serialized +/// Constant, re-share it with the uniform-width optimum for Share width `w`, +/// and return the serialized result. +pub fn normalize_constant_bytes_uniform( + w: u64, + bytes: &[u8], + limits: &ExactSharingLimits, +) -> Result, NormalizeBytesError> { + let mut input = bytes; + let c = Constant::get(&mut input).map_err(NormalizeBytesError::Decode)?; + if !input.is_empty() { + return Err(NormalizeBytesError::Decode(format!( + "{} trailing bytes after the Constant", + input.len() + ))); + } + let (out, _) = normalize_constant_sharing_uniform(w, &c, limits) + .map_err(NormalizeBytesError::Sharing)?; + let mut buf = Vec::new(); + out.put(&mut buf); + Ok(buf) +} diff --git a/crates/ixon/src/sharing_exact/cost.rs b/crates/ixon/src/sharing_exact/cost.rs new file mode 100644 index 000000000..e734e8b64 --- /dev/null +++ b/crates/ixon/src/sharing_exact/cost.rs @@ -0,0 +1,360 @@ +//! Exact serialized-length helpers for the expression and Constant grammar +//! (TagN integers). +//! +//! Every function here mirrors a writer in `serialize.rs` byte for byte; the +//! tests compare them against the real serializer. Arithmetic is checked: +//! helpers that measure caller data return `None` instead of wrapping. + +use std::cmp::Ordering; +use std::sync::Arc; + +use rustc_hash::FxHashMap; + +use super::roots::constant_info_root_exprs; +use crate::constant::{ + Constant, ConstantInfo, Constructor, Inductive, MutConst, Recursor, +}; +use crate::expr::Expr; +use crate::tag::TagN; +use crate::univ::put_univ; + +/// Serialized byte length with an explicit overflow sentinel. +/// +/// Values below `u64::MAX` are exact. [`Len::OVERFLOW`] stands for every +/// length `>= u64::MAX`: addition saturates into it, so it compares strictly +/// greater than every exact length and two exact lengths always compare +/// exactly. The optimizer only ever returns exact lengths; an overflowed +/// candidate can lose a comparison but can never be selected. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Len(u64); + +impl Len { + pub const ZERO: Len = Len(0); + pub const OVERFLOW: Len = Len(u64::MAX); + + /// `v == u64::MAX` is read as [`Len::OVERFLOW`]. + pub const fn new(v: u64) -> Len { + Len(v) + } + + #[must_use] + pub const fn plus(self, other: Len) -> Len { + Len(self.0.saturating_add(other.0)) + } + + #[must_use] + pub const fn plus_u64(self, other: u64) -> Len { + Len(self.0.saturating_add(other)) + } + + pub const fn is_exact(self) -> bool { + self.0 != u64::MAX + } + + /// The exact value, or `None` for [`Len::OVERFLOW`]. + pub const fn exact(self) -> Option { + if self.0 == u64::MAX { None } else { Some(self.0) } + } + + /// Raw value; `u64::MAX` is the overflow sentinel. + pub const fn raw(self) -> u64 { + self.0 + } +} + +/// Minimal little-endian byte count of `x` (0 for 0), as `u64_byte_count`. +pub fn byte_count(x: u64) -> u64 { + (64 - u64::from(x.leading_zeros())).div_ceil(8) +} + +/// Encoded length of a TagN (f = 4) integer `size` for any flag: +/// 1, 2, 3, 4, 5 or 9 bytes ([`TagN::byte_width`]). +pub fn tag4_len(size: u64) -> u64 { + TagN::byte_width(4, size) as u64 +} + +/// Encoded length of a TagN (f = 0) integer `size`: 1, 2, 3, 4, 5 or 9 bytes. +pub fn tag0_len(size: u64) -> u64 { + TagN::byte_width(0, size) as u64 +} + +/// Byte width of `Expr::Share(index)`. +pub fn share_width(index: u64) -> u64 { + tag4_len(index) +} + +/// Unsigned lexicographic order of the TagN (f = 4) encodings of two values +/// under the same flag (flag 0 stands for it: the flag bits are equal). TagN +/// is a prefix code, so distinct values differ inside the shorter encoding. +pub(crate) fn tag4_bytes_cmp(a: u64, b: u64) -> Ordering { + let mut xa = Vec::with_capacity(9); + let mut xb = Vec::with_capacity(9); + TagN::put(4, 0, a, &mut xa); + TagN::put(4, 0, b, &mut xb); + xa.cmp(&xb) +} + +fn usize_u64(n: usize) -> Option { + u64::try_from(n).ok() +} + +/// Exact `put_expr` length of an expression (Share leaves allowed). +/// +/// Iterative, memoized by pointer, so an `Arc` DAG is measured without +/// walking its occurrence tree. Returns `None` if the length overflows. +pub fn expr_len(e: &Expr) -> Option { + expr_len_with(e, &tag4_len) +} + +/// [`expr_len`] with every `Share(i)` priced `share(i)` bytes instead of its +/// TagN width (a Share-width layout or model). +pub fn expr_len_with(e: &Expr, share: &dyn Fn(u64) -> u64) -> Option { + expr_len_memo(e, share, &mut FxHashMap::default()) +} + +/// `tag0_len(count)` plus the [`expr_len_with`] of every expression, with +/// one pointer memo for all of them (the length of an expression does not +/// depend on where it occurs); `None` if the sum overflows. +pub(crate) fn exprs_len_with<'a>( + count: u64, + exprs: impl Iterator>, + share: &dyn Fn(u64) -> u64, +) -> Option { + let mut memo: FxHashMap<*const Expr, ExprLenInfo> = FxHashMap::default(); + let mut total = tag0_len(count); + for e in exprs { + total = total.checked_add(expr_len_memo(e, share, &mut memo)?)?; + } + Some(total) +} + +#[derive(Clone, Copy)] +pub(crate) struct ExprLenInfo { + /// Standalone length. + len: u64, + /// Telescope count, summed side bytes and tail length when this node is + /// the top of its App/Lam/All spine. + count: u64, + sum: u64, + tail: u64, +} + +/// The children of an expression node, without allocating. +pub(crate) fn expr_children(e: &Expr) -> [Option<&Arc>; 3] { + match e { + Expr::Prj(_, _, v) => [Some(v), None, None], + Expr::App(a, b) | Expr::Lam(_, a, b) | Expr::All(_, _, a, b) => { + [Some(a), Some(b), None] + }, + Expr::Let(_, a, b, c) => [Some(a), Some(b), Some(c)], + _ => [None, None, None], + } +} + +/// [`expr_len_with`] with a caller-provided pointer memo. +fn expr_len_memo( + e: &Expr, + share: &dyn Fn(u64) -> u64, + memo: &mut FxHashMap<*const Expr, ExprLenInfo>, +) -> Option { + let mut stack: Vec<(&Expr, bool)> = vec![(e, false)]; + while let Some((node, ready)) = stack.pop() { + let key = std::ptr::from_ref(node); + if memo.contains_key(&key) { + continue; + } + let children = expr_children(node); + if !ready && children[0].is_some() { + stack.push((node, true)); + for child in children.into_iter().flatten() { + if !memo.contains_key(&Arc::as_ptr(child)) { + stack.push((child.as_ref(), false)); + } + } + continue; + } + let info = expr_len_info(node, &|c| memo[&Arc::as_ptr(c)], share)?; + memo.insert(key, info); + } + memo.get(&std::ptr::from_ref(e)).map(|i| i.len) +} + +/// The [`ExprLenInfo`] of one node from those of its children (`None` if +/// a length overflows). +pub(crate) fn expr_len_info( + node: &Expr, + get: &dyn Fn(&Arc) -> ExprLenInfo, + share: &dyn Fn(u64) -> u64, +) -> Option { + type Info = ExprLenInfo; + fn leaf(len: u64) -> Info { + Info { len, count: 0, sum: 0, tail: 0 } + } + Some(match node { + Expr::Sort(n) | Expr::Var(n) | Expr::Str(n) | Expr::Nat(n) => { + leaf(tag4_len(*n)) + }, + Expr::Share(n) => leaf(share(*n)), + Expr::Ref(n, us) | Expr::Rec(n, us) => { + let mut len = tag4_len(usize_u64(us.len())?).checked_add(tag0_len(*n))?; + for u in us { + len = len.checked_add(tag0_len(*u))?; + } + leaf(len) + }, + Expr::Prj(t, f, v) => { + leaf(tag4_len(*f).checked_add(tag0_len(*t))?.checked_add(get(v).len)?) + }, + Expr::Let(c, ty, v, b) => leaf( + tag4_len(c.flags()) + .checked_add(1)? + .checked_add(get(ty).len)? + .checked_add(get(v).len)? + .checked_add(get(b).len)?, + ), + Expr::App(f, a) => { + let (count, sum, tail) = if matches!(f.as_ref(), Expr::App(..)) { + let fi = get(f); + (fi.count.checked_add(1)?, fi.sum.checked_add(get(a).len)?, fi.tail) + } else { + (1, get(a).len, get(f).len) + }; + let len = tag4_len(count).checked_add(sum)?.checked_add(tail)?; + Info { len, count, sum, tail } + }, + Expr::Lam(_, ty, b) | Expr::All(_, _, ty, b) => { + let all = matches!(node, Expr::All(..)); + let same = if all { + matches!(b.as_ref(), Expr::All(..)) + } else { + matches!(b.as_ref(), Expr::Lam(..)) + }; + let side = get(ty).len.checked_add(1)?; + let (count, sum, tail) = if same { + let bi = get(b); + (bi.count.checked_add(1)?, bi.sum.checked_add(side)?, bi.tail) + } else { + (1, side, get(b).len) + }; + let len = tag4_len(count).checked_add(sum)?.checked_add(tail)?; + Info { len, count, sum, tail } + }, + }) +} + +impl ExprLenInfo { + pub(crate) const ZERO: ExprLenInfo = + ExprLenInfo { len: 0, count: 0, sum: 0, tail: 0 }; + + /// The standalone length. + pub(crate) fn len(self) -> u64 { + self.len + } +} + +/// Exact length of a sharing table: its TagN count plus every entry. +pub fn sharing_table_len(table: &[Arc]) -> Option { + let mut len = tag0_len(usize_u64(table.len())?); + for e in table { + len = len.checked_add(expr_len(e)?)?; + } + Some(len) +} + +fn definition_fixed(lvls: u64) -> u64 { + 1 + tag0_len(lvls) +} + +fn recursor_fixed(r: &Recursor) -> Option { + let mut len = 1 + tag0_len(r.lvls); + for x in [r.params, r.indices, r.motives, r.minors] { + len = len.checked_add(tag0_len(x))?; + } + len = len.checked_add(tag0_len(usize_u64(r.rules.len())?))?; + for rule in &r.rules { + len = len.checked_add(tag0_len(rule.fields))?; + } + Some(len) +} + +fn constructor_fixed(c: &Constructor) -> Option { + let mut len = 1u64; + for x in [c.lvls, c.cidx, c.params, c.fields] { + len = len.checked_add(tag0_len(x))?; + } + Some(len) +} + +fn inductive_fixed(i: &Inductive) -> Option { + let mut len = 1u64; + for x in [i.lvls, i.params, i.indices] { + len = len.checked_add(tag0_len(x))?; + } + len = len.checked_add(tag0_len(usize_u64(i.ctors.len())?))?; + for c in &i.ctors { + len = len.checked_add(constructor_fixed(c)?)?; + } + Some(len) +} + +fn mut_const_fixed(m: &MutConst) -> Option { + let body = match m { + MutConst::Defn(d) => definition_fixed(d.lvls), + MutConst::Indc(i) => inductive_fixed(i)?, + MutConst::Recr(r) => recursor_fixed(r)?, + }; + body.checked_add(1) +} + +/// Exact length of every byte of `c` except its root expressions (as listed +/// by [`constant_info_root_exprs`]) and its whole sharing table, including +/// the table's TagN count. +pub fn constant_fixed_len(c: &Constant) -> Option { + let info = match &c.info { + ConstantInfo::Muts(ms) => { + let mut len = tag4_len(usize_u64(ms.len())?); + for m in ms { + len = len.checked_add(mut_const_fixed(m)?)?; + } + len + }, + other => { + let header = tag4_len(other.variant()?); + let body = match other { + ConstantInfo::Defn(d) => definition_fixed(d.lvls), + ConstantInfo::Recr(r) => recursor_fixed(r)?, + ConstantInfo::Axio(a) => definition_fixed(a.lvls), + ConstantInfo::Quot(q) => definition_fixed(q.lvls), + ConstantInfo::CPrj(p) => { + tag0_len(p.idx).checked_add(tag0_len(p.cidx))?.checked_add(32)? + }, + ConstantInfo::RPrj(p) => tag0_len(p.idx).checked_add(32)?, + ConstantInfo::IPrj(p) => tag0_len(p.idx).checked_add(32)?, + ConstantInfo::DPrj(p) => tag0_len(p.idx).checked_add(32)?, + ConstantInfo::Muts(_) => return None, + }; + header.checked_add(body)? + }, + }; + let refs = usize_u64(c.refs.len())?; + let mut len = info + .checked_add(tag0_len(refs))? + .checked_add(refs.checked_mul(32)?)? + .checked_add(tag0_len(usize_u64(c.univs.len())?))?; + let mut scratch = Vec::new(); + for u in &c.univs { + scratch.clear(); + put_univ(u, &mut scratch); + len = len.checked_add(usize_u64(scratch.len())?)?; + } + Some(len) +} + +/// Exact `Constant::put` length, decomposed as fixed bytes + roots + table. +pub fn constant_len(c: &Constant) -> Option { + let mut len = constant_fixed_len(c)?; + for root in constant_info_root_exprs(&c.info) { + len = len.checked_add(expr_len(&root)?)?; + } + len.checked_add(sharing_table_len(&c.sharing)?) +} diff --git a/crates/ixon/src/sharing_exact/dag.rs b/crates/ixon/src/sharing_exact/dag.rs new file mode 100644 index 000000000..ed4c64570 --- /dev/null +++ b/crates/ixon/src/sharing_exact/dag.rs @@ -0,0 +1,910 @@ +//! Hash-consed structural DAG of the expanded roots and its §3.2 term IDs. +//! +//! Interning uses a hash map keyed by the complete structural [`Node`]; the +//! hash only accelerates lookup and equality is decided by `Eq` on every +//! constructor, scalar, contract and child, so hash collisions cannot merge +//! distinct terms. Share leaves of an input table resolve to the interned ID +//! of the referenced entry, which expands the table without materializing its +//! occurrence tree. + +use std::sync::Arc; + +use rustc_hash::{FxHashMap, FxHashSet}; + +use super::cost::{Len, tag0_len, tag4_len}; +use super::{ + FormatBound, MalformedSharing, Meter, ShareLocation, SharingError, +}; +use crate::contract::{ + BinderContract, LetContract, ValueContract, pack_all_contract, +}; +use crate::expr::Expr; + +/// Structural term ID: position in the §3.2 order. +pub type TermId = u32; + +pub(crate) fn ix(t: TermId) -> usize { + usize::try_from(t).unwrap_or(usize::MAX) +} + +/// One distinct expanded subterm; children are term IDs. +#[derive(Clone, Debug, PartialEq, Eq, Hash)] +pub enum Node { + Sort(u64), + Var(u64), + Ref(u64, Vec), + Rec(u64, Vec), + Prj(u64, u64, TermId), + Str(u64), + Nat(u64), + App(TermId, TermId), + Lam(BinderContract, TermId, TermId), + All(BinderContract, ValueContract, TermId, TermId), + Let(LetContract, TermId, TermId, TermId), +} + +/// Ordered children of a node (at most three). +#[derive(Clone, Copy, Debug)] +pub struct Children { + ids: [TermId; 3], + len: u8, +} + +impl Children { + pub fn as_slice(&self) -> &[TermId] { + &self.ids[..usize::from(self.len)] + } +} + +/// Telescope family of App, Lam and All nodes. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum Family { + App, + Lam, + All, +} + +/// §3.2 sort key: constructor tag, scalar payload, ordered child IDs. The +/// derived order compares fields in that order, integers numerically and +/// vectors lexicographically with a proper prefix first. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct NodeKey { + pub tag: u8, + pub scalars: Vec, + pub children: Vec, +} + +fn u64_len(n: usize) -> u64 { + u64::try_from(n).unwrap_or(u64::MAX) +} + +impl Node { + /// Constructor tag (the TagN expression flag). + pub fn tag(&self) -> u8 { + match self { + Node::Sort(_) => Expr::FLAG_SORT, + Node::Var(_) => Expr::FLAG_VAR, + Node::Ref(..) => Expr::FLAG_REF, + Node::Rec(..) => Expr::FLAG_REC, + Node::Prj(..) => Expr::FLAG_PRJ, + Node::Str(_) => Expr::FLAG_STR, + Node::Nat(_) => Expr::FLAG_NAT, + Node::App(..) => Expr::FLAG_APP, + Node::Lam(..) => Expr::FLAG_LAM, + Node::All(..) => Expr::FLAG_ALL, + Node::Let(..) => Expr::FLAG_LET, + } + } + + /// The §3.2 scalar payload vector. + pub fn scalars(&self) -> Vec { + match self { + Node::Sort(n) | Node::Var(n) | Node::Str(n) | Node::Nat(n) => vec![*n], + Node::Ref(n, us) | Node::Rec(n, us) => { + let mut v = Vec::with_capacity(us.len() + 2); + v.push(*n); + v.push(u64_len(us.len())); + v.extend_from_slice(us); + v + }, + Node::Prj(t, f, _) => vec![*t, *f], + Node::App(..) => vec![], + Node::Lam(c, ..) => vec![u64::from(c.to_bits())], + Node::All(c, v, ..) => vec![u64::from(pack_all_contract(*c, *v))], + Node::Let(c, ..) => vec![c.flags(), u64::from(c.binder.to_bits())], + } + } + + pub fn children(&self) -> Children { + let (ids, len) = match self { + Node::Sort(_) + | Node::Var(_) + | Node::Ref(..) + | Node::Rec(..) + | Node::Str(_) + | Node::Nat(_) => ([0; 3], 0), + Node::Prj(_, _, v) => ([*v, 0, 0], 1), + Node::App(a, b) | Node::Lam(_, a, b) | Node::All(_, _, a, b) => { + ([*a, *b, 0], 2) + }, + Node::Let(_, a, b, c) => ([*a, *b, *c], 3), + }; + Children { ids, len } + } + + pub(crate) fn family(&self) -> Option { + match self { + Node::App(..) => Some(Family::App), + Node::Lam(..) => Some(Family::Lam), + Node::All(..) => Some(Family::All), + _ => None, + } + } + + /// Bytes this node contributes besides its children and, for App/Lam/All, + /// besides the per-telescope TagN header: the whole encoding of a leaf, + /// Prj/Let headers, and the contract byte of each Lam/All binder. + pub(crate) fn own_len(&self) -> Len { + match self { + Node::Sort(n) | Node::Var(n) | Node::Str(n) | Node::Nat(n) => { + Len::new(tag4_len(*n)) + }, + Node::Ref(n, us) | Node::Rec(n, us) => { + let mut len = + Len::new(tag4_len(u64_len(us.len()))).plus_u64(tag0_len(*n)); + for u in us { + len = len.plus_u64(tag0_len(*u)); + } + len + }, + Node::Prj(t, f, _) => Len::new(tag4_len(*f)).plus_u64(tag0_len(*t)), + Node::App(..) => Len::ZERO, + Node::Lam(..) | Node::All(..) => Len::new(1), + Node::Let(c, ..) => Len::new(tag4_len(c.flags())).plus_u64(1), + } + } + + fn map_children(&self, f: impl Fn(TermId) -> TermId) -> Node { + match self { + Node::Sort(_) + | Node::Var(_) + | Node::Ref(..) + | Node::Rec(..) + | Node::Str(_) + | Node::Nat(_) => self.clone(), + Node::Prj(t, i, v) => Node::Prj(*t, *i, f(*v)), + Node::App(a, b) => Node::App(f(*a), f(*b)), + Node::Lam(c, a, b) => Node::Lam(*c, f(*a), f(*b)), + Node::All(c, v, a, b) => Node::All(*c, *v, f(*a), f(*b)), + Node::Let(c, a, b, d) => Node::Let(*c, f(*a), f(*b), f(*d)), + } + } + + /// Rebuild an expression node with the given child expressions. + pub fn to_expr(&self, child: impl Fn(TermId) -> Arc) -> Expr { + match self { + Node::Sort(n) => Expr::Sort(*n), + Node::Var(n) => Expr::Var(*n), + Node::Ref(n, us) => Expr::Ref(*n, us.clone()), + Node::Rec(n, us) => Expr::Rec(*n, us.clone()), + Node::Prj(t, i, v) => Expr::Prj(*t, *i, child(*v)), + Node::Str(n) => Expr::Str(*n), + Node::Nat(n) => Expr::Nat(*n), + Node::App(a, b) => Expr::App(child(*a), child(*b)), + Node::Lam(c, a, b) => Expr::Lam(*c, child(*a), child(*b)), + Node::All(c, v, a, b) => Expr::All(*c, *v, child(*a), child(*b)), + Node::Let(c, a, b, d) => Expr::Let(*c, child(*a), child(*b), child(*d)), + } + } + + pub(crate) fn from_leaf(e: &Expr) -> Option { + Some(match e { + Expr::Sort(n) => Node::Sort(*n), + Expr::Var(n) => Node::Var(*n), + Expr::Ref(n, us) => Node::Ref(*n, us.clone()), + Expr::Rec(n, us) => Node::Rec(*n, us.clone()), + Expr::Str(n) => Node::Str(*n), + Expr::Nat(n) => Node::Nat(*n), + _ => return None, + }) + } +} + +/// The distinct expanded subterms of ordered roots, indexed by §3.2 term ID. +/// +/// IDs are assigned by increasing height, then by [`NodeKey`]; every child +/// therefore has a smaller ID than its parent. Only subterms reachable from +/// the roots are present, so unreachable entries of an input table cannot +/// influence IDs. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SharingDag { + nodes: Vec, + heights: Vec, + roots: Vec, +} + +/// How Share leaves are resolved while interning one expression. +#[derive(Clone, Copy)] +enum ShareCtx<'a> { + /// Input must be fully expanded; `root` names the root for errors. + Forbidden { root: u64 }, + /// Table expansion: `resolved` are the IDs of the entries this location + /// may reference (a prefix of `table`). + Table { + table: &'a [Arc], + resolved: &'a [TermId], + location: ShareLocation, + }, +} + +struct Builder<'m, 'l> { + nodes: Vec, + heights: Vec, + index: FxHashMap, + meter: &'m mut Meter<'l>, +} + +impl Builder<'_, '_> { + fn intern(&mut self, node: Node) -> Result { + if let Some(&id) = self.index.get(&node) { + return Ok(id); + } + let mut height: u32 = 0; + for &c in node.children().as_slice() { + let h = self.heights[ix(c)].checked_add(1).ok_or_else(|| { + SharingError::FormatBound(FormatBound::TermIdSpace { + nodes: u64_len(self.nodes.len()), + }) + })?; + height = height.max(h); + } + self.meter.height(u64::from(height))?; + let count = u64_len(self.nodes.len()) + 1; + self.meter.distinct_nodes(count)?; + let id = TermId::try_from(self.nodes.len()) + .ok() + .filter(|id| *id != TermId::MAX) + .ok_or(SharingError::FormatBound(FormatBound::TermIdSpace { + nodes: count, + }))?; + self.nodes.push(node.clone()); + self.heights.push(height); + self.index.insert(node, id); + Ok(id) + } + + fn resolve_share( + &mut self, + index: u64, + ctx: ShareCtx<'_>, + ) -> Result { + match ctx { + ShareCtx::Forbidden { root } => { + Err(SharingError::Malformed(MalformedSharing::UnresolvedShare { + root, + index, + })) + }, + ShareCtx::Table { table, resolved, location } => { + if let Some(&id) = + usize::try_from(index).ok().and_then(|i| resolved.get(i)) + { + return Ok(id); + } + let table_len = u64_len(table.len()); + match location { + ShareLocation::Entry(entry) if index < table_len => { + Err(classify_nonbackward(table, entry, index, self.meter)) + }, + _ => { + Err(SharingError::Malformed(MalformedSharing::ShareOutOfRange { + location, + index, + table_len, + })) + }, + } + }, + } + } + + /// Intern one expression tree, iteratively and memoized by pointer. + /// + /// The pointer memo is shared across the entries and roots of one build. + /// They are processed in order of increasing reference bound, so a + /// pointer validated under a smaller bound stays valid under a larger one. + fn intern_expr( + &mut self, + root: &Arc, + memo: &mut FxHashMap<*const Expr, TermId>, + ctx: ShareCtx<'_>, + ) -> Result { + let mut stack: Vec<(&Expr, bool)> = vec![(root.as_ref(), false)]; + while let Some((e, ready)) = stack.pop() { + let key = std::ptr::from_ref(e); + if memo.contains_key(&key) { + continue; + } + if !ready { + self.meter.input_node()?; + if let Expr::Share(i) = e { + let id = self.resolve_share(*i, ctx)?; + memo.insert(key, id); + continue; + } + if let Some(leaf) = Node::from_leaf(e) { + let id = self.intern(leaf)?; + memo.insert(key, id); + continue; + } + stack.push((e, true)); + for c in super::cost::expr_children(e).into_iter().flatten() { + if !memo.contains_key(&Arc::as_ptr(c)) { + stack.push((c.as_ref(), false)); + } + } + continue; + } + let id = |c: &Arc| memo[&Arc::as_ptr(c)]; + let node = match e { + Expr::Prj(t, f, v) => Node::Prj(*t, *f, id(v)), + Expr::App(a, b) => Node::App(id(a), id(b)), + Expr::Lam(c, a, b) => Node::Lam(*c, id(a), id(b)), + Expr::All(c, v, a, b) => Node::All(*c, *v, id(a), id(b)), + Expr::Let(c, a, b, d) => Node::Let(*c, id(a), id(b), id(d)), + _ => { + return Err(SharingError::Internal( + "leaf reached the compound interning path".into(), + )); + }, + }; + let id = self.intern(node)?; + memo.insert(key, id); + } + memo.get(&Arc::as_ptr(root)).copied().ok_or_else(|| { + SharingError::Internal("interned root missing from memo".into()) + }) + } + + /// Keep the subterms reachable from `roots` and renumber them by §3.2. + fn finalize( + self, + roots: &[TermId], + ) -> Result<(SharingDag, Vec), SharingError> { + let n = self.nodes.len(); + let mut reach = vec![false; n]; + for &r in roots { + reach[ix(r)] = true; + } + // Children were interned before their parents, so they have smaller + // provisional IDs and a descending sweep propagates reachability. + for p in (0..n).rev() { + if reach[p] { + for &c in self.nodes[p].children().as_slice() { + reach[ix(c)] = true; + } + } + } + let max_h = + (0..n).filter(|&p| reach[p]).map(|p| self.heights[p]).max().unwrap_or(0); + let mut buckets: Vec> = + vec![Vec::new(); usize::try_from(max_h).unwrap_or(0) + 1]; + for p in (0..n).filter(|&p| reach[p]) { + buckets[usize::try_from(self.heights[p]).unwrap_or(0)].push(p); + } + let mut new_id = vec![TermId::MAX; n]; + let mut nodes = Vec::new(); + let mut heights = Vec::new(); + let mut next: TermId = 0; + for (h, mut keyed) in buckets.into_iter().enumerate() { + // Sorted by the [`NodeKey`] order (compared in place), then by the + // provisional ID, as sorting `(NodeKey, usize)` pairs. + let key_cmp = |a: usize, b: usize| { + node_key_cmp(&self.nodes[a], &self.nodes[b], &new_id) + }; + keyed.sort_by(|&a, &b| key_cmp(a, b).then(a.cmp(&b))); + for w in keyed.windows(2) { + if key_cmp(w[0], w[1]) == std::cmp::Ordering::Equal { + return Err(SharingError::Internal( + "two interned nodes share one structural key".into(), + )); + } + } + let h = u32::try_from(h) + .map_err(|_e| SharingError::Internal("height exceeds u32".into()))?; + for p in keyed { + new_id[p] = next; + next = next.checked_add(1).ok_or(SharingError::FormatBound( + FormatBound::TermIdSpace { nodes: u64_len(n) }, + ))?; + nodes.push(self.nodes[p].map_children(|c| new_id[ix(c)])); + heights.push(h); + } + } + let roots = roots.iter().map(|&r| new_id[ix(r)]).collect(); + let dag = SharingDag { nodes, heights, roots }; + Ok((dag, new_id)) + } +} + +/// The scalar payload of a node other than `Ref`/`Rec` ([`Node::scalars`], +/// at most two values), without allocating. +fn small_scalars(node: &Node) -> ([u64; 2], usize) { + match node { + Node::Sort(n) | Node::Var(n) | Node::Str(n) | Node::Nat(n) => ([*n, 0], 1), + Node::Prj(t, f, _) => ([*t, *f], 2), + Node::Lam(c, ..) => ([u64::from(c.to_bits()), 0], 1), + Node::All(c, v, ..) => ([u64::from(pack_all_contract(*c, *v)), 0], 1), + Node::Let(c, ..) => ([c.flags(), u64::from(c.binder.to_bits())], 2), + Node::App(..) | Node::Ref(..) | Node::Rec(..) => ([0, 0], 0), + } +} + +/// The order of the [`NodeKey`]s of two nodes (tag, scalar payload, child +/// IDs mapped by `ids`), compared in place. +fn node_key_cmp(a: &Node, b: &Node, ids: &[TermId]) -> std::cmp::Ordering { + a.tag() + .cmp(&b.tag()) + .then_with(|| match (a, b) { + ( + Node::Ref(n, us) | Node::Rec(n, us), + Node::Ref(m, vs) | Node::Rec(m, vs), + ) => { + // `[n, |us|, us...]`, lexicographically. + n.cmp(m).then(us.len().cmp(&vs.len())).then_with(|| us.cmp(vs)) + }, + _ => { + let ((x, i), (y, j)) = (small_scalars(a), small_scalars(b)); + x[..i].cmp(&y[..j]) + }, + }) + .then_with(|| { + let (ca, cb) = (a.children(), b.children()); + ca.as_slice() + .iter() + .map(|&c| ids[ix(c)]) + .cmp(cb.as_slice().iter().map(|&c| ids[ix(c)])) + }) +} + +/// Classify a reference from `entry` to `index`, with +/// `entry <= index < table.len()`: a cycle if `index` can reach `entry` +/// through Share edges, otherwise a forward reference. +fn classify_nonbackward( + table: &[Arc], + entry: u64, + index: u64, + meter: &mut Meter<'_>, +) -> SharingError { + let forward = + SharingError::Malformed(MalformedSharing::ForwardShare { entry, index }); + let cyclic = + SharingError::Malformed(MalformedSharing::CyclicShare { entry, index }); + if index == entry { + return cyclic; + } + let mut visited: FxHashSet = FxHashSet::default(); + let mut todo = vec![index]; + while let Some(j) = todo.pop() { + if !visited.insert(j) { + continue; + } + let Some(e) = usize::try_from(j).ok().and_then(|j| table.get(j)) else { + continue; + }; + let mut seen: FxHashSet<*const Expr> = FxHashSet::default(); + let mut stack: Vec<&Expr> = vec![e.as_ref()]; + while let Some(x) = stack.pop() { + if !seen.insert(std::ptr::from_ref(x)) { + continue; + } + if let Err(err) = meter.input_node() { + return err; + } + if let Expr::Share(k) = x { + if *k == entry { + return cyclic; + } + todo.push(*k); + } + stack.extend(x.children().into_iter().map(|c| c.as_ref())); + } + } + forward +} + +impl SharingDag { + /// Build from roots; with `table`, Share leaves are expanded against it + /// under the backward-reference rule, otherwise they are rejected. + pub(crate) fn build( + roots: &[Arc], + table: Option<&[Arc]>, + meter: &mut Meter<'_>, + ) -> Result { + Self::build_full(roots, table, meter).map(|(dag, _)| dag) + } + + /// [`SharingDag::build`], also returning the term ID each table entry + /// expands to (`None` for an entry no root reaches). + pub(crate) fn build_full( + roots: &[Arc], + table: Option<&[Arc]>, + meter: &mut Meter<'_>, + ) -> Result<(SharingDag, Vec>), SharingError> { + let mut b = Builder { + nodes: Vec::new(), + heights: Vec::new(), + index: FxHashMap::default(), + meter, + }; + let mut memo: FxHashMap<*const Expr, TermId> = FxHashMap::default(); + let mut root_ids = Vec::with_capacity(roots.len()); + let mut entry_ids: Vec = Vec::new(); + match table { + None => { + for (i, r) in roots.iter().enumerate() { + let ctx = ShareCtx::Forbidden { root: u64_len(i) }; + root_ids.push(b.intern_expr(r, &mut memo, ctx)?); + } + }, + Some(table) => { + let mut resolved: Vec = Vec::with_capacity(table.len()); + for (j, e) in table.iter().enumerate() { + let ctx = ShareCtx::Table { + table, + resolved: &resolved, + location: ShareLocation::Entry(u64_len(j)), + }; + let id = b.intern_expr(e, &mut memo, ctx)?; + resolved.push(id); + entry_ids.push(id); + } + for (i, r) in roots.iter().enumerate() { + let ctx = ShareCtx::Table { + table, + resolved: &resolved, + location: ShareLocation::Root(u64_len(i)), + }; + root_ids.push(b.intern_expr(r, &mut memo, ctx)?); + } + }, + } + let (dag, new_id) = b.finalize(&root_ids)?; + let entries = entry_ids + .iter() + .map(|&p| Some(new_id[ix(p)]).filter(|&id| id != TermId::MAX)) + .collect(); + Ok((dag, entries)) + } + + /// Whether the table `entries` and `roots` expand exactly to the terms + /// `order` and to this DAG's roots, decided without interning: every + /// expression is matched top-down against the term it must denote, a Share + /// in entry `i` must name an entry `< i` and one in a root an entry `< + /// entries.len()`, memoized by pointer (a pointer checked under a smaller + /// bound stays valid under a larger one). On success returns the number of + /// pointer-distinct expression nodes reachable from `entries` and + /// `roots`. + /// + /// A success implies that [`SharingDag::build_full`]`(roots, + /// Some(entries))` returns this DAG and the entry IDs `order` (the + /// expansions are the same terms, and the DAG and its IDs are a function of + /// the terms reachable from the roots), and that its only possible error is + /// exhausting `max_input_nodes`: it charges one input node per + /// pointer-distinct node (its pointer memo is shared by all entries and + /// roots, and a pointer is only revisited after it was memoized), interns + /// the same distinct nodes at the same heights as the build of this DAG, + /// and finds no malformed Share. `None` means a mismatch; callers then run + /// the build itself. + pub(crate) fn check_encoding( + &self, + order: &[TermId], + entries: &[Arc], + roots: &[Arc], + ) -> Option { + if entries.len() != order.len() || roots.len() != self.roots.len() { + return None; + } + let mut memo: FxHashMap<*const Expr, TermId> = FxHashMap::default(); + let mut stack: Vec<(&Expr, TermId)> = Vec::new(); + let tasks = entries + .iter() + .zip(order) + .enumerate() + .map(|(i, (e, &t))| (e, t, i)) + .chain( + roots.iter().zip(&self.roots).map(|(e, &t)| (e, t, entries.len())), + ); + for (e, t, bound) in tasks { + stack.push((e.as_ref(), t)); + while let Some((x, t)) = stack.pop() { + let key = std::ptr::from_ref(x); + match memo.get(&key) { + Some(&u) if u == t => continue, + Some(_) => return None, + None => {}, + } + let node = self.nodes.get(ix(t))?; + let ok = match (x, node) { + (Expr::Share(k), _) => { + usize::try_from(*k).ok().is_some_and(|k| k < bound && order[k] == t) + }, + (Expr::Sort(a), Node::Sort(b)) + | (Expr::Var(a), Node::Var(b)) + | (Expr::Str(a), Node::Str(b)) + | (Expr::Nat(a), Node::Nat(b)) => a == b, + (Expr::Ref(a, us), Node::Ref(b, vs)) + | (Expr::Rec(a, us), Node::Rec(b, vs)) => a == b && us == vs, + (Expr::Prj(a, f, v), Node::Prj(b, g, tv)) => { + stack.push((v.as_ref(), *tv)); + a == b && f == g + }, + (Expr::App(f, a), Node::App(tf, ta)) => { + stack.push((a.as_ref(), *ta)); + stack.push((f.as_ref(), *tf)); + true + }, + (Expr::Lam(c, ty, b), Node::Lam(d, tty, tb)) => { + stack.push((b.as_ref(), *tb)); + stack.push((ty.as_ref(), *tty)); + c == d + }, + (Expr::All(c, v, ty, b), Node::All(d, u, tty, tb)) => { + stack.push((b.as_ref(), *tb)); + stack.push((ty.as_ref(), *tty)); + c == d && v == u + }, + (Expr::Let(c, ty, v, b), Node::Let(d, tty, tv, tb)) => { + stack.push((b.as_ref(), *tb)); + stack.push((v.as_ref(), *tv)); + stack.push((ty.as_ref(), *tty)); + c == d + }, + _ => false, + }; + if !ok { + return None; + } + memo.insert(key, t); + } + } + u64::try_from(memo.len()).ok() + } + + /// [`SharingDag::check_encoding`] and, in the same walk with the same + /// pointer memo, the length `exprs_len_with(entries.len(), entries ++ + /// roots, share)`. `None` on a mismatch or a length overflow (callers then + /// run the separate checks); otherwise the visited count and the length. + pub(crate) fn check_and_measure( + &self, + order: &[TermId], + entries: &[Arc], + roots: &[Arc], + share: &dyn Fn(u64) -> u64, + ) -> Option<(u64, u64)> { + use super::cost::{ExprLenInfo, expr_children, expr_len_info}; + if entries.len() != order.len() || roots.len() != self.roots.len() { + return None; + } + // Per pointer: the term it denotes and, once its children are done, its + // length information. + let mut memo: FxHashMap<*const Expr, (TermId, Option)> = + FxHashMap::default(); + let mut stack: Vec<(&Expr, TermId, bool)> = Vec::new(); + let mut total = tag0_len(u64_len(entries.len())); + let tasks = entries + .iter() + .zip(order) + .enumerate() + .map(|(i, (e, &t))| (e, t, i)) + .chain( + roots.iter().zip(&self.roots).map(|(e, &t)| (e, t, entries.len())), + ); + for (e, t, bound) in tasks { + stack.push((e.as_ref(), t, false)); + while let Some((x, t, ready)) = stack.pop() { + let key = std::ptr::from_ref(x); + if ready { + let info = { + let get = |c: &Arc| { + memo + .get(&Arc::as_ptr(c)) + .and_then(|m| m.1) + .unwrap_or(ExprLenInfo::ZERO) + }; + expr_len_info(x, &get, share)? + }; + memo.insert(key, (t, Some(info))); + continue; + } + match memo.get(&key) { + Some(&(u, _)) if u == t => continue, + Some(_) => return None, + None => {}, + } + let node = self.nodes.get(ix(t))?; + let mut kids: [Option; 3] = [None; 3]; + let ok = match (x, node) { + (Expr::Share(k), _) => { + usize::try_from(*k).ok().is_some_and(|k| k < bound && order[k] == t) + }, + (Expr::Sort(a), Node::Sort(b)) + | (Expr::Var(a), Node::Var(b)) + | (Expr::Str(a), Node::Str(b)) + | (Expr::Nat(a), Node::Nat(b)) => a == b, + (Expr::Ref(a, us), Node::Ref(b, vs)) + | (Expr::Rec(a, us), Node::Rec(b, vs)) => a == b && us == vs, + (Expr::Prj(a, f, _), Node::Prj(b, g, tv)) => { + kids[0] = Some(*tv); + a == b && f == g + }, + (Expr::App(..), Node::App(tf, ta)) => { + kids = [Some(*tf), Some(*ta), None]; + true + }, + (Expr::Lam(c, ..), Node::Lam(d, tty, tb)) => { + kids = [Some(*tty), Some(*tb), None]; + c == d + }, + (Expr::All(c, v, ..), Node::All(d, u, tty, tb)) => { + kids = [Some(*tty), Some(*tb), None]; + c == d && v == u + }, + (Expr::Let(c, ..), Node::Let(d, tty, tv, tb)) => { + kids = [Some(*tty), Some(*tv), Some(*tb)]; + c == d + }, + _ => false, + }; + if !ok { + return None; + } + memo.insert(key, (t, None)); + stack.push((x, t, true)); + for (c, tc) in expr_children(x).into_iter().zip(kids).rev() { + if let (Some(c), Some(tc)) = (c, tc) { + stack.push((c.as_ref(), tc, false)); + } + } + } + total = total + .checked_add(memo.get(&std::ptr::from_ref(e.as_ref()))?.1?.len())?; + } + Some((u64::try_from(memo.len()).ok()?, total)) + } + + /// The only error the re-expansion build can report once + /// [`SharingDag::check_encoding`] (or [`SharingDag::check_and_measure`]) + /// succeeded with `visited` nodes: `max_input_nodes` exhausted. + pub(crate) fn check_input_nodes( + &self, + visited: u64, + limits: &super::ExactSharingLimits, + ) -> Result<(), SharingError> { + if visited > limits.max_input_nodes { + return Err(SharingError::ResourceExhausted(super::ResourceExhausted { + resource: super::Resource::InputNodes, + limit: limits.max_input_nodes, + })); + } + Ok(()) + } + + /// The re-expansion check of an encoding of this DAG with table terms + /// `order`: `build_full(roots, Some(entries))` under a fresh meter of + /// `limits` must return this DAG and the entry IDs `order`, otherwise the + /// internal error `ast_msg` or `ids_msg`. + /// + /// When [`SharingDag::check_encoding`] succeeds the build would succeed, + /// unless its node count exceeds `max_input_nodes`, so only that limit is + /// checked; otherwise the build itself runs and reports. + pub(crate) fn check_reexpansion( + &self, + order: &[TermId], + entries: &[Arc], + roots: &[Arc], + limits: &super::ExactSharingLimits, + ast_msg: &str, + ids_msg: &str, + ) -> Result<(), SharingError> { + if let Some(visited) = self.check_encoding(order, entries, roots) { + return self.check_input_nodes(visited, limits); + } + let mut check_meter = Meter::new(limits); + let (check, entry_ids) = + SharingDag::build_full(roots, Some(entries), &mut check_meter)?; + if check != *self { + return Err(SharingError::Internal(ast_msg.into())); + } + if entry_ids + .iter() + .map(|x| x.unwrap_or(TermId::MAX)) + .ne(order.iter().copied()) + { + return Err(SharingError::Internal(ids_msg.into())); + } + Ok(()) + } + + /// Build from fully expanded roots; any Share leaf is an error. + pub fn from_expanded_roots( + roots: &[Arc], + limits: &super::ExactSharingLimits, + ) -> Result { + Self::build(roots, None, &mut Meter::new(limits)) + } + + /// Build by expanding `roots` against `table` (entry `i` may reference + /// only entries `< i`; roots may reference any entry). + pub fn from_shared( + roots: &[Arc], + table: &[Arc], + limits: &super::ExactSharingLimits, + ) -> Result { + Self::build(roots, Some(table), &mut Meter::new(limits)) + } + + /// Expand a Constant's ordered roots against its own sharing table. + pub fn from_constant( + c: &crate::constant::Constant, + limits: &super::ExactSharingLimits, + ) -> Result { + let roots = super::constant_info_root_exprs(&c.info); + Self::build(&roots, Some(&c.sharing), &mut Meter::new(limits)) + } + + /// Nodes indexed by term ID. + pub fn nodes(&self) -> &[Node] { + &self.nodes + } + + pub fn node(&self, t: TermId) -> &Node { + &self.nodes[ix(t)] + } + + /// Heights indexed by term ID (leaves are 0). + pub fn heights(&self) -> &[u32] { + &self.heights + } + + /// Term IDs of the ordered roots. + pub fn roots(&self) -> &[TermId] { + &self.roots + } + + /// Number of distinct subterms `N`. + pub fn len(&self) -> usize { + self.nodes.len() + } + + pub fn is_empty(&self) -> bool { + self.nodes.is_empty() + } + + /// The §3.2 key of `t`. + pub fn key(&self, t: TermId) -> NodeKey { + let node = self.node(t); + NodeKey { + tag: node.tag(), + scalars: node.scalars(), + children: node.children().as_slice().to_vec(), + } + } + + /// Every term as an expanded expression, indexed by term ID. Built bottom + /// up with one `Arc` per distinct term. + pub fn term_exprs(&self) -> Vec> { + let mut out: Vec> = Vec::with_capacity(self.nodes.len()); + for node in &self.nodes { + let e = node.to_expr(|c| out[ix(c)].clone()); + out.push(Arc::new(e)); + } + out + } + + /// The expanded roots, in order. + pub fn root_exprs(&self) -> Vec> { + let terms = self.term_exprs(); + self.roots.iter().map(|&r| terms[ix(r)].clone()).collect() + } +} diff --git a/crates/ixon/src/sharing_exact/dict.rs b/crates/ixon/src/sharing_exact/dict.rs new file mode 100644 index 000000000..cdd7dcdd1 --- /dev/null +++ b/crates/ixon/src/sharing_exact/dict.rs @@ -0,0 +1,1314 @@ +//! The fixed-dictionary optimizer `C_M` (§5) and byte-least materialization. +//! +//! For a dictionary `M` (available terms and their Share widths), `C_M(t)` +//! is the minimum length of a standalone expression expanding to `t`. The +//! options at `t` are a Share of `t` (if available) and its inline +//! constructor. For App, Lam and All the inline constructor is a telescope +//! over the maximal same-family spine `t = t_0, t_1, ..., t_l` (App follows +//! the function, Lam/All the body; `t_l` is the first node of another +//! constructor). A telescope of `j` spine nodes costs its TagN header for +//! `j`, every side child's standalone cost (App arguments; Lam/All contract +//! byte plus binder type), and its head: for `j < l` the head `t_j` continues +//! the family, so the canonical writer would merge any inline form of it +//! back into the telescope and the only legal head is a Share of `t_j`; for +//! `j = l` the head is the natural tail at its standalone cost. Every +//! canonical telescope boundary is one of these cases, so the recurrence is +//! complete; it is sound because each case is realized by a concrete +//! expression that the canonical writer emits with exactly that header. +//! +//! Children are standalone expressions and their lengths add, so the +//! recurrence runs bottom-up in term-ID order (children have smaller IDs). + +use std::cmp::Ordering; +use std::sync::Arc; + +use rustc_hash::FxHashMap; + +use super::SharingError; +use super::cost::{Len, share_width, tag4_bytes_cmp, tag4_len}; +use super::dag::{Node, SharingDag, TermId, ix}; +use crate::expr::Expr; + +/// Share widths available to one evaluation. +pub(crate) trait Widths { + fn width(&self, t: TermId) -> Option; +} + +/// A dictionary with actual table indices, needed to materialize Shares. +pub(crate) trait Indices: Widths { + fn index(&self, t: TermId) -> Option; +} + +/// The empty dictionary. +pub(crate) struct NoWidths; + +impl Widths for NoWidths { + fn width(&self, _t: TermId) -> Option { + None + } +} + +/// A fixed dictionary: available terms and their actual table indices. +/// Indices need not be consecutive, which lets tests force any width. +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct FixedDictionary { + index: FxHashMap, +} + +impl FixedDictionary { + pub fn new() -> Self { + Self::default() + } + + /// Make `t` available as `Share(index)`; returns a previous index. + pub fn insert(&mut self, t: TermId, index: u64) -> Option { + self.index.insert(t, index) + } + + pub fn index_of(&self, t: TermId) -> Option { + self.index.get(&t).copied() + } + + pub fn len(&self) -> usize { + self.index.len() + } + + pub fn is_empty(&self) -> bool { + self.index.is_empty() + } +} + +impl Widths for FixedDictionary { + fn width(&self, t: TermId) -> Option { + self.index.get(&t).map(|&i| share_width(i)) + } +} + +impl Indices for FixedDictionary { + fn index(&self, t: TermId) -> Option { + self.index_of(t) + } +} + +/// A dense prefix dictionary for table sequences (indices `< 2^32`). +pub(crate) struct DenseIndex { + index: Vec, +} + +impl DenseIndex { + const NONE: u64 = u64::MAX; + + pub(crate) fn new(n: usize) -> Self { + DenseIndex { index: vec![Self::NONE; n] } + } + + pub(crate) fn set(&mut self, t: TermId, i: u64) { + self.index[ix(t)] = i; + } +} + +impl Widths for DenseIndex { + fn width(&self, t: TermId) -> Option { + self.index(t).map(share_width) + } +} + +impl Indices for DenseIndex { + fn index(&self, t: TermId) -> Option { + let i = self.index[ix(t)]; + (i != Self::NONE).then_some(i) + } +} + +/// The representation chosen for one standalone occurrence. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum Choice { + /// A Share of this term's table entry. + Share, + /// The node's own constructor with standalone children (leaf, Prj, Let). + Inline, + /// A telescope of `j >= 1` spine nodes (see the module docs). + Telescope(u64), +} + +/// Scan the telescope options of an App/Lam/All node `t`. +/// +/// Returns the least inline length found and its prefix length `j`. With +/// `ties` unset the scan may stop once no remaining option can be strictly +/// below `min(best, share)`; with `ties` set it stops only once none can +/// reach that value, and among equal lengths it keeps the `j` whose TagN +/// header bytes are least. Remaining options are bounded below by +/// `header(j) + s + 2`: headers never shrink, a further spine node adds a +/// side cost of at least one byte, and every head costs at least one byte. +#[allow(clippy::too_many_arguments)] +fn scan_telescope Len>( + nodes: &[Node], + own: &[Len], + t: TermId, + widths: &W, + cost: &C, + ties: bool, + share: Len, + work: &mut u64, +) -> (Len, u64) { + let family = nodes[ix(t)].family(); + let mut best = Len::OVERFLOW; + let mut best_j: u64 = 0; + let mut cur = t; + let mut j: u64 = 0; + let mut s = Len::ZERO; + loop { + *work = work.saturating_add(1); + let (side, next) = match &nodes[ix(cur)] { + Node::App(f, a) => (cost(*a), *f), + Node::Lam(_, ty, b) | Node::All(_, _, ty, b) => { + (own[ix(cur)].plus(cost(*ty)), *b) + }, + _ => break, + }; + s = s.plus(side); + j = j.saturating_add(1); + let header = Len::new(tag4_len(j)); + let continues = nodes[ix(next)].family() == family; + let head = if continues { + widths.width(next).map(Len::new) + } else { + Some(cost(next)) + }; + if let Some(h) = head { + let len = header.plus(s).plus(h); + if len < best + || (ties && len == best && tag4_bytes_cmp(j, best_j) == Ordering::Less) + { + best = len; + best_j = j; + } + } + if !continues { + break; + } + let lower = header.plus(s).plus_u64(2); + let cap = best.min(share); + if (ties && lower > cap) || (!ties && lower >= cap) { + break; + } + cur = next; + } + (best, best_j) +} + +/// `C_M(t)` given the minimum standalone lengths `cost` of every smaller +/// term. With `ties`, also the pinned byte-least choice among options of +/// that length: any inline form precedes a Share (expression flags +/// `0x0..=0xA` are below the Share flag `0xB`), and telescopes of one node +/// are ordered by their TagN header bytes, which differ for distinct `j`. +/// Once the head is fixed the remaining segments have fixed lengths, so +/// their least bytes are chosen independently by the same rule. +pub(crate) fn eval_node Len>( + nodes: &[Node], + own: &[Len], + t: TermId, + widths: &W, + cost: &C, + ties: bool, + work: &mut u64, +) -> (Len, Choice) { + *work = work.saturating_add(1); + let share = widths.width(t).map_or(Len::OVERFLOW, Len::new); + let o = own[ix(t)]; + let (inline, choice) = match &nodes[ix(t)] { + Node::Sort(_) + | Node::Var(_) + | Node::Ref(..) + | Node::Rec(..) + | Node::Str(_) + | Node::Nat(_) => (o, Choice::Inline), + Node::Prj(_, _, v) => (o.plus(cost(*v)), Choice::Inline), + Node::Let(_, a, b, c) => { + (o.plus(cost(*a)).plus(cost(*b)).plus(cost(*c)), Choice::Inline) + }, + Node::App(..) | Node::Lam(..) | Node::All(..) => { + let (len, j) = + scan_telescope(nodes, own, t, widths, cost, ties, share, work); + (len, Choice::Telescope(j)) + }, + }; + if share < inline { (share, Choice::Share) } else { (inline, choice) } +} + +/// `C_M` for every term, bottom-up. +pub(crate) fn all_costs( + nodes: &[Node], + own: &[Len], + widths: &W, + work: &mut u64, +) -> Vec { + let mut costs: Vec = Vec::with_capacity(nodes.len()); + for t in 0..nodes.len() { + let t = TermId::try_from(t).unwrap_or(TermId::MAX); + let c = eval_node(nodes, own, t, widths, &|x| costs[ix(x)], false, work).0; + costs.push(c); + } + costs +} + +/// `C_M` of every term under a dictionary that grows one term at a time +/// ([`IncrementalCosts::add`]), with the work count of a full [`all_costs`] +/// evaluation of the current dictionary ([`IncrementalCosts::work`]). +/// +/// Only terms whose evaluation can read a changed value are evaluated again. +/// [`eval_node`] at `t` reads `width(t)`; for a non-telescope node the costs +/// of its children; for an App/Lam/All node, along its spine `t = s_0, s_1, +/// ...` ([`scan_telescope`], which may stop earlier, so this is a superset), +/// the cost of every side child, the width of every spine successor of the +/// same family and the cost of the first successor of another family. So +/// after `width(t)` changes, `t` is evaluated again, and so is every parent +/// `p` of an evaluated term `x` such that `p` reads the cost of `x` and it +/// changed, or `x` continues the spine of `p` and either `x = t` or `x` is +/// spine-dirty (a value read along the spine of `x` changed). Terms are +/// evaluated in increasing ID, so children come first. Every other term reads +/// the same values as in the previous evaluation, so its cost and its work +/// are unchanged; the work count is the sum of the per-term work, which is +/// what [`all_costs`] counts. +pub(crate) struct IncrementalCosts<'a> { + nodes: &'a [Node], + own: &'a [Len], + edges: &'a ReadEdges, + eval: Evaluation, + /// Stamps of the current step: cost changed, spine-dirty. + changed: Vec, + spine_dirty: Vec, + epoch: u32, + /// The terms queued for evaluation in the current step, as a bit set. + queued: Vec, +} + +/// One evaluation of a dictionary ([`all_costs`]) with the work of every +/// term. +#[derive(Clone)] +pub(crate) struct Evaluation { + pub(crate) costs: Vec, + term_work: Vec, + total: u128, +} + +impl Evaluation { + /// [`all_costs`] of `widths`, keeping each term's work. + pub(crate) fn new( + nodes: &[Node], + own: &[Len], + widths: &W, + ) -> Self { + let n = nodes.len(); + let mut costs: Vec = Vec::with_capacity(n); + let mut term_work: Vec = Vec::with_capacity(n); + let mut total: u128 = 0; + for t in 0..n { + let t = TermId::try_from(t).unwrap_or(TermId::MAX); + let mut w = 0u64; + let c = + eval_node(nodes, own, t, widths, &|x| costs[ix(x)], false, &mut w).0; + costs.push(c); + term_work.push(w); + total += u128::from(w); + } + Evaluation { costs, term_work, total } + } + + /// The work [`all_costs`] counts (it saturates; the per-term counts are + /// small). + pub(crate) fn work(&self) -> u64 { + u64::try_from(self.total).unwrap_or(u64::MAX) + } +} + +/// The parent edges of a DAG grouped by child (`edges[start[x]..start[x + +/// 1]]` are the distinct parents of `x`), each tagged with what the parent's +/// evaluation reads of `x`: [`READS_COST`] and/or [`READS_SPINE`]. +pub(crate) struct ReadEdges { + start: Vec, + edges: Vec<(TermId, u8)>, +} + +/// The parent reads the cost of the child (a non-telescope child, a side +/// child, or a spine successor of another family). +const READS_COST: u8 = 1; +/// The child continues the parent's spine: the parent reads its width and +/// the values along its spine. +const READS_SPINE: u8 = 2; + +impl ReadEdges { + pub(crate) fn new(nodes: &[Node]) -> Self { + let n = nodes.len(); + let reads = |p: &Node| -> [(TermId, u8); 3] { + match spine_parts(p) { + Some((side, next)) => { + let next_reads = if nodes[ix(next)].family() == p.family() { + READS_SPINE + } else { + READS_COST + }; + if side == next { + [(side, READS_COST | next_reads), (0, 0), (0, 0)] + } else { + [(side, READS_COST), (next, next_reads), (0, 0)] + } + }, + None => { + let mut out = [(0, 0); 3]; + for (slot, &c) in p.children().as_slice().iter().enumerate() { + match out[..slot].iter().position(|&(d, f)| f != 0 && d == c) { + Some(_) => {}, + None => out[slot] = (c, READS_COST), + } + } + out + }, + } + }; + // Offsets are `usize`: there are up to three edges per node, more than + // `u32` holds for the largest DAGs the limits admit. + let mut start = vec![0usize; n + 1]; + for node in nodes { + for (c, f) in reads(node) { + if f != 0 { + start[ix(c) + 1] += 1; + } + } + } + for i in 0..n { + start[i + 1] += start[i]; + } + let mut fill: Vec = start[..n].to_vec(); + let mut edges: Vec<(TermId, u8)> = vec![(0, 0); start[n]]; + for (p, node) in nodes.iter().enumerate() { + let p = TermId::try_from(p).unwrap_or(TermId::MAX); + for (c, f) in reads(node) { + if f != 0 { + edges[fill[ix(c)]] = (p, f); + fill[ix(c)] += 1; + } + } + } + ReadEdges { start, edges } + } + + fn of(&self, x: usize) -> &[(TermId, u8)] { + &self.edges[self.start[x]..self.start[x + 1]] + } +} + +impl<'a> IncrementalCosts<'a> { + /// Continue from the evaluation `eval` of the current dictionary. + pub(crate) fn new( + nodes: &'a [Node], + own: &'a [Len], + edges: &'a ReadEdges, + eval: Evaluation, + ) -> Self { + let n = nodes.len(); + IncrementalCosts { + nodes, + own, + edges, + eval, + changed: vec![0; n], + spine_dirty: vec![0; n], + epoch: 0, + queued: vec![0; n.div_ceil(64)], + } + } + + /// `C_M` of every term under the current dictionary. + pub(crate) fn costs(&self) -> &[Len] { + &self.eval.costs + } + + /// The work [`all_costs`] counts for the current dictionary (saturating). + pub(crate) fn work(&self) -> u64 { + self.eval.work() + } + + /// `widths` is the previous dictionary with `t`'s width changed (`t` was + /// added); update every cost. + pub(crate) fn add(&mut self, t: TermId, widths: &W) { + if self.epoch == u32::MAX { + self.changed.fill(0); + self.spine_dirty.fill(0); + self.epoch = 0; + } + self.epoch += 1; + let ep = self.epoch; + let nodes = self.nodes; + // Queued terms are only ever larger than the term being evaluated, so + // one forward sweep over the bit set evaluates them in increasing ID. + let mut last = ix(t); + self.queued[last / 64] |= 1 << (last % 64); + let mut word = last / 64; + while word <= last / 64 { + let bits = self.queued[word]; + if bits == 0 { + word += 1; + continue; + } + let bit = bits.trailing_zeros() as usize; + self.queued[word] &= !(1u64 << bit); + let xi = word * 64 + bit; + let x = TermId::try_from(xi).unwrap_or(TermId::MAX); + let mut w = 0u64; + let c = { + let costs = &self.eval.costs; + eval_node(nodes, self.own, x, widths, &|y| costs[ix(y)], false, &mut w) + .0 + }; + let ev = &mut self.eval; + ev.total = ev.total - u128::from(ev.term_work[xi]) + u128::from(w); + ev.term_work[xi] = w; + if c != ev.costs[xi] { + ev.costs[xi] = c; + self.changed[xi] = ep; + } + let changed = |y: TermId| self.changed[ix(y)] == ep; + // Whether a value read along the spine of `x` (side costs, widths of + // continuing successors, the cost of the natural tail) changed. + if let Some((side, next)) = spine_parts(&nodes[xi]) + && (changed(side) + || if nodes[ix(next)].family() == nodes[xi].family() { + next == t || self.spine_dirty[ix(next)] == ep + } else { + changed(next) + }) + { + self.spine_dirty[xi] = ep; + } + let x_changed = changed(x); + let x_spine = x == t || self.spine_dirty[xi] == ep; + if !x_changed && !x_spine { + continue; + } + for &(p, f) in self.edges.of(xi) { + if (f & READS_COST != 0 && x_changed) + || (f & READS_SPINE != 0 && x_spine) + { + let pi = ix(p); + self.queued[pi / 64] |= 1 << (pi % 64); + last = last.max(pi); + } + } + } + } +} + +/// The phase-3 evaluation of a growing dictionary that evaluates a term only +/// when its cost or its work is needed, with the work count of a full +/// [`all_costs`] evaluation of the current dictionary at every step. +/// +/// **Work.** [`eval_node`] counts 1 for a term plus, for an App/Lam/All term +/// `t`, one per telescope option [`scan_telescope`] visits. When no term of +/// `t`'s spine (`t` and its same-family successors) is available, the scan +/// cannot stop before the natural end: no head is found before it and `t` +/// has no Share, so the bound it compares with, `min(best, share)`, stays +/// [`Len::OVERFLOW`], which no unsaturated length reaches. Its work is then +/// `1 + spine length` whatever the costs, and a non-telescope term's work is +/// always 1. Only the telescope terms with an available term on their spine +/// (`spined`; the set only grows) can have cost-dependent work; they are +/// evaluated again at every step where one of their inputs may have +/// changed. Every other term's last recorded work is its current work, so +/// the sum of the recorded work is the full evaluation's count. Saturation +/// is excluded up front ([`LazyCosts::applies`]): every cost of the empty +/// dictionary is below `2^62`, costs only decrease as terms become +/// available, and every partial length of a scan is at most the term's cost +/// of the empty dictionary plus a header and 2. +/// +/// **Costs.** When a term becomes available, it and all its ancestors are +/// marked stale (the stale set is closed upward), and a stale term is +/// evaluated again only when it is needed: before a materialization, every +/// stale descendant of the targets (children first, so its inputs are +/// current), and every stale spined term at each step. Evaluating a term +/// from current inputs gives what a full evaluation gives. +pub(crate) struct LazyCosts<'a> { + nodes: &'a [Node], + own: &'a [Len], + edges: &'a ReadEdges, + eval: Evaluation, + stale: Vec, + spined: Vec, + /// Scratch of `ensure`: visited marks of the current call. + mark: Vec, + epoch: u32, + stack: Vec, + order: Vec<(TermId, bool)>, +} + +impl<'a> LazyCosts<'a> { + /// Whether the work argument applies: every cost of the empty dictionary + /// (`base`) is below `2^62`. + pub(crate) fn applies(base: &Evaluation) -> bool { + base.costs.iter().all(|c| c.raw() < 1 << 62) + } + + /// Continue from `eval`, the full evaluation of `widths`. + pub(crate) fn new( + nodes: &'a [Node], + own: &'a [Len], + edges: &'a ReadEdges, + eval: Evaluation, + widths: &W, + ) -> Self { + let n = nodes.len(); + // `reach[t]`: `t` or a same-family successor on its spine is available. + let mut reach = vec![false; n]; + let mut spined = vec![false; n]; + for t in 0..n { + let tid = TermId::try_from(t).unwrap_or(TermId::MAX); + let avail = widths.width(tid).is_some(); + if let Some((_, next)) = spine_parts(&nodes[t]) { + let same = nodes[ix(next)].family() == nodes[t].family(); + reach[t] = avail || (same && reach[ix(next)]); + spined[t] = reach[t]; + } else { + reach[t] = avail; + } + } + LazyCosts { + nodes, + own, + edges, + eval, + stale: vec![false; n], + spined, + mark: vec![0; n], + epoch: 0, + stack: Vec::new(), + order: Vec::new(), + } + } + + /// `C_M` of every term that is not stale; [`LazyCosts::prepare`] makes the + /// descendants of targets current. + pub(crate) fn costs(&self) -> &[Len] { + &self.eval.costs + } + + /// The work [`all_costs`] counts for the current dictionary (saturating). + pub(crate) fn work(&self) -> u64 { + self.eval.work() + } + + /// Make the costs of `targets` and of all their descendants current. + pub(crate) fn prepare(&mut self, targets: &[TermId], widths: &W) { + for &t in targets { + self.ensure(t, widths); + } + } + + /// `widths` is the previous dictionary with `t` added. + pub(crate) fn add(&mut self, t: TermId, widths: &W) { + let nodes = self.nodes; + // `t` and every ancestor become stale. + let mut due: Vec = Vec::new(); + self.stack.clear(); + if !self.stale[ix(t)] { + self.stale[ix(t)] = true; + self.stack.push(t); + } + while let Some(x) = self.stack.pop() { + if self.spined[ix(x)] { + due.push(x); + } + for &(p, _) in self.edges.of(ix(x)) { + if !self.stale[ix(p)] { + self.stale[ix(p)] = true; + self.stack.push(p); + } + } + } + // `t` and the terms whose spine reaches it are spined from now on. The + // spined set is closed under spine predecessors, so the walk stops at a + // term that already is. + self.stack.clear(); + if spine_parts(&nodes[ix(t)]).is_some() && !self.spined[ix(t)] { + self.spined[ix(t)] = true; + self.stack.push(t); + } + while let Some(x) = self.stack.pop() { + due.push(x); + for &(p, f) in self.edges.of(ix(x)) { + if f & READS_SPINE != 0 && !self.spined[ix(p)] { + self.spined[ix(p)] = true; + self.stack.push(p); + } + } + } + for x in due { + self.ensure(x, widths); + } + } + + /// Evaluate the stale terms among `x` and its descendants, children + /// first. The stale set is closed upward, so they are reached through + /// stale terms only. + fn ensure(&mut self, x: TermId, widths: &W) { + if !self.stale[ix(x)] { + return; + } + if self.epoch == u32::MAX { + self.mark.fill(0); + self.epoch = 0; + } + self.epoch += 1; + let ep = self.epoch; + let nodes = self.nodes; + // Post-order over the stale region: a term is evaluated after all its + // stale descendants (which its evaluation may read). A term popped again + // after its first visit is done: it cannot be its own descendant. + let mut post: Vec<(TermId, bool)> = std::mem::take(&mut self.order); + post.clear(); + post.push((x, false)); + while let Some((y, expanded)) = post.pop() { + let yi = ix(y); + if !expanded { + if self.mark[yi] == ep { + continue; + } + self.mark[yi] = ep; + post.push((y, true)); + for &c in nodes[yi].children().as_slice() { + if self.stale[ix(c)] && self.mark[ix(c)] != ep { + post.push((c, false)); + } + } + continue; + } + let mut w = 0u64; + let c = { + let costs = &self.eval.costs; + eval_node(nodes, self.own, y, widths, &|z| costs[ix(z)], false, &mut w) + .0 + }; + let ev = &mut self.eval; + ev.total = ev.total - u128::from(ev.term_work[yi]) + u128::from(w); + ev.term_work[yi] = w; + ev.costs[yi] = c; + self.stale[yi] = false; + } + self.order = post; + } +} + +/// Side child and spine successor of an App/Lam/All node. +fn spine_parts(node: &Node) -> Option<(TermId, TermId)> { + match node { + Node::App(f, a) => Some((*a, *f)), + Node::Lam(_, ty, b) | Node::All(_, _, ty, b) => Some((*ty, *b)), + _ => None, + } +} + +fn internal(msg: &str) -> SharingError { + SharingError::Internal(msg.to_string()) +} + +/// The spine successor of a telescope node. +fn spine_next(node: &Node) -> Option { + match node { + Node::App(f, _) => Some(*f), + Node::Lam(_, _, b) | Node::All(_, _, _, b) => Some(*b), + _ => None, + } +} + +/// Visit the terms whose standalone representations choice `ch` at `t` +/// needs: the children of an inline node; for a telescope of `j` spine +/// nodes, the side child of each spine node (one unit of `work` per spine +/// node), then the node after the spine unless the telescope stops at a +/// Share of it (a cut). Returns whether the choice is a telescope with a +/// cut. +fn for_each_needed( + nodes: &[Node], + t: TermId, + ch: Choice, + work: &mut u64, + mut need: impl FnMut(TermId), +) -> Result { + match ch { + Choice::Share => Ok(false), + Choice::Inline => { + for &c in nodes[ix(t)].children().as_slice() { + need(c); + } + Ok(false) + }, + Choice::Telescope(j) => { + if j == 0 { + return Err(internal("telescope choice without an option")); + } + let mut cur = t; + for _ in 0..j { + *work = work.saturating_add(1); + let node = &nodes[ix(cur)]; + match node { + Node::App(_, a) => need(*a), + Node::Lam(_, ty, _) | Node::All(_, _, ty, _) => need(*ty), + _ => return Err(internal("telescope walked off its spine")), + } + cur = spine_next(node).ok_or_else(|| internal("spine"))?; + } + let cut = nodes[ix(cur)].family() == nodes[ix(t)].family(); + if !cut { + need(cur); + } + Ok(cut) + }, + } +} + +/// The spine nodes of a telescope choice of `j` nodes at `t`, the node +/// after them, and whether the telescope stops at a Share of it (a cut). +fn telescope_parts( + nodes: &[Node], + t: TermId, + j: u64, +) -> Result<(Vec, TermId, bool), SharingError> { + let mut spine = Vec::new(); + let mut cur = t; + for _ in 0..j { + spine.push(cur); + cur = spine_next(&nodes[ix(cur)]).ok_or_else(|| internal("spine"))?; + } + let cut = nodes[ix(cur)].family() == nodes[ix(t)].family(); + Ok((spine, cur, cut)) +} + +/// The standalone representation of `c` built earlier, from `rep`. +fn built( + rep: &[Option>], + c: TermId, +) -> Result, SharingError> { + rep.get(ix(c)).cloned().flatten().ok_or_else(|| internal("missing child")) +} + +/// The expression of `t` written with choice `ch` under `dict`, the +/// standalone representations of the terms it needs read from `rep`. +fn build_choice( + nodes: &[Node], + dict: &D, + t: TermId, + ch: Choice, + rep: &[Option>], +) -> Result, SharingError> { + let node = &nodes[ix(t)]; + Ok(match ch { + Choice::Share => Arc::new(Expr::Share( + dict.index(t).ok_or_else(|| internal("share index"))?, + )), + Choice::Inline => { + let mut kids: Vec> = Vec::new(); + for &c in node.children().as_slice() { + kids.push(built(rep, c)?); + } + let slot = |c: TermId| { + let pos = node.children().as_slice().iter().position(|&x| x == c); + kids[pos.unwrap_or(0)].clone() + }; + Arc::new(node.to_expr(slot)) + }, + Choice::Telescope(j) => { + let (spine, cur, cut) = telescope_parts(nodes, t, j)?; + let mut e = if cut { + Arc::new(Expr::Share( + dict.index(cur).ok_or_else(|| internal("cut index"))?, + )) + } else { + built(rep, cur)? + }; + for &s in spine.iter().rev() { + e = Arc::new(match &nodes[ix(s)] { + Node::App(_, a) => Expr::App(e, built(rep, *a)?), + Node::Lam(c, ty, _) => Expr::Lam(*c, built(rep, *ty)?, e), + Node::All(c, v, ty, _) => Expr::All(*c, *v, built(rep, *ty)?, e), + _ => return Err(internal("telescope rebuild")), + }); + } + e + }, + }) +} + +/// Materialize the byte-least minimum-length standalone expression of each +/// target under a fixed dictionary, given `costs = C_M` for every term. +pub(crate) fn materialize( + nodes: &[Node], + own: &[Len], + dict: &D, + costs: &[Len], + targets: &[TermId], + work: &mut u64, +) -> Result>, SharingError> { + let Some(&top) = targets.iter().max() else { + return Ok(Vec::new()); + }; + let top = ix(top); + let mut choice: Vec> = vec![None; top + 1]; + let mut needed = vec![false; top + 1]; + for &t in targets { + needed[ix(t)] = true; + } + // Top-down: decide every needed standalone occurrence. Needed children + // have smaller IDs, so one descending sweep suffices. + for t in (0..=top).rev() { + if !needed[t] { + continue; + } + let tid = TermId::try_from(t).map_err(|_e| internal("term id"))?; + let (_, ch) = + eval_node(nodes, own, tid, dict, &|x| costs[ix(x)], true, work); + choice[t] = Some(ch); + for_each_needed(nodes, tid, ch, work, |c| needed[ix(c)] = true)?; + } + // Bottom-up: build each needed standalone representation once. + let mut rep: Vec>> = vec![None; top + 1]; + for t in 0..=top { + let Some(ch) = choice[t] else { continue }; + let tid = TermId::try_from(t).map_err(|_e| internal("term id"))?; + rep[t] = Some(build_choice(nodes, dict, tid, ch, &rep)?); + } + targets.iter().map(|&t| built(&rep, t)).collect() +} + +/// [`materialize`] with scratch space reused across calls on one DAG: the +/// same choices, expressions and work, but the time of a call is linear in +/// the terms it writes, not in the largest target's ID. +/// +/// The needed terms are decided in decreasing ID (a max-heap; a needed term +/// is only ever marked by a larger one, so every term is decided once, after +/// all its users, exactly as the descending sweep of [`materialize`]), then +/// built in increasing ID. +pub(crate) struct Materializer { + /// `stamp[t] == epoch`: `t` is needed in the current call. + stamp: Vec, + epoch: u32, + rep: Vec>>, + heap: std::collections::BinaryHeap, +} + +impl Materializer { + pub(crate) fn new(n: usize) -> Self { + Materializer { + stamp: vec![0; n], + epoch: 0, + rep: vec![None; n], + heap: std::collections::BinaryHeap::new(), + } + } + + fn need(&mut self, t: TermId) { + let i = ix(t); + if self.stamp[i] != self.epoch { + self.stamp[i] = self.epoch; + self.heap.push(t); + } + } + + /// [`materialize`]`(nodes, own, dict, costs, targets, work)`. + #[cfg(test)] + pub(crate) fn run( + &mut self, + nodes: &[Node], + own: &[Len], + dict: &D, + costs: &[Len], + targets: &[TermId], + work: &mut u64, + ) -> Result>, SharingError> { + let plan = self.decide(nodes, own, dict, costs, targets, work)?; + self.build(nodes, dict, &plan) + } + + /// The decisions of [`Materializer::run`] (with all its work) without + /// building the expressions: the needed terms with their choices, and the + /// number of expression nodes [`Materializer::build`] allocates for them. + pub(crate) fn decide( + &mut self, + nodes: &[Node], + own: &[Len], + dict: &D, + costs: &[Len], + targets: &[TermId], + work: &mut u64, + ) -> Result { + if self.epoch == u32::MAX { + self.stamp.fill(0); + self.epoch = 0; + } + self.epoch += 1; + self.heap.clear(); + for &t in targets { + self.need(t); + } + let mut plan = + Plan { decided: Vec::new(), targets: targets.to_vec(), nodes: 0 }; + // Top-down: decide every needed standalone occurrence. + while let Some(tid) = self.heap.pop() { + let (_, ch) = + eval_node(nodes, own, tid, dict, &|x| costs[ix(x)], true, work); + plan.decided.push((tid, ch)); + plan.nodes = plan.nodes.saturating_add(match ch { + Choice::Share | Choice::Inline => 1, + Choice::Telescope(j) => j, + }); + if for_each_needed(nodes, tid, ch, work, |c| self.need(c))? { + // The cut: a Share of the spine node where the telescope stops. + plan.nodes = plan.nodes.saturating_add(1); + } + } + Ok(plan) + } + + /// Build the expressions of `plan` (from [`Materializer::decide`] under a + /// dictionary with the same indices as `dict` for the terms it shares). + pub(crate) fn build( + &mut self, + nodes: &[Node], + dict: &D, + plan: &Plan, + ) -> Result>, SharingError> { + // Bottom-up: build each needed standalone representation once. + for &(tid, ch) in plan.decided.iter().rev() { + let e = build_choice(nodes, dict, tid, ch, &self.rep)?; + self.rep[ix(tid)] = Some(e); + } + let out: Result>, SharingError> = + plan.targets.iter().map(|&t| built(&self.rep, t)).collect(); + for &(t, _) in &plan.decided { + self.rep[ix(t)] = None; + } + out + } +} + +/// The decisions of one materialization ([`Materializer::decide`]): the +/// needed terms in decision (decreasing) order with their choices, the +/// targets, and the number of expression nodes the build allocates (one +/// per Share or inline node, one per spine node of a telescope and one for +/// a telescope's cut Share). +#[derive(Debug, PartialEq, Eq)] +pub(crate) struct Plan { + decided: Vec<(TermId, Choice)>, + targets: Vec, + pub(crate) nodes: u64, +} + +/// `C_M(t)` for a fixed dictionary (§5). +pub fn dictionary_cost( + dag: &SharingDag, + dict: &FixedDictionary, + t: TermId, +) -> Len { + let own: Vec = dag.nodes().iter().map(Node::own_len).collect(); + let mut work = 0; + let costs = all_costs(dag.nodes(), &own, dict, &mut work); + costs.get(ix(t)).copied().unwrap_or(Len::OVERFLOW) +} + +/// The byte-least minimum-length standalone expression of each target under +/// a fixed dictionary; Shares use the dictionary's actual indices. +pub fn materialize_with_dictionary( + dag: &SharingDag, + dict: &FixedDictionary, + targets: &[TermId], +) -> Result>, SharingError> { + if targets.iter().any(|&t| ix(t) >= dag.len()) { + return Err(internal("target out of range")); + } + let own: Vec = dag.nodes().iter().map(Node::own_len).collect(); + let mut work = 0; + let costs = all_costs(dag.nodes(), &own, dict, &mut work); + materialize(dag.nodes(), &own, dict, &costs, targets, &mut work) +} + +/// A dictionary with one term's own Share hidden: the top of that term's +/// table entry, which may not reference itself. +pub(crate) struct Hide<'a, D> { + pub(crate) inner: &'a D, + pub(crate) hidden: TermId, +} + +impl Widths for Hide<'_, D> { + fn width(&self, t: TermId) -> Option { + if t == self.hidden { None } else { self.inner.width(t) } + } +} + +impl Indices for Hide<'_, D> { + fn index(&self, t: TermId) -> Option { + if t == self.hidden { None } else { self.inner.index(t) } + } +} + +/// Real table indices with every Share priced at one uniform width. +pub(crate) struct UniformIndex { + pub(crate) index: Vec>, + pub(crate) width: u64, +} + +impl Widths for UniformIndex { + fn width(&self, t: TermId) -> Option { + self.index[ix(t)].map(|_| self.width) + } +} + +impl Indices for UniformIndex { + fn index(&self, t: TermId) -> Option { + self.index[ix(t)] + } +} + +/// Materialize a table given in dependency order (every stored descendant +/// of an entry precedes it) and the roots, from one evaluation `costs` of the +/// whole dictionary `dict`. In such an order each entry can use every stored +/// term that can occur inside it and no other, so the full dictionary prices +/// and builds it exactly. Entry tops take their best non-Share choice; every +/// nested occurrence takes its standalone choice. Returns entries, roots and +/// the predicted cost `sum inline(entry) + sum C(root)` (without the count). +pub(crate) fn decide_dependent( + nodes: &[Node], + own: &[Len], + dict: &D, + costs: &[Len], + table: &[TermId], + roots: &[TermId], + work: &mut u64, +) -> Result { + let n = nodes.len(); + let mut predicted = Len::ZERO; + let mut entry_choice: Vec = Vec::with_capacity(table.len()); + let mut needed = vec![false; n]; + let mark_children = + |t: TermId, ch: Choice, needed: &mut Vec, work: &mut u64| { + for_each_needed(nodes, t, ch, work, |c| needed[ix(c)] = true).map(|_| ()) + }; + for &t in table { + let hide = Hide { inner: dict, hidden: t }; + let (c, ch) = + eval_node(nodes, own, t, &hide, &|x| costs[ix(x)], true, work); + if ch == Choice::Share { + return Err(internal("entry top chose a Share")); + } + predicted = predicted.plus(c); + mark_children(t, ch, &mut needed, work)?; + entry_choice.push(ch); + } + for &r in roots { + needed[ix(r)] = true; + predicted = predicted.plus(costs[ix(r)]); + } + let mut choice: Vec> = vec![None; n]; + for t in (0..n).rev() { + if !needed[t] { + continue; + } + let tid = TermId::try_from(t).map_err(|_e| internal("term id"))?; + let (c, ch) = + eval_node(nodes, own, tid, dict, &|x| costs[ix(x)], true, work); + if c != costs[t] { + return Err(internal("standalone choice differs from C_M")); + } + choice[t] = Some(ch); + mark_children(tid, ch, &mut needed, work)?; + } + Ok(DependentPlan { entry_choice, choice, predicted }) +} + +/// The decisions of [`materialize_dependent`]: each entry's top choice, +/// the standalone choice of every needed term, and the predicted length. +pub(crate) struct DependentPlan { + entry_choice: Vec, + choice: Vec>, + pub(crate) predicted: Len, +} + +/// What the expressions of a [`DependentPlan`] contain, computed without +/// building them: per table position the number of Shares of that entry in +/// all the expression trees (entries and roots, with multiplicity, as a walk +/// of each tree counts them), per entry the entries its expression shares +/// in pre-order of first occurrence, and the number of expression nodes the +/// build allocates (all pointer-distinct). +#[derive(Clone, Debug)] +pub(crate) struct PlanShares { + pub(crate) refs: Vec, + pub(crate) deps: Vec>, + pub(crate) nodes: u64, +} + +/// One item of the pre-order walk of [`DependentPlan::shares`]. +#[derive(Clone, Copy)] +enum WalkItem { + /// The standalone representation of a term (shared by its occurrences). + Rep(TermId), + /// A Share of a term. + Shr(TermId), +} + +impl DependentPlan { + /// The children of the expression of `t` written with choice `ch`, in + /// expression order (`Expr` children, left to right). + fn items( + nodes: &[Node], + t: TermId, + ch: Choice, + out: &mut Vec, + ) -> Result { + out.clear(); + match ch { + Choice::Share => { + out.push(WalkItem::Shr(t)); + Ok(1) + }, + Choice::Inline => { + for &c in nodes[ix(t)].children().as_slice() { + out.push(WalkItem::Rep(c)); + } + Ok(1) + }, + Choice::Telescope(j) => { + let (spine, cur, cut) = telescope_parts(nodes, t, j)?; + let head = if cut { WalkItem::Shr(cur) } else { WalkItem::Rep(cur) }; + // App: `App(App(head, a_{j-1}) .., a_0)`, so the head, then the + // arguments from the deepest spine node up. Lam/All: + // `Lam(ty_0, Lam(ty_1, .. head))`, so the binder types from the top, + // then the head. + if matches!(nodes[ix(t)], Node::App(..)) { + out.push(head); + for &s in spine.iter().rev() { + if let Node::App(_, a) = nodes[ix(s)] { + out.push(WalkItem::Rep(a)); + } + } + } else { + for &s in &spine { + match nodes[ix(s)] { + Node::Lam(_, ty, _) | Node::All(_, _, ty, _) => { + out.push(WalkItem::Rep(ty)); + }, + _ => return Err(internal("telescope walked off its spine")), + } + } + out.push(head); + } + Ok(j + u64::from(cut)) + }, + } + } + + /// See [`PlanShares`]; `pos[t]` is the table position of a stored term. + pub(crate) fn shares( + &self, + nodes: &[Node], + table: &[TermId], + roots: &[TermId], + pos: &dyn Fn(TermId) -> Option, + ) -> Result { + let n = nodes.len(); + let mut refs = vec![0u64; table.len()]; + let add_ref = |refs: &mut Vec, x: TermId, m: u64| { + if let Some(r) = pos(x).and_then(|i| refs.get_mut(i)) { + *r = r.saturating_add(m); + } + }; + let mut items: Vec = Vec::new(); + // Occurrence counts of the standalone representations in all trees. + let mut mult = vec![0u64; n]; + let mut count = 0u64; + for &r in roots { + mult[ix(r)] = mult[ix(r)].saturating_add(1); + } + for (&t, &ch) in table.iter().zip(&self.entry_choice) { + count = count.saturating_add(Self::items(nodes, t, ch, &mut items)?); + for &it in &items { + match it { + WalkItem::Rep(c) => mult[ix(c)] = mult[ix(c)].saturating_add(1), + WalkItem::Shr(x) => add_ref(&mut refs, x, 1), + } + } + } + for t in (0..n).rev() { + let Some(ch) = self.choice[t] else { continue }; + let tid = TermId::try_from(t).map_err(|_e| internal("term id"))?; + count = count.saturating_add(Self::items(nodes, tid, ch, &mut items)?); + let m = mult[t]; + if m == 0 { + continue; + } + for &it in &items { + match it { + WalkItem::Rep(c) => mult[ix(c)] = mult[ix(c)].saturating_add(m), + WalkItem::Shr(x) => add_ref(&mut refs, x, m), + } + } + } + // Per entry, the shared entries in pre-order of first occurrence. A + // representation met again contributes nothing new, so each is walked + // once per entry. + let mut deps = Vec::with_capacity(table.len()); + let mut seen_rep = vec![0usize; n]; + let mut seen_dep = vec![0usize; n]; + let mut stack: Vec = Vec::new(); + for (e, (&t, &ch)) in table.iter().zip(&self.entry_choice).enumerate() { + let ep = e + 1; + let mut ds: Vec = Vec::new(); + Self::items(nodes, t, ch, &mut items)?; + stack.clear(); + stack.extend(items.iter().rev()); + while let Some(it) = stack.pop() { + match it { + WalkItem::Shr(x) => { + if seen_dep[ix(x)] != ep { + seen_dep[ix(x)] = ep; + ds.push(x); + } + }, + WalkItem::Rep(c) => { + if seen_rep[ix(c)] == ep { + continue; + } + seen_rep[ix(c)] = ep; + let cch = + self.choice[ix(c)].ok_or_else(|| internal("missing choice"))?; + Self::items(nodes, c, cch, &mut items)?; + stack.extend(items.iter().rev()); + }, + } + } + deps.push(ds); + } + Ok(PlanShares { refs, deps, nodes: count }) + } +} + +/// The expressions of the decisions of [`decide_dependent`] for the same +/// `table` and `roots`: entries and roots. +pub(crate) fn build_dependent( + nodes: &[Node], + dict: &D, + plan: &DependentPlan, + table: &[TermId], + roots: &[TermId], +) -> Result<(Vec>, Vec>), SharingError> { + let n = nodes.len(); + let DependentPlan { entry_choice, choice, .. } = plan; + let mut rep: Vec>> = vec![None; n]; + for t in 0..n { + if let Some(ch) = choice[t] { + let tid = TermId::try_from(t).map_err(|_e| internal("term id"))?; + rep[t] = Some(build_choice(nodes, dict, tid, ch, &rep)?); + } + } + let mut entries = Vec::with_capacity(table.len()); + for (&t, &ch) in table.iter().zip(entry_choice) { + entries.push(build_choice(nodes, dict, t, ch, &rep)?); + } + let roots_out = + roots.iter().map(|&r| built(&rep, r)).collect::>()?; + Ok((entries, roots_out)) +} diff --git a/crates/ixon/src/sharing_exact/mss.rs b/crates/ixon/src/sharing_exact/mss.rs new file mode 100644 index 000000000..bdd49b230 --- /dev/null +++ b/crates/ixon/src/sharing_exact/mss.rs @@ -0,0 +1,154 @@ +//! Maximal structural sharing (MSS), a reference encoding for the tests; it +//! is not on the compiler path. The tests use it as a valid Share-bearing +//! input that the exact constructions must normalize from and never exceed. +//! +//! MSS stores every candidate (compact in-degree at least 2, unshared length +//! at least 2), orders the table by the Kahn priority order of compact +//! in-degree (repeatedly the available entry, every stored term its body +//! references already placed, with the largest in-degree; ties by the +//! smaller structural ID), and replaces every occurrence of a stored term by +//! a Share, in roots and in other entries. + +use std::collections::BTreeSet; +use std::sync::Arc; + +use super::cost::Len; +use super::dag::{Node, SharingDag, TermId, ix}; +use super::dict::all_costs; +use super::uniform::graph_facts; +use super::{ + ExactSharingLimits, Meter, SharingError, constant_info_root_exprs, + rebuild_constant_info, +}; +use crate::constant::Constant; +use crate::expr::Expr; + +fn internal(msg: &str) -> SharingError { + SharingError::Internal(msg.to_string()) +} + +/// An MSS encoding of a DAG. +struct MssEncoding { + /// Stored terms in table order. + table_terms: Vec, + sharing: Vec>, + roots: Vec>, +} + +/// MSS of a DAG. +fn mss_dag(dag: &SharingDag) -> Result { + let nodes = dag.nodes(); + let n = nodes.len(); + let own: Vec = nodes.iter().map(Node::own_len).collect(); + let mut work = 0u64; + let base = all_costs(nodes, &own, &super::dict::NoWidths, &mut work); + let facts = graph_facts(dag); + let stored: Vec = + (0..n).map(|t| facts.deg[t] >= 2 && base[t] >= Len::new(2)).collect(); + // Dependencies: the stored terms reachable from a stored term's children + // through unstored terms (the Shares of its MSS body). + let mut deps: Vec> = vec![Vec::new(); n]; + let mut stamp = vec![usize::MAX; n]; + for t in 0..n { + if !stored[t] { + continue; + } + let mut stack: Vec = nodes[t].children().as_slice().to_vec(); + while let Some(c) = stack.pop() { + let c = ix(c); + if stamp[c] == t { + continue; + } + stamp[c] = t; + if stored[c] { + deps[t].push(TermId::try_from(c).map_err(|_e| internal("id"))?); + } else { + stack.extend_from_slice(nodes[c].children().as_slice()); + } + } + } + // Kahn priority order by in-degree, ties by the smaller ID. + let mut pend = vec![0usize; n]; + let mut users: Vec> = vec![Vec::new(); n]; + for t in 0..n { + if stored[t] { + pend[t] = deps[t].len(); + for &d in &deps[t] { + users[ix(d)].push(t); + } + } + } + let key = |t: usize| (std::cmp::Reverse(facts.deg[t]), t); + let mut ready: BTreeSet<(std::cmp::Reverse, usize)> = + (0..n).filter(|&t| stored[t] && pend[t] == 0).map(key).collect(); + let mut order: Vec = Vec::new(); + while let Some((_, t)) = ready.pop_first() { + order.push(t); + for &u in &users[t] { + pend[u] -= 1; + if pend[u] == 0 { + ready.insert(key(u)); + } + } + } + if order.len() != stored.iter().filter(|&&s| s).count() { + return Err(internal("MSS order is incomplete")); + } + let mut index = vec![None; n]; + for (i, &t) in order.iter().enumerate() { + index[t] = Some(i as u64); + } + // Shared form of every term (children have smaller IDs). + let mut shared: Vec> = Vec::with_capacity(n); + let mut body: Vec>> = vec![None; n]; + for t in 0..n { + let e = Arc::new(nodes[t].to_expr(|c| shared[ix(c)].clone())); + if let Some(i) = index[t] { + body[t] = Some(e); + shared.push(Expr::share(i)); + } else { + shared.push(e); + } + } + let sharing: Vec> = order + .iter() + .map(|&t| body[t].clone().ok_or_else(|| internal("missing body"))) + .collect::>()?; + let roots: Vec> = + dag.roots().iter().map(|&r| shared[ix(r)].clone()).collect(); + let table_terms = order + .iter() + .map(|&t| TermId::try_from(t).map_err(|_e| internal("id"))) + .collect::>()?; + Ok(MssEncoding { table_terms, sharing, roots }) +} + +/// MSS of a constant (its table expanded first), checked to expand to the +/// same DAG. +pub(crate) fn mss_constant( + c: &Constant, + limits: &ExactSharingLimits, +) -> Result { + let mut meter = Meter::new(limits); + let roots = constant_info_root_exprs(&c.info); + let dag = SharingDag::build(&roots, Some(&c.sharing), &mut meter)?; + let enc = mss_dag(&dag)?; + let mut check_meter = Meter::new(limits); + let (check, ids) = + SharingDag::build_full(&enc.roots, Some(&enc.sharing), &mut check_meter)?; + if check != dag + || ids + .iter() + .map(|x| x.unwrap_or(TermId::MAX)) + .ne(enc.table_terms.iter().copied()) + { + return Err(internal("MSS encoding does not expand to the input")); + } + let info = rebuild_constant_info(&c.info, &enc.roots)?; + Ok(Constant { + info, + sharing: enc.sharing, + refs: c.refs.clone(), + univs: c.univs.clone(), + }) +} diff --git a/crates/ixon/src/sharing_exact/oracle.rs b/crates/ixon/src/sharing_exact/oracle.rs new file mode 100644 index 000000000..263acee90 --- /dev/null +++ b/crates/ixon/src/sharing_exact/oracle.rs @@ -0,0 +1,332 @@ +//! A deliberately simple exact reference search for tiny inputs (§6.3): a +//! test oracle (compiled for tests only), not on the compiler path. +//! +//! It shares no search code with the optimizer: IDs are recomputed from +//! expression values, every ordered sequence of distinct expanded subterms is +//! tried as the table (not only R1/R2 candidates), every table entry and +//! root enumerates every per-occurrence choice between its inline constructor +//! and a Share of an equal earlier entry, and lengths and bytes come from the +//! real serializer. Candidates are compared by the full key `(L, Q, bytes)`. +//! +//! For one table sequence the entries and roots are separate byte segments of +//! the Constant: a minimum-length Constant has every segment at its minimum +//! length, so segment positions are fixed and the byte-least Constant takes +//! the byte-least minimum segment everywhere. [`oracle_full_product`] checks +//! this separability by enumerating complete Constants. + +use std::collections::HashMap; +use std::sync::Arc; + +use super::roots::{constant_info_root_exprs, rebuild_constant_info}; +use crate::constant::Constant; +use crate::contract::pack_all_contract; +use crate::expr::Expr; +use crate::serialize::put_expr; + +fn collect(e: &Arc, heights: &mut HashMap) -> u32 { + if let Some(&h) = heights.get(e.as_ref()) { + return h; + } + assert!(!matches!(e.as_ref(), Expr::Share(_)), "oracle input has Share"); + let h = e.children().into_iter().map(|c| collect(c, heights) + 1).max(); + let h = h.unwrap_or(0); + heights.insert(e.as_ref().clone(), h); + h +} + +fn key(e: &Expr, ids: &HashMap) -> (u8, Vec, Vec) { + let id = |c: &Arc| ids[c.as_ref()]; + match e { + Expr::Sort(u) => (0, vec![*u], vec![]), + Expr::Var(i) => (1, vec![*i], vec![]), + Expr::Ref(r, us) | Expr::Rec(r, us) => { + let tag = if matches!(e, Expr::Ref(..)) { 2 } else { 3 }; + let mut s = vec![*r, us.len() as u64]; + s.extend(us.iter().copied()); + (tag, s, vec![]) + }, + Expr::Prj(t, f, v) => (4, vec![*t, *f], vec![id(v)]), + Expr::Str(r) => (5, vec![*r], vec![]), + Expr::Nat(r) => (6, vec![*r], vec![]), + Expr::App(f, a) => (7, vec![], vec![id(f), id(a)]), + Expr::Lam(c, ty, b) => { + (8, vec![u64::from(c.to_bits())], vec![id(ty), id(b)]) + }, + Expr::All(c, v, ty, b) => { + (9, vec![u64::from(pack_all_contract(*c, *v))], vec![id(ty), id(b)]) + }, + Expr::Let(c, ty, v, b) => ( + 10, + vec![c.flags(), u64::from(c.binder.to_bits())], + vec![id(ty), id(v), id(b)], + ), + Expr::Share(_) => panic!("oracle input has Share"), + } +} + +/// Independent §3.2 IDs of the distinct subterms of `roots`, and the terms +/// in ID order. +pub(crate) fn oracle_ids( + roots: &[Arc], +) -> (HashMap, Vec>) { + let mut heights: HashMap = HashMap::new(); + for r in roots { + collect(r, &mut heights); + } + let max_h = heights.values().copied().max().unwrap_or(0); + let mut ids: HashMap = HashMap::new(); + let mut terms: Vec> = Vec::new(); + for h in 0..=max_h { + let mut level: Vec<(u8, Vec, Vec, Expr)> = heights + .iter() + .filter(|(_, hh)| **hh == h) + .map(|(e, _)| { + let (t, s, c) = key(e, &ids); + (t, s, c, e.clone()) + }) + .collect(); + level.sort_by(|a, b| (&a.0, &a.1, &a.2).cmp(&(&b.0, &b.1, &b.2))); + for (_, _, _, e) in level { + let id = u32::try_from(terms.len()).unwrap(); + ids.insert(e.clone(), id); + terms.push(Arc::new(e)); + } + } + (ids, terms) +} + +/// Every representation of `e` using the available `(expanded, index)` +/// entries: at each occurrence, the inline constructor or a Share of an +/// equal entry. +pub(crate) fn variants( + e: &Arc, + avail: &[(Arc, u64)], +) -> Vec> { + let mut out: Vec> = avail + .iter() + .filter(|(x, _)| x == e) + .map(|(_, i)| Expr::share(*i)) + .collect(); + let kids = e.children(); + if kids.is_empty() { + out.push(e.clone()); + return out; + } + let mut combos: Vec>> = vec![vec![]]; + for c in kids { + let vs = variants(c, avail); + let mut next = Vec::with_capacity(combos.len() * vs.len()); + for prefix in &combos { + for v in &vs { + let mut row = prefix.clone(); + row.push(v.clone()); + next.push(row); + } + } + assert!(next.len() <= 2_000_000, "oracle variant explosion"); + combos = next; + } + out.extend(combos.iter().map(|cs| Arc::new(e.with_children(cs).unwrap()))); + out +} + +pub(crate) fn bytes_of(e: &Expr) -> Vec { + let mut b = Vec::new(); + put_expr(e, &mut b); + b +} + +/// The byte-least minimum-length variant and every variant's bytes. +fn best_variant(e: &Arc, avail: &[(Arc, u64)]) -> Arc { + variants(e, avail) + .into_iter() + .map(|v| (bytes_of(&v), v)) + .min_by(|a, b| (a.0.len(), &a.0).cmp(&(b.0.len(), &b.0))) + .unwrap() + .1 +} + +/// Result of the exhaustive search. +#[derive(Debug)] +pub(crate) struct OracleResult { + pub len: u64, + pub q: Vec, + pub bytes: Vec, + pub constant: Constant, + /// Every table sequence (as oracle IDs) that attains the minimum length. + pub minimal_sequences: Vec>, + pub sequences: u64, +} + +fn constant_bytes(c: &Constant) -> Vec { + let mut b = Vec::new(); + c.put(&mut b); + b +} + +fn for_each_sequence(n: usize, f: &mut impl FnMut(&[usize])) { + fn go(n: usize, order: &mut Vec, f: &mut impl FnMut(&[usize])) { + f(order); + for i in 0..n { + if !order.contains(&i) { + order.push(i); + go(n, order, f); + order.pop(); + } + } + } + go(n, &mut Vec::new(), f); +} + +fn available(terms: &[Arc], order: &[usize]) -> Vec<(Arc, u64)> { + order.iter().enumerate().map(|(i, &t)| (terms[t].clone(), i as u64)).collect() +} + +/// Exhaustive minimum of the full key over all tables and occurrence +/// choices. `template` supplies every non-sharing field; its roots must be +/// fully expanded and its table is ignored. +pub(crate) fn oracle_optimum(template: &Constant) -> OracleResult { + let roots = constant_info_root_exprs(&template.info); + let (_, terms) = oracle_ids(&roots); + let mut best: Option<(u64, Vec, Vec, Constant)> = None; + let mut min_len = u64::MAX; + let mut minimal: Vec> = Vec::new(); + let mut sequences = 0u64; + for_each_sequence(terms.len(), &mut |order| { + sequences += 1; + let mut table = Vec::with_capacity(order.len()); + for i in 0..order.len() { + let avail = available(&terms, &order[..i]); + table.push(best_variant(&terms[order[i]], &avail)); + } + let avail = available(&terms, order); + let reps: Vec> = + roots.iter().map(|r| best_variant(r, &avail)).collect(); + let info = rebuild_constant_info(&template.info, &reps).unwrap(); + let c = Constant { + info, + sharing: table, + refs: template.refs.clone(), + univs: template.univs.clone(), + }; + let bytes = constant_bytes(&c); + let len = bytes.len() as u64; + let q: Vec = + order.iter().map(|&i| u32::try_from(i).unwrap()).collect(); + if len < min_len { + min_len = len; + minimal.clear(); + } + if len == min_len { + minimal.push(q.clone()); + } + let better = match &best { + None => true, + Some((bl, bq, bb, _)) => (len, &q, &bytes) < (*bl, bq, bb), + }; + if better { + best = Some((len, q, bytes, c)); + } + }); + let (len, q, bytes, constant) = best.unwrap(); + minimal.sort(); + OracleResult { + len, + q, + bytes, + constant, + minimal_sequences: minimal, + sequences, + } +} + +/// The minimum key over the complete Cartesian product of every entry's and +/// root's variants, for every table sequence. Returns `None` if some +/// sequence has more than `cap` complete Constants. +pub(crate) fn oracle_full_product( + template: &Constant, + cap: usize, +) -> Option<(u64, Vec, Vec, u64)> { + let roots = constant_info_root_exprs(&template.info); + let (_, terms) = oracle_ids(&roots); + let mut best: Option<(u64, Vec, Vec)> = None; + let mut complete = 0u64; + let mut too_big = false; + for_each_sequence(terms.len(), &mut |order| { + if too_big { + return; + } + let mut components: Vec>> = Vec::new(); + for i in 0..order.len() { + components + .push(variants(&terms[order[i]], &available(&terms, &order[..i]))); + } + let k = components.len(); + let avail = available(&terms, order); + for r in &roots { + components.push(variants(r, &avail)); + } + let total: usize = components.iter().map(Vec::len).product(); + if total > cap { + too_big = true; + return; + } + let q: Vec = + order.iter().map(|&i| u32::try_from(i).unwrap()).collect(); + let mut pick = vec![0usize; components.len()]; + loop { + let table: Vec> = + (0..k).map(|i| components[i][pick[i]].clone()).collect(); + let reps: Vec> = + (k..components.len()).map(|i| components[i][pick[i]].clone()).collect(); + let info = rebuild_constant_info(&template.info, &reps).unwrap(); + let c = Constant { + info, + sharing: table, + refs: template.refs.clone(), + univs: template.univs.clone(), + }; + let bytes = constant_bytes(&c); + complete += 1; + let len = bytes.len() as u64; + let better = match &best { + None => true, + Some((bl, bq, bb)) => (len, &q, &bytes) < (*bl, bq, bb), + }; + if better { + best = Some((len, q.clone(), bytes)); + } + // Odometer increment. + let mut d = 0; + loop { + if d == pick.len() { + return; + } + pick[d] += 1; + if pick[d] < components[d].len() { + break; + } + pick[d] = 0; + d += 1; + } + } + }); + if too_big { + return None; + } + best.map(|(l, q, b)| (l, q, b, complete)) +} + +/// Number of representations [`variants`] would enumerate (saturating). +pub(crate) fn variant_count(e: &Arc, avail: &[(Arc, u64)]) -> u128 { + let shares = avail.iter().filter(|(x, _)| x == e).count() as u128; + let kids = e.children(); + if kids.is_empty() { + return shares + 1; + } + kids + .into_iter() + .map(|c| variant_count(c, avail)) + .fold(1u128, u128::saturating_mul) + .saturating_add(shares) +} diff --git a/crates/ixon/src/sharing_exact/par.rs b/crates/ixon/src/sharing_exact/par.rs new file mode 100644 index 000000000..d08ca5cc1 --- /dev/null +++ b/crates/ixon/src/sharing_exact/par.rs @@ -0,0 +1,56 @@ +//! Deterministic task splitting for the parallel paths of the tiered +//! construction. Results always come back in index order, so the callers +//! combine them exactly as the sequential path does. + +use std::ops::Range; + +/// Split `0..n` into at most `budget` contiguous ranges of nearly equal +/// length (none empty). +pub(crate) fn split(n: usize, budget: usize) -> Vec> { + let tasks = budget.clamp(1, n.max(1)); + let size = n.div_ceil(tasks).max(1); + (0..n).step_by(size).map(|s| s..(s + size).min(n)).collect() +} + +/// Run `f` on the ranges of [`split`]`(n, budget)`, in parallel on the +/// current rayon pool when `budget > 1`, and concatenate the results in +/// range order. With `budget <= 1` (or without rayon) this is `f(0..n)`. +pub(crate) fn map_ranges(n: usize, budget: usize, f: F) -> Vec +where + R: Send, + F: Fn(Range) -> Vec + Sync, +{ + if budget <= 1 || n <= 1 { + return f(0..n); + } + #[cfg(not(target_arch = "riscv64"))] + { + use rayon::prelude::*; + let parts: Vec> = split(n, budget).into_par_iter().map(&f).collect(); + parts.into_iter().flatten().collect() + } + #[cfg(target_arch = "riscv64")] + { + f(0..n) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn split_covers_in_order() { + for n in 0..40 { + for b in 0..12 { + let r = split(n, b); + let flat: Vec = r.iter().cloned().flatten().collect(); + assert_eq!(flat, (0..n).collect::>()); + assert!(r.len() <= b.max(1)); + assert!(r.iter().all(|x| !x.is_empty())); + } + } + let v = map_ranges(37, 5, |r| r.map(|i| i * 2).collect()); + assert_eq!(v, (0..37).map(|i| i * 2).collect::>()); + } +} diff --git a/crates/ixon/src/sharing_exact/prof.rs b/crates/ixon/src/sharing_exact/prof.rs new file mode 100644 index 000000000..da061df9f --- /dev/null +++ b/crates/ixon/src/sharing_exact/prof.rs @@ -0,0 +1,155 @@ +//! Scoped phase timers of the tiered construction, for profiling only. +//! +//! With the `sharing-profile` feature every [`scope`] adds its wall time +//! (per thread, summed over threads) to a process-wide counter of its +//! [`Phase`]; [`report`] reads the counters. Without the feature (the +//! default) [`scope`] is an empty value and nothing is measured. Timing never +//! affects the construction. + +/// A timed part of the construction. Scopes of different phases do not +/// nest, except [`Phase::Total`], which wraps one construction after its DAG +/// is built (the [`Phase::Dag`] scope comes before it). +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum Phase { + /// One whole tiered construction (DAG built). + Total, + /// Expansion of the input into the structural DAG. + Dag, + /// Per width: the candidate count and graph facts of `tiered_at`. + Prep, + /// Phase 1: graph facts, spine tables, bounds and the classification. + Classify, + /// Phase 1: the component searches. + Search, + /// Phase 1: the table-count knapsack. + Knapsack, + /// Phase 1: model length, pinned order and decisions of the uniform + /// optimum, and the building of its expressions where they are built. + UniformMaterialize, + /// Phase 1: the dry run (what the expressions contain, their real length), + /// or the re-expansion check and real length of built expressions. + UniformCheck, + /// Phase 2: reference counts, first tier, Kahn order. + Allocate, + /// Phase 3: dictionary evaluations (the whole table, or every prefix). + RematerializeCosts, + /// Phase 3: materialization decisions of the entries and roots. + RematerializeDecide, + /// Phase 3: building the expressions of the decisions. + RematerializeBuild, + /// Phase 3: price, re-expansion and length checks. + RematerializeCheck, + /// Reassembly and serialization of the output Constant. + Output, +} + +impl Phase { + #[cfg_attr(not(feature = "sharing-profile"), allow(dead_code))] + pub(crate) const ALL: [Phase; 14] = [ + Phase::Total, + Phase::Dag, + Phase::Prep, + Phase::Classify, + Phase::Search, + Phase::Knapsack, + Phase::UniformMaterialize, + Phase::UniformCheck, + Phase::Allocate, + Phase::RematerializeCosts, + Phase::RematerializeDecide, + Phase::RematerializeBuild, + Phase::RematerializeCheck, + Phase::Output, + ]; + + #[cfg_attr(not(feature = "sharing-profile"), allow(dead_code))] + fn name(self) -> &'static str { + match self { + Phase::Total => "total", + Phase::Dag => "dag", + Phase::Prep => "prep", + Phase::Classify => "p1.classify", + Phase::Search => "p1.search", + Phase::Knapsack => "p1.knapsack", + Phase::UniformMaterialize => "p1.materialize", + Phase::UniformCheck => "p1.check", + Phase::Allocate => "p2.allocate", + Phase::RematerializeCosts => "p3.costs", + Phase::RematerializeDecide => "p3.decide", + Phase::RematerializeBuild => "p3.build", + Phase::RematerializeCheck => "p3.check", + Phase::Output => "output", + } + } +} + +#[cfg(feature = "sharing-profile")] +mod imp { + use std::sync::atomic::{AtomicU64, Ordering}; + use std::time::Instant; + + use super::Phase; + + const N: usize = Phase::ALL.len(); + static NANOS: [AtomicU64; N] = [const { AtomicU64::new(0) }; N]; + static CALLS: [AtomicU64; N] = [const { AtomicU64::new(0) }; N]; + + pub(crate) struct Scope { + phase: Phase, + start: Instant, + } + + impl Drop for Scope { + fn drop(&mut self) { + let ns = u64::try_from(self.start.elapsed().as_nanos()).unwrap_or(0); + NANOS[self.phase as usize].fetch_add(ns, Ordering::Relaxed); + CALLS[self.phase as usize].fetch_add(1, Ordering::Relaxed); + } + } + + pub(crate) fn scope(phase: Phase) -> Scope { + Scope { phase, start: Instant::now() } + } + + pub(crate) fn report() -> Vec<(&'static str, u64, u64)> { + Phase::ALL + .iter() + .map(|&p| { + ( + p.name(), + NANOS[p as usize].load(Ordering::Relaxed), + CALLS[p as usize].load(Ordering::Relaxed), + ) + }) + .collect() + } +} + +#[cfg(not(feature = "sharing-profile"))] +mod imp { + use super::Phase; + + pub(crate) struct Scope; + + // Scopes are ended with `drop`, as with the feature. + impl Drop for Scope { + fn drop(&mut self) {} + } + + #[inline(always)] + pub(crate) fn scope(_phase: Phase) -> Scope { + Scope + } + + pub(crate) fn report() -> Vec<(&'static str, u64, u64)> { + Vec::new() + } +} + +pub(crate) use imp::scope; + +/// Per phase: name, summed nanoseconds and scope count (empty without the +/// `sharing-profile` feature). +pub fn profile_report() -> Vec<(&'static str, u64, u64)> { + imp::report() +} diff --git a/crates/ixon/src/sharing_exact/roots.rs b/crates/ixon/src/sharing_exact/roots.rs new file mode 100644 index 000000000..7c4085ba7 --- /dev/null +++ b/crates/ixon/src/sharing_exact/roots.rs @@ -0,0 +1,205 @@ +//! Ordered expression roots of a ConstantInfo and their exact reassembly. +//! +//! The order mirrors Lean's `Ix.CompileM.constantInfoRootExprs` and the Rust +//! compiler's `apply_sharing_to_*` layout: definitions `[type, value]`; +//! axioms and quotients `[type]`; recursors `type` then every rule `rhs`; +//! mutual blocks flatten each member in order (an inductive contributes its +//! type then each constructor type); projections contribute nothing. + +use std::sync::Arc; + +use super::{MalformedSharing, SharingError}; +use crate::constant::{ + ConstantInfo, Constructor, Definition, Inductive, MutConst, Recursor, + RecursorRule, +}; +use crate::expr::Expr; + +fn push_mut_const_roots(m: &MutConst, out: &mut Vec>) { + match m { + MutConst::Defn(d) => { + out.push(d.typ.clone()); + out.push(d.value.clone()); + }, + MutConst::Indc(i) => { + out.push(i.typ.clone()); + out.extend(i.ctors.iter().map(|c| c.typ.clone())); + }, + MutConst::Recr(r) => push_recursor_roots(r, out), + } +} + +fn push_recursor_roots(r: &Recursor, out: &mut Vec>) { + out.push(r.typ.clone()); + out.extend(r.rules.iter().map(|rule| rule.rhs.clone())); +} + +/// The ordered sharing roots of `info`. +pub fn constant_info_root_exprs(info: &ConstantInfo) -> Vec> { + let mut out = Vec::new(); + match info { + ConstantInfo::Defn(d) => { + out.push(d.typ.clone()); + out.push(d.value.clone()); + }, + ConstantInfo::Recr(r) => push_recursor_roots(r, &mut out), + ConstantInfo::Axio(a) => out.push(a.typ.clone()), + ConstantInfo::Quot(q) => out.push(q.typ.clone()), + ConstantInfo::CPrj(_) + | ConstantInfo::RPrj(_) + | ConstantInfo::IPrj(_) + | ConstantInfo::DPrj(_) => {}, + ConstantInfo::Muts(ms) => { + for m in ms { + push_mut_const_roots(m, &mut out); + } + }, + } + out +} + +/// Number of roots [`constant_info_root_exprs`] returns, without cloning. +pub fn constant_info_root_count(info: &ConstantInfo) -> usize { + fn mut_count(m: &MutConst) -> usize { + match m { + MutConst::Defn(_) => 2, + MutConst::Indc(i) => 1 + i.ctors.len(), + MutConst::Recr(r) => 1 + r.rules.len(), + } + } + match info { + ConstantInfo::Defn(_) => 2, + ConstantInfo::Recr(r) => 1 + r.rules.len(), + ConstantInfo::Axio(_) | ConstantInfo::Quot(_) => 1, + ConstantInfo::CPrj(_) + | ConstantInfo::RPrj(_) + | ConstantInfo::IPrj(_) + | ConstantInfo::DPrj(_) => 0, + ConstantInfo::Muts(ms) => ms.iter().map(mut_count).sum(), + } +} + +struct Feed<'a> { + roots: &'a [Arc], + next: usize, +} + +impl Feed<'_> { + fn take(&mut self) -> Option> { + let e = self.roots.get(self.next)?.clone(); + self.next += 1; + Some(e) + } +} + +fn rebuild_definition( + d: &Definition, + feed: &mut Feed<'_>, +) -> Option { + Some(Definition { + kind: d.kind, + safety: d.safety, + lvls: d.lvls, + typ: feed.take()?, + value: feed.take()?, + }) +} + +fn rebuild_recursor(r: &Recursor, feed: &mut Feed<'_>) -> Option { + let typ = feed.take()?; + let mut rules = Vec::with_capacity(r.rules.len()); + for rule in &r.rules { + rules.push(RecursorRule { fields: rule.fields, rhs: feed.take()? }); + } + Some(Recursor { + k: r.k, + is_unsafe: r.is_unsafe, + lvls: r.lvls, + params: r.params, + indices: r.indices, + motives: r.motives, + minors: r.minors, + typ, + rules, + }) +} + +fn rebuild_inductive(i: &Inductive, feed: &mut Feed<'_>) -> Option { + let typ = feed.take()?; + let mut ctors = Vec::with_capacity(i.ctors.len()); + for c in &i.ctors { + ctors.push(Constructor { + is_unsafe: c.is_unsafe, + lvls: c.lvls, + cidx: c.cidx, + params: c.params, + fields: c.fields, + typ: feed.take()?, + }); + } + Some(Inductive { + is_unsafe: i.is_unsafe, + lvls: i.lvls, + params: i.params, + indices: i.indices, + typ, + ctors, + }) +} + +fn rebuild_with( + info: &ConstantInfo, + feed: &mut Feed<'_>, +) -> Option { + Some(match info { + ConstantInfo::Defn(d) => ConstantInfo::Defn(rebuild_definition(d, feed)?), + ConstantInfo::Recr(r) => ConstantInfo::Recr(rebuild_recursor(r, feed)?), + ConstantInfo::Axio(a) => { + let mut a = a.clone(); + a.typ = feed.take()?; + ConstantInfo::Axio(a) + }, + ConstantInfo::Quot(q) => { + let mut q = q.clone(); + q.typ = feed.take()?; + ConstantInfo::Quot(q) + }, + ConstantInfo::CPrj(_) + | ConstantInfo::RPrj(_) + | ConstantInfo::IPrj(_) + | ConstantInfo::DPrj(_) => info.clone(), + ConstantInfo::Muts(ms) => { + let mut out = Vec::with_capacity(ms.len()); + for m in ms { + out.push(match m { + MutConst::Defn(d) => MutConst::Defn(rebuild_definition(d, feed)?), + MutConst::Indc(i) => MutConst::Indc(rebuild_inductive(i, feed)?), + MutConst::Recr(r) => MutConst::Recr(rebuild_recursor(r, feed)?), + }); + } + ConstantInfo::Muts(out) + }, + }) +} + +/// Replace the roots of `info`, in [`constant_info_root_exprs`] order, by +/// `roots`. Every non-expression field is kept. Fails unless the rebuild +/// consumes exactly `roots.len()` expressions. +pub fn rebuild_constant_info( + info: &ConstantInfo, + roots: &[Arc], +) -> Result { + let expected = constant_info_root_count(info); + let mismatch = || { + SharingError::Malformed(MalformedSharing::RootCountMismatch { + expected: u64::try_from(expected).unwrap_or(u64::MAX), + actual: u64::try_from(roots.len()).unwrap_or(u64::MAX), + }) + }; + let mut feed = Feed { roots, next: 0 }; + let rebuilt = rebuild_with(info, &mut feed).ok_or_else(mismatch)?; + if feed.next != roots.len() || expected != roots.len() { + return Err(mismatch()); + } + Ok(rebuilt) +} diff --git a/crates/ixon/src/sharing_exact/search.rs b/crates/ixon/src/sharing_exact/search.rs new file mode 100644 index 000000000..139582673 --- /dev/null +++ b/crates/ixon/src/sharing_exact/search.rs @@ -0,0 +1,846 @@ +//! Exact table selection and ordering (§6): the width-state search for the +//! global minimum of `docs/sharing-minimum.md` §3. Exponential in the +//! candidates, it is a test oracle for small inputs (and the reference of +//! the uniform optimizer's tests), not on the compiler path. +//! +//! A width state assigns each stored term the Share width of its index. By +//! §6.2 every future length depends only on the state, so histories reaching +//! one state merge: the state keeps its least accumulated body length `F` +//! and, among histories of that length, the least term-ID prefix. States are +//! sparse sorted `(term, width)` vectors, expanded layer by layer (layer `k` +//! holds states with `k` entries) in sorted key order, so work counters and +//! failures are deterministic. +//! +//! Candidates are the terms that some minimum may store: R1 drops terms with +//! one expanded occurrence and R2 terms whose inline encoding is one byte. +//! Both reductions strictly shorten any encoding that violates them, so they +//! preserve every minimum-length encoding and hence the canonical key. +//! +//! # Pruning +//! +//! A state is dropped only if a lower bound on every completion is strictly +//! above the length of a feasible encoding, so states that could tie the +//! minimum survive for the tie-break. Two bounds are used; either may prune. +//! +//! **Dictionary bound (§4.1).** At state `M` with `k` entries every later +//! entry has an index `>= k`, hence a Share width `>= share_width(k)`. Let +//! `M+` extend `M` with every absent candidate at width `share_width(k)` +//! (the plan's width 1 is the case `k < 8`). `C` is antitone in +//! availability and monotone in widths, later bodies cost `>= 0` and the +//! table count prefix never shrinks, so every completion has length at +//! least `F(M) + tag0(k) + sum C_{M+}(root)`. For a successor +//! `M + (t, share_width(k))` the same sum is still a lower bound, because +//! `t` keeps the width `M+` gave it and other widths only grow. +//! +//! **Materialization bound.** Let `E(M)` be the terms that occur in the +//! expansions of the entries of `M`. Those entries emit only terms of +//! `E(M)`. Every other term `t` must still have its constructor emitted +//! inline at least once, in a later entry or a root: follow any occurrence +//! through Shares until a representation emits it. Pick one such emission +//! per non-leaf `t` outside `E(M)`. It owns bytes no other picked emission +//! owns: `t`'s own bytes (Prj/Let headers, a Lam/All contract byte) and, at +//! each child position that holds a leaf, that leaf's inline encoding or a +//! Share (at least one byte for a candidate leaf; the inline length for any +//! other leaf, since only candidates are ever stored). An App/Lam/All node +//! that is never the same-family spine child of any parent starts a +//! telescope wherever it is emitted inline, so its picked emission also owns +//! one header byte (a "header top"). No other telescope header and no Share +//! byte at a non-leaf position is counted. Each root position adds bytes not +//! yet counted: a leaf root as a leaf position; a root in `E(M)` contains no +//! picked emission, so its whole representation, at least `C_{M+}(root)`; +//! an App/Lam/All root outside `E(M)` that is not a header top, its +//! telescope header or Share byte; any other root outside `E(M)`, a Share +//! or unpicked header byte at every position except possibly the one +//! holding its picked emission. The picked bytes lie outside the bodies +//! counted by `F(M)`, so `F(M) + tag0(k) + (picked) + (root bytes)` bounds +//! every completion. +//! +//! Both bounds hold for every completion by candidates, and every +//! minimum-length encoding is such a completion of each state on its path, +//! so no state on the path of a minimum is ever pruned. +//! +//! # Upper bounds +//! +//! The initial feasible length is the lesser of the unshared encoding and a +//! deterministic greedy table sequence. They only tighten pruning; neither is +//! returned unless the search certifies it. + +use std::sync::Arc; + +use rustc_hash::FxHashMap; + +use super::cost::{Len, expr_len, share_width, sharing_table_len, tag0_len}; +use super::dag::{Node, SharingDag, TermId, ix}; +use super::dict::{ + DenseIndex, NoWidths, Widths, all_costs, eval_node, materialize, +}; +use super::{ExactSharingResult, FormatBound, Meter, SharingError}; +use crate::expr::Expr; + +fn internal(msg: impl Into) -> SharingError { + SharingError::Internal(msg.into()) +} + +fn tid(i: usize) -> TermId { + TermId::try_from(i).unwrap_or(TermId::MAX) +} + +/// Per-DAG data shared by every state evaluation. +pub(crate) struct Prepared { + pub(crate) own: Vec, + /// `C` under the empty dictionary: the unshared standalone lengths. + pub(crate) base: Vec, + pub(crate) cands: Vec, + pub(crate) is_cand: Vec, + /// Materialization-bound bytes of one picked emission of each non-leaf + /// term (0 for leaves), and their sum. + pub(crate) picked: Vec, + pub(crate) picked_total: Len, + /// Lower bound on the bytes at a position holding each leaf. + pub(crate) leaf_pos: Vec, + /// App/Lam/All nodes whose picked emission owns a telescope header. + pub(crate) header_top: Vec, + parent_start: Vec, + parents: Vec, +} + +impl Prepared { + fn parents_of(&self, t: TermId) -> &[TermId] { + &self.parents[self.parent_start[ix(t)]..self.parent_start[ix(t) + 1]] + } +} + +/// Every candidate at one width. +struct Candidates<'a> { + is_cand: &'a [bool], + width: u64, +} + +impl Widths for Candidates<'_> { + fn width(&self, t: TermId) -> Option { + self.is_cand[ix(t)].then_some(self.width) + } +} + +/// Expanded occurrence counts (saturating) of every term. +pub(crate) fn occurrences(dag: &SharingDag) -> Vec { + let nodes = dag.nodes(); + let mut occ = vec![0u64; nodes.len()]; + for &r in dag.roots() { + occ[ix(r)] = occ[ix(r)].saturating_add(1); + } + // Parents have larger IDs than children: a descending sweep sees each + // node's final count before propagating it along every child edge. + for t in (0..nodes.len()).rev() { + let o = occ[t]; + if o == 0 { + continue; + } + for &c in nodes[t].children().as_slice() { + occ[ix(c)] = occ[ix(c)].saturating_add(o); + } + } + occ +} + +fn candidates_of(occ: &[u64], base: &[Len]) -> Vec { + (0..occ.len()) + .filter(|&t| occ[t] >= 2 && base[t] > Len::new(1)) + .map(tid) + .collect() +} + +/// The terms some minimum may store after reductions R1 (at least two +/// expanded occurrences) and R2 (inline encoding longer than one byte), in +/// term-ID order. Its length is the search's candidate count. +pub fn candidate_terms(dag: &SharingDag) -> Vec { + let own: Vec = dag.nodes().iter().map(Node::own_len).collect(); + let base = all_costs(dag.nodes(), &own, &NoWidths, &mut 0); + candidates_of(&occurrences(dag), &base) +} + +pub(crate) fn prepare( + dag: &SharingDag, + meter: &mut Meter<'_>, +) -> Result { + prepare_with(dag, meter, |_| true) +} + +/// [`prepare`] keeping only the R1/R2 candidates accepted by `keep`. +pub(crate) fn prepare_with( + dag: &SharingDag, + meter: &mut Meter<'_>, + keep: impl Fn(TermId) -> bool, +) -> Result { + let nodes = dag.nodes(); + let n = nodes.len(); + let own: Vec = nodes.iter().map(Node::own_len).collect(); + let mut work = 0u64; + let base = all_costs(nodes, &own, &NoWidths, &mut work); + let occ = occurrences(dag); + let cands: Vec = + candidates_of(&occ, &base).into_iter().filter(|&t| keep(t)).collect(); + meter.candidates(u64::try_from(cands.len()).unwrap_or(u64::MAX))?; + let mut is_cand = vec![false; n]; + for &t in &cands { + is_cand[ix(t)] = true; + } + let leaf_pos: Vec = + (0..n).map(|t| if is_cand[t] { Len::new(1) } else { base[t] }).collect(); + // A node that is never the same-family spine child of a parent starts a + // telescope at every inline emission, so its picked emission owns that + // telescope's header. + let mut spine_child = vec![false; n]; + for node in nodes { + let next = match node { + Node::App(f, _) => Some(*f), + Node::Lam(_, _, b) | Node::All(_, _, _, b) => Some(*b), + _ => None, + }; + if let Some(c) = next + && nodes[ix(c)].family() == node.family() + { + spine_child[ix(c)] = true; + } + } + let mut header_top = vec![false; n]; + let mut picked = vec![Len::ZERO; n]; + let mut picked_total = Len::ZERO; + for (t, node) in nodes.iter().enumerate() { + let kids = node.children(); + if kids.as_slice().is_empty() { + continue; + } + let mut p = own[t]; + if node.family().is_some() && !spine_child[t] { + header_top[t] = true; + p = p.plus_u64(1); + } + for &c in kids.as_slice() { + if nodes[ix(c)].children().as_slice().is_empty() { + p = p.plus(leaf_pos[ix(c)]); + } + } + picked[t] = p; + picked_total = picked_total.plus(p); + } + // Distinct parents of every node, in CSR form. + let mut count = vec![0usize; n + 1]; + for node in nodes { + let kids = node.children(); + let kids = kids.as_slice(); + for (i, &c) in kids.iter().enumerate() { + if !kids[..i].contains(&c) { + count[ix(c)] += 1; + } + } + } + let mut parent_start = vec![0usize; n + 1]; + for i in 0..n { + parent_start[i + 1] = parent_start[i] + count[i]; + } + let mut fill = parent_start.clone(); + let mut parents = vec![0; parent_start[n]]; + for (p, node) in nodes.iter().enumerate() { + let kids = node.children(); + let kids = kids.as_slice(); + for (i, &c) in kids.iter().enumerate() { + if !kids[..i].contains(&c) { + parents[fill[ix(c)]] = tid(p); + fill[ix(c)] += 1; + } + } + } + meter.work(work)?; + Ok(Prepared { + own, + base, + cands, + is_cand, + picked, + picked_total, + leaf_pos, + header_top, + parent_start, + parents, + }) +} + +struct DenseWidths<'a>(&'a [u8]); + +impl Widths for DenseWidths<'_> { + fn width(&self, t: TermId) -> Option { + match self.0[ix(t)] { + 0 => None, + w => Some(u64::from(w)), + } + } +} + +/// `M+`: the state's widths, and `plus` for every other candidate. +struct PlusWidths<'a> { + m: &'a [u8], + is_cand: &'a [bool], + plus: u64, +} + +impl Widths for PlusWidths<'_> { + fn width(&self, t: TermId) -> Option { + match self.m[ix(t)] { + 0 => self.is_cand[ix(t)].then_some(self.plus), + w => Some(u64::from(w)), + } + } +} + +/// Costs of one evaluated state. +struct StateCosts { + /// `sum C_M(root)`. + roots: Len, + /// `sum C_{M+}(root)`: the dictionary bound's variable part. + roots_plus: Len, + /// Picked and root bytes of the materialization bound. + materialization: Len, +} + +/// Scratch space for evaluating one state at a time. +/// +/// `C_M(t)` differs from the unshared `C(t)` only if `t` or a descendant is +/// stored, and `C_{M+}(t)` differs from its all-candidates value under the +/// same condition. Only those ancestors are recomputed. +struct StateEval<'p> { + prep: &'p Prepared, + nodes: &'p [Node], + roots: &'p [TermId], + width_m: Vec, + stamp: Vec, + covered: Vec, + seen_root: Vec, + epoch: u32, + cost_m: Vec, + cost_p: Vec, + affected: Vec, + todo: Vec, + /// Width given to absent candidates by `M+`, and `C` under exactly that + /// dictionary (every candidate at `plus`). + plus: u64, + plus_base: Vec, +} + +impl<'p> StateEval<'p> { + fn new(prep: &'p Prepared, dag: &'p SharingDag, work: &mut u64) -> Self { + let n = dag.len(); + let plus_base = all_costs( + dag.nodes(), + &prep.own, + &Candidates { is_cand: &prep.is_cand, width: 1 }, + work, + ); + StateEval { + prep, + nodes: dag.nodes(), + roots: dag.roots(), + width_m: vec![0; n], + stamp: vec![0; n], + covered: vec![0; n], + seen_root: vec![0; n], + epoch: 0, + cost_m: vec![Len::ZERO; n], + cost_p: vec![Len::ZERO; n], + affected: Vec::new(), + todo: Vec::new(), + plus: 1, + plus_base, + } + } + + /// Switch `M+` to give absent candidates width `plus`. + fn set_plus(&mut self, plus: u64, work: &mut u64) { + if plus != self.plus { + self.plus = plus; + self.plus_base = all_costs( + self.nodes, + &self.prep.own, + &Candidates { is_cand: &self.prep.is_cand, width: plus }, + work, + ); + } + } + + fn cost_m(&self, t: TermId) -> Len { + if self.stamp[ix(t)] == self.epoch { + self.cost_m[ix(t)] + } else { + self.prep.base[ix(t)] + } + } + + fn cost_p(&self, t: TermId) -> Len { + if self.stamp[ix(t)] == self.epoch { + self.cost_p[ix(t)] + } else { + self.plus_base[ix(t)] + } + } + + fn eval(&mut self, m: &[(TermId, u8)], work: &mut u64) -> StateCosts { + if self.epoch == u32::MAX { + self.stamp.fill(0); + self.covered.fill(0); + self.seen_root.fill(0); + self.epoch = 0; + } + self.epoch += 1; + let ep = self.epoch; + // Ancestors of stored terms: the only terms whose costs change. + self.affected.clear(); + for &(t, w) in m { + self.width_m[ix(t)] = w; + self.stamp[ix(t)] = ep; + self.affected.push(t); + } + let mut i = 0; + while i < self.affected.len() { + let x = self.affected[i]; + i += 1; + for &p in self.prep.parents_of(x) { + *work = work.saturating_add(1); + if self.stamp[ix(p)] != ep { + self.stamp[ix(p)] = ep; + self.affected.push(p); + } + } + } + self.affected.sort_unstable(); + for a in 0..self.affected.len() { + let t = self.affected[a]; + let cm = eval_node( + self.nodes, + &self.prep.own, + t, + &DenseWidths(&self.width_m), + &|c| self.cost_m(c), + false, + work, + ) + .0; + self.cost_m[ix(t)] = cm; + let widths = PlusWidths { + m: &self.width_m, + is_cand: &self.prep.is_cand, + plus: self.plus, + }; + let cp = eval_node( + self.nodes, + &self.prep.own, + t, + &widths, + &|c| self.cost_p(c), + false, + work, + ) + .0; + self.cost_p[ix(t)] = cp; + } + // E(M): descendants-or-self of stored terms, and their picked bytes. + let mut covered_bytes = Len::ZERO; + self.todo.clear(); + for &(t, _) in m { + if self.covered[ix(t)] != ep { + self.covered[ix(t)] = ep; + self.todo.push(t); + } + } + while let Some(x) = self.todo.pop() { + *work = work.saturating_add(1); + covered_bytes = covered_bytes.plus(self.prep.picked[ix(x)]); + for &c in self.nodes[ix(x)].children().as_slice() { + if self.covered[ix(c)] != ep { + self.covered[ix(c)] = ep; + self.todo.push(c); + } + } + } + let mut roots = Len::ZERO; + let mut roots_plus = Len::ZERO; + let mut root_bytes = Len::ZERO; + for &r in self.roots { + roots = roots.plus(self.cost_m(r)); + let cp = self.cost_p(r); + roots_plus = roots_plus.plus(cp); + let node = &self.nodes[ix(r)]; + let extra = if node.children().as_slice().is_empty() { + self.prep.leaf_pos[ix(r)] + } else if self.covered[ix(r)] == ep { + cp + } else if (node.family().is_some() && !self.prep.header_top[ix(r)]) + || self.seen_root[ix(r)] == ep + { + // An uncounted header or Share byte at this position. + Len::new(1) + } else { + // Possibly the position of the picked emission: count nothing. + self.seen_root[ix(r)] = ep; + Len::ZERO + }; + root_bytes = root_bytes.plus(extra); + } + // picked_total >= covered_bytes: E(M) is a set of distinct terms. + let outside = Len::new( + self.prep.picked_total.raw().saturating_sub(covered_bytes.raw()), + ); + let materialization = if self.prep.picked_total.is_exact() { + outside.plus(root_bytes) + } else { + Len::ZERO + }; + StateCosts { roots, roots_plus, materialization } + } + + fn reset(&mut self, m: &[(TermId, u8)]) { + for &(t, _) in m { + self.width_m[ix(t)] = 0; + } + } +} + +type StateKey = Vec<(TermId, u8)>; + +/// How a Share at table index `k` is priced. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum WidthModel { + /// The real TagN width of index `k`. + Ixon, + /// Every Share costs `w` bytes (the uniform-width cost model; the tests' + /// reference of the uniform optimizer). + #[cfg(test)] + Uniform(u8), +} + +impl WidthModel { + pub(crate) fn width(self, k: u64) -> u64 { + match self { + WidthModel::Ixon => share_width(k), + #[cfg(test)] + WidthModel::Uniform(w) => u64::from(w), + } + } +} + +/// Whether `prefix ++ [t]` is lexicographically below `other` (same length). +fn extension_less(prefix: &[TermId], t: TermId, other: &[TermId]) -> bool { + match prefix.cmp(&other[..prefix.len()]) { + std::cmp::Ordering::Less => true, + std::cmp::Ordering::Greater => false, + std::cmp::Ordering::Equal => t < other[prefix.len()], + } +} + +/// Insert `(t, w)` into a sorted state key. +fn extend_key(key: &[(TermId, u8)], t: TermId, w: u8) -> StateKey { + let pos = key.partition_point(|&(x, _)| x < t); + let mut out = Vec::with_capacity(key.len() + 1); + out.extend_from_slice(&key[..pos]); + out.push((t, w)); + out.extend_from_slice(&key[pos..]); + out +} + +/// A feasible upper bound: starting from the empty table, repeatedly append +/// the candidate whose addition gives the shortest encoding, while that is +/// strictly shorter than the current one. Candidates are tried in term-ID +/// order and ties keep the first, so the result is deterministic. The value +/// is the exact length of a real table sequence. +fn greedy_upper_bound( + eval: &mut StateEval<'_>, + prep: &Prepared, + meter: &mut Meter<'_>, + model: WidthModel, +) -> Result { + let mut key: StateKey = Vec::new(); + let mut f = Len::ZERO; + let mut k: u64 = 0; + let mut work = 0u64; + let costs = eval.eval(&key, &mut work); + let mut current = f.plus(Len::new(tag0_len(0))).plus(costs.roots); + let mut bodies: Vec<(TermId, Len)> = + prep.cands.iter().map(|&t| (t, eval.cost_m(t))).collect(); + eval.reset(&key); + meter.work(std::mem::take(&mut work))?; + loop { + let w = u8::try_from(model.width(k)) + .map_err(|_e| internal("share width exceeds u8"))?; + let count = Len::new(tag0_len(k.saturating_add(1))); + let mut step: Option<(Len, TermId, Len)> = None; + for &(t, c) in &bodies { + let nf = f.plus(c); + let next = extend_key(&key, t, w); + let total = nf.plus(count).plus(eval.eval(&next, &mut work).roots); + eval.reset(&next); + meter.work(std::mem::take(&mut work))?; + if total < current && step.is_none_or(|(best, _, _)| total < best) { + step = Some((total, t, nf)); + } + } + let Some((total, t, nf)) = step else { + return Ok(current); + }; + key = extend_key(&key, t, w); + f = nf; + k = k.saturating_add(1); + current = total; + eval.eval(&key, &mut work); + bodies = prep + .cands + .iter() + .filter(|&&x| eval.width_m[ix(x)] == 0) + .map(|&x| (x, eval.cost_m(x))) + .collect(); + eval.reset(&key); + meter.work(std::mem::take(&mut work))?; + } +} + +/// The width-state dynamic program. Returns the least `(variable length, +/// term-ID sequence)` over all table sequences, or a resource error. +pub(crate) fn width_state_search( + dag: &SharingDag, + prep: &Prepared, + mut ub: Len, + meter: &mut Meter<'_>, + model: WidthModel, +) -> Result<(Len, Vec), SharingError> { + let prune = meter.limits().lower_bound_pruning; + let materialization = meter.limits().materialization_bound; + let mut work = 0u64; + let mut eval = StateEval::new(prep, dag, &mut work); + meter.work(work)?; + if prune && meter.limits().greedy_upper_bound && !prep.cands.is_empty() { + let g = greedy_upper_bound(&mut eval, prep, meter, model)?; + meter.stats.greedy_len = g.exact(); + ub = ub.min(g); + } + let mut best: Option<(Len, Vec)> = None; + let mut layer: Vec<(StateKey, Len, Vec)> = + vec![(Vec::new(), Len::ZERO, Vec::new())]; + meter.state()?; + let mut k: u64 = 0; + while !layer.is_empty() { + meter.stats.layers += 1; + meter.layer(u64::try_from(layer.len()).unwrap_or(u64::MAX))?; + let count_k = Len::new(tag0_len(k)); + let count_next = Len::new(tag0_len(k.saturating_add(1))); + let width_k = model.width(k); + let width_next = + u8::try_from(width_k).map_err(|_e| internal("share width exceeds u8"))?; + let mut work = 0u64; + eval.set_plus(width_k, &mut work); + meter.work(work)?; + let mut next: FxHashMap)> = + FxHashMap::default(); + for (key, f, prefix) in layer { + meter.stats.states_expanded += 1; + let mut work = 0u64; + let costs = eval.eval(&key, &mut work); + meter.work(work)?; + let dict_lower = f.plus(count_k).plus(costs.roots_plus); + let mat_lower = if materialization { + f.plus(count_k).plus(costs.materialization) + } else { + Len::ZERO + }; + if prune && dict_lower.max(mat_lower) > ub { + meter.stats.states_pruned += 1; + eval.reset(&key); + continue; + } + let total = f.plus(count_k).plus(costs.roots); + let improves = match &best { + None => true, + Some((bt, bq)) => (total, &prefix) < (*bt, bq), + }; + if improves { + best = Some((total, prefix.clone())); + } + ub = ub.min(total); + let lower_next = count_next.plus(costs.roots_plus); + for &t in &prep.cands { + if eval.width_m[ix(t)] != 0 { + continue; + } + meter.transition()?; + let nf = f.plus(eval.cost_m(t)); + if !nf.is_exact() || (prune && nf.plus(lower_next) > ub) { + continue; + } + match next.entry(extend_key(&key, t, width_next)) { + std::collections::hash_map::Entry::Vacant(v) => { + meter.state()?; + let mut np = prefix.clone(); + np.push(t); + v.insert((nf, np)); + }, + std::collections::hash_map::Entry::Occupied(mut o) => { + let (of, op) = o.get(); + if nf < *of || (nf == *of && extension_less(&prefix, t, op)) { + let mut np = prefix.clone(); + np.push(t); + o.insert((nf, np)); + } + }, + } + } + eval.reset(&key); + } + let mut v: Vec<(StateKey, Len, Vec)> = + next.into_iter().map(|(key, (f, p))| (key, f, p)).collect(); + v.sort_unstable_by(|a, b| a.0.cmp(&b.0)); + layer = v; + k = k.saturating_add(1); + } + best.ok_or_else(|| internal("every width state was pruned")) +} + +/// Exact variable length of the table sequence `q` with every entry and +/// root at its minimum: `sum C_{q Result { + let n = dag.len(); + let mut seen = vec![false; n]; + for &t in q { + if ix(t) >= n || seen[ix(t)] { + return Err(internal("sequence term out of range or repeated")); + } + seen[ix(t)] = true; + } + let own: Vec = dag.nodes().iter().map(Node::own_len).collect(); + let mut dict = DenseIndex::new(n); + let mut work = 0u64; + let k = u64::try_from(q.len()).map_err(|_e| internal("length"))?; + let mut total = Len::new(tag0_len(k)); + for (i, &t) in q.iter().enumerate() { + let costs = all_costs(dag.nodes(), &own, &dict, &mut work); + total = total.plus(costs[ix(t)]); + dict.set(t, u64::try_from(i).map_err(|_e| internal("index"))?); + } + let costs = all_costs(dag.nodes(), &own, &dict, &mut work); + for &r in dag.roots() { + total = total.plus(costs[ix(r)]); + } + Ok(total) +} + +/// Materialize the canonical representation of table sequence `q`. +pub(crate) fn materialize_sequence( + dag: &SharingDag, + own: &[Len], + q: &[TermId], + meter: &mut Meter<'_>, +) -> Result<(Vec>, Vec>), SharingError> { + let nodes = dag.nodes(); + let mut dict = DenseIndex::new(dag.len()); + let mut table = Vec::with_capacity(q.len()); + let mut work = 0u64; + for (i, &t) in q.iter().enumerate() { + let costs = all_costs(nodes, own, &dict, &mut work); + let mut e = materialize(nodes, own, &dict, &costs, &[t], &mut work)?; + table.push(e.pop().ok_or_else(|| internal("entry"))?); + dict.set(t, u64::try_from(i).map_err(|_e| internal("index"))?); + meter.work(std::mem::take(&mut work))?; + } + let costs = all_costs(nodes, own, &dict, &mut work); + let roots = materialize(nodes, own, &dict, &costs, dag.roots(), &mut work)?; + meter.work(work)?; + Ok((roots, table)) +} + +/// Run the exact optimizer on `dag`. `fixed` is the byte length of the +/// non-sharing part of the enclosing Constant (0 for bare roots); it only +/// enters the output-size limit. +pub(crate) fn optimize( + dag: &SharingDag, + fixed: u64, + meter: &mut Meter<'_>, +) -> Result { + let prep = prepare(dag, meter)?; + let mut unshared = Len::new(tag0_len(0)); + for &r in dag.roots() { + unshared = unshared.plus(prep.base[ix(r)]); + } + meter.stats.unshared_len = unshared.exact(); + let (total, q) = + width_state_search(dag, &prep, unshared, meter, WidthModel::Ixon)?; + let variable = total + .exact() + .ok_or(SharingError::FormatBound(FormatBound::LengthOverflow))?; + let output = fixed + .checked_add(variable) + .filter(|&x| x != u64::MAX) + .ok_or(SharingError::FormatBound(FormatBound::LengthOverflow))?; + meter.output(output)?; + let (roots, sharing) = materialize_sequence(dag, &prep.own, &q, meter)?; + // Certification: the real encodings have the optimized length and expand, + // under the backward-reference rule, to exactly the input DAG. + let mut actual = sharing_table_len(&sharing) + .ok_or(SharingError::FormatBound(FormatBound::LengthOverflow))?; + for r in &roots { + actual = expr_len(r) + .and_then(|l| actual.checked_add(l)) + .ok_or(SharingError::FormatBound(FormatBound::LengthOverflow))?; + } + if actual != variable { + return Err(internal(format!( + "materialized length {actual} differs from optimized length {variable}" + ))); + } + let mut check_meter = Meter::new(meter.limits()); + let check = SharingDag::build(&roots, Some(&sharing), &mut check_meter)?; + if check != *dag { + return Err(internal("materialized encoding changes the expanded AST")); + } + Ok(ExactSharingResult { + roots, + sharing, + table_terms: q, + variable_len: variable, + stats: meter.stats.clone(), + }) +} + +/// Reference for the uniform-width model: the width-state search with every +/// Share priced `w`, over the R1/R2 candidates (optionally only those of +/// compact in-degree at least 2). Returns the minimum model length and the +/// least term-ID table sequence attaining it. Exponential; for tests. +#[cfg(test)] +pub(crate) fn uniform_reference_dag( + dag: &SharingDag, + w: u8, + min_in_degree2: bool, + meter: &mut Meter<'_>, +) -> Result<(u64, Vec), SharingError> { + if w == 0 { + return Err(SharingError::FormatBound(FormatBound::UniformWidth { w: 0 })); + } + let mut deg = vec![0u64; dag.len()]; + for &r in dag.roots() { + deg[ix(r)] += 1; + } + for node in dag.nodes() { + for &c in node.children().as_slice() { + deg[ix(c)] += 1; + } + } + let prep = prepare_with(dag, meter, |t| !min_in_degree2 || deg[ix(t)] >= 2)?; + let mut unshared = Len::new(tag0_len(0)); + for &r in dag.roots() { + unshared = unshared.plus(prep.base[ix(r)]); + } + let (total, q) = + width_state_search(dag, &prep, unshared, meter, WidthModel::Uniform(w))?; + let total = total + .exact() + .ok_or(SharingError::FormatBound(FormatBound::LengthOverflow))?; + Ok((total, q)) +} diff --git a/crates/ixon/src/sharing_exact/tests.rs b/crates/ixon/src/sharing_exact/tests.rs new file mode 100644 index 000000000..e68645ffe --- /dev/null +++ b/crates/ixon/src/sharing_exact/tests.rs @@ -0,0 +1,3846 @@ +//! Tests for exact minimum sharing: serializer-length helpers, structural +//! IDs, expansion validation, the fixed-dictionary recurrence against +//! enumeration, the width-state search against the tiny exhaustive oracle, +//! the §2 fixtures, representation independence and resource behavior. + +#![allow(clippy::cast_possible_truncation)] + +use std::collections::HashMap; + +use rustc_hash::FxHashMap; +use std::sync::Arc; + +use ix_common::address::Address; +use ix_common::env::{DefinitionSafety, QuotKind}; + +use super::cost::tag4_bytes_cmp; +use super::oracle::{ + bytes_of, oracle_full_product, oracle_ids, oracle_optimum, variant_count, + variants, +}; +use super::search::materialize_sequence; +use super::tiered::normalize_constant_sharing_tiered_at_width; +use super::*; +use crate::constant::{ + Axiom, Constant, ConstantInfo, Constructor, ConstructorProj, DefKind, + Definition, DefinitionProj, Inductive, InductiveProj, MutConst, Quotient, + Recursor, RecursorProj, RecursorRule, +}; +use crate::contract::{BinderContract, LetContract, ValueContract}; +use crate::expr::Expr; +use crate::serialize::put_expr; +use crate::tag::{TagN, u64_byte_count}; +use crate::univ::Univ; + +// =========================================================================== +// Helpers +// =========================================================================== + +type E = Arc; + +fn hex(b: &[u8]) -> String { + b.iter().map(|x| format!("{x:02x}")).collect() +} + +fn put(c: &Constant) -> Vec { + let mut b = Vec::new(); + c.put(&mut b); + b +} + +fn roundtrip(c: &Constant) -> Vec { + let b = put(c); + let mut s = b.as_slice(); + let d = Constant::get(&mut s).expect("decode"); + assert!(s.is_empty(), "trailing bytes"); + assert_eq!(&d, c); + b +} + +fn univs(n: usize) -> Vec> { + let mut out = vec![Univ::zero()]; + for _ in 1..n { + let last = out.last().unwrap().clone(); + out.push(Univ::succ(last)); + } + out +} + +fn axiom(root: E, univ_count: usize) -> Constant { + Constant { + info: ConstantInfo::Axio(Axiom { is_unsafe: false, lvls: 0, typ: root }), + sharing: vec![], + refs: vec![], + univs: univs(univ_count), + } +} + +/// `T_n = Prop -> ... -> Prop` with `n` binders. +fn chain(n: usize) -> E { + (0..n).fold(Expr::sort(0), |body, _| Expr::all(Expr::sort(0), body)) +} + +/// The default limits in the checked mode (`full_check`): every test of the +/// tiered construction builds and checks all its candidates. +fn limits() -> ExactSharingLimits { + ExactSharingLimits { full_check: true, ..ExactSharingLimits::default() } +} + +/// The constant with every root expanded and an empty table. +fn unshared(c: &Constant) -> Constant { + let dag = SharingDag::from_constant(c, &limits()).unwrap(); + let info = rebuild_constant_info(&c.info, &dag.root_exprs()).unwrap(); + Constant { + info, + sharing: vec![], + refs: c.refs.clone(), + univs: c.univs.clone(), + } +} + +/// Bytes of a hex string. +fn unhex(s: &str) -> Vec { + (0..s.len()) + .step_by(2) + .map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap()) + .collect() +} + +/// The 19-byte encoding of the T2 -> T2 witness written by the former +/// production heuristic (`docs/sharing-minimum.md` §2): a valid, longer +/// incoming encoding. +fn former_heuristic_t2() -> Constant { + let bytes = unhex("d200009117b1b10291170000911700b0000100"); + let mut slice = bytes.as_slice(); + let c = Constant::get(&mut slice).unwrap(); + assert!(slice.is_empty()); + c +} + +fn normalize(c: &Constant) -> Constant { + normalize_constant_sharing(c, &limits()).unwrap() +} + +/// Rebuild an expression with no pointer sharing at all. +fn deep_clone(e: &E) -> E { + let kids: Vec = e.children().into_iter().map(deep_clone).collect(); + if kids.is_empty() { + Arc::new(e.as_ref().clone()) + } else { + Arc::new(e.with_children(&kids).unwrap()) + } +} + +struct Rng(u64); + +impl Rng { + fn next(&mut self) -> u64 { + self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15); + let mut z = self.0; + z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9); + z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB); + z ^ (z >> 31) + } + fn below(&mut self, n: u64) -> u64 { + self.next() % n + } + fn pct(&mut self, p: u64) -> bool { + self.below(100) < p + } + fn pick<'a, T>(&mut self, xs: &'a [T]) -> &'a T { + &xs[self.below(xs.len() as u64) as usize] + } +} + +fn small_index(rng: &mut Rng) -> u64 { + if rng.pct(85) { rng.below(3) } else { *rng.pick(&[7, 8, 200, 300]) } +} + +fn value_contract(rng: &mut Rng) -> ValueContract { + ValueContract::from_bits(rng.below(4) as u8).unwrap() +} + +fn binder_contract(rng: &mut Rng) -> BinderContract { + BinderContract::from_bits(rng.below(16) as u8).unwrap() +} + +fn let_contract(rng: &mut Rng) -> LetContract { + LetContract::from_flags(rng.below(4), binder_contract(rng)).unwrap() +} + +/// Random expressions over every constructor, reusing earlier subterms so +/// that sharing matters. Contracts are drawn from a small set per call so +/// equal-shaped binders repeat. +struct ExprGen { + rng: Rng, + pool: Vec, + reuse: u64, + contracts: Vec<(BinderContract, ValueContract)>, +} + +impl ExprGen { + fn new(seed: u64, reuse: u64) -> Self { + let mut rng = Rng(seed); + let contracts = + (0..2).map(|_| (binder_contract(&mut rng), value_contract(&mut rng))); + let contracts = contracts.collect(); + ExprGen { rng, pool: vec![], reuse, contracts } + } + + fn leaf(&mut self) -> E { + let r = &mut self.rng; + match r.below(7) { + 0 | 1 => Expr::sort(small_index(r)), + 2 => Expr::var(small_index(r)), + 3 => { + let us = (0..r.below(3)).map(|_| r.below(2)).collect(); + Expr::reference(small_index(r), us) + }, + 4 => { + let us = (0..r.below(2)).map(|_| r.below(2)).collect(); + Expr::rec(r.below(2), us) + }, + 5 => Expr::str(small_index(r)), + _ => Expr::nat(small_index(r)), + } + } + + fn expr(&mut self, depth: u32) -> E { + if !self.pool.is_empty() && self.rng.pct(self.reuse) { + return self.rng.pick(&self.pool).clone(); + } + let e = if depth == 0 || self.rng.pct(30) { + self.leaf() + } else { + let (bc, vc) = *self.rng.pick(&self.contracts.clone()); + match self.rng.below(9) { + 0 | 1 => { + let f = self.expr(depth - 1); + let a = self.expr(depth - 1); + Expr::app(f, a) + }, + 2 | 3 => { + let ty = self.expr(depth - 1); + let b = self.expr(depth - 1); + Expr::lam_contract(bc, ty, b) + }, + 4 | 5 => { + let ty = self.expr(depth - 1); + let b = self.expr(depth - 1); + Expr::all_contract(bc, vc, ty, b) + }, + 6 => { + let lc = let_contract(&mut self.rng); + let ty = self.expr(depth - 1); + let v = self.expr(depth - 1); + let b = self.expr(depth - 1); + Expr::let_contract(lc, ty, v, b) + }, + 7 => { + let v = self.expr(depth - 1); + Expr::prj(small_index(&mut self.rng), self.rng.below(9), v) + }, + _ => { + // A same-family spine continuation. + let f = self.expr(depth - 1); + let a = self.expr(depth - 1); + let inner = Expr::app(f, a); + let b = self.expr(depth - 1); + Expr::app(inner, b) + }, + } + }; + self.pool.push(e.clone()); + e + } +} + +/// Wrap ordered roots in a random ConstantInfo that has exactly that many +/// roots, with random refs/univs tables. +fn wrap(rng: &mut Rng, roots: Vec) -> Constant { + let n = roots.len(); + let mut it = roots.into_iter(); + let mut take = || it.next().unwrap(); + let lvls = *rng.pick(&[0u64, 1, 3, 200]); + let def = |take: &mut dyn FnMut() -> E, rng: &mut Rng| Definition { + kind: *rng.pick(&[DefKind::Definition, DefKind::Opaque, DefKind::Theorem]), + safety: *rng.pick(&[ + DefinitionSafety::Safe, + DefinitionSafety::Unsafe, + DefinitionSafety::Partial, + ]), + lvls, + typ: take(), + value: take(), + }; + let rec = |take: &mut dyn FnMut() -> E, rules: usize, rng: &mut Rng| { + let typ = take(); + Recursor { + k: rng.pct(50), + is_unsafe: rng.pct(50), + lvls, + params: rng.below(3), + indices: rng.below(300), + motives: 1, + minors: rng.below(3), + typ, + rules: (0..rules) + .map(|_| RecursorRule { fields: rng.below(3), rhs: take() }) + .collect(), + } + }; + let ind = |take: &mut dyn FnMut() -> E, ctors: usize, rng: &mut Rng| { + let typ = take(); + Inductive { + is_unsafe: rng.pct(50), + lvls, + params: rng.below(3), + indices: rng.below(3), + typ, + ctors: (0..ctors) + .map(|i| Constructor { + is_unsafe: false, + lvls, + cidx: i as u64, + params: 1, + fields: rng.below(200), + typ: take(), + }) + .collect(), + } + }; + let addr = |i: u64| Address::hash(&i.to_le_bytes()); + let info = match (n, rng.below(4)) { + (0, 0) => { + ConstantInfo::CPrj(ConstructorProj { idx: 1, cidx: 2, block: addr(1) }) + }, + (0, 1) => ConstantInfo::RPrj(RecursorProj { idx: 0, block: addr(2) }), + (0, 2) => ConstantInfo::IPrj(InductiveProj { idx: 300, block: addr(3) }), + (0, _) => ConstantInfo::DPrj(DefinitionProj { idx: 4, block: addr(4) }), + (1, 0) => { + ConstantInfo::Axio(Axiom { is_unsafe: rng.pct(50), lvls, typ: take() }) + }, + (1, 1) => { + ConstantInfo::Quot(Quotient { kind: QuotKind::Lift, lvls, typ: take() }) + }, + (2, 0 | 1) => ConstantInfo::Defn(def(&mut take, rng)), + (n, 2) => { + ConstantInfo::Muts(vec![MutConst::Indc(ind(&mut take, n - 1, rng))]) + }, + (n, 3) if n >= 3 => ConstantInfo::Muts(vec![ + MutConst::Defn(def(&mut take, rng)), + MutConst::Recr(rec(&mut take, n - 3, rng)), + ]), + (n, _) => ConstantInfo::Recr(rec(&mut take, n - 1, rng)), + }; + let refs = (0..rng.below(3)).map(addr).collect(); + let univs = (0..rng.below(3)).map(Univ::var).collect(); + Constant { info, sharing: vec![], refs, univs } +} + +/// A random constant whose expanded roots have between `min_n` and `max_n` +/// distinct subterms. +fn gen_constant(seed: u64, min_n: usize, max_n: usize, depth: u32) -> Constant { + let mut attempt = 0u64; + loop { + let mut g = + ExprGen::new(seed.wrapping_mul(1_000_003).wrapping_add(attempt), 45); + attempt += 1; + let nroots = 1 + g.rng.below(3) as usize; + let roots: Vec = (0..nroots).map(|_| g.expr(depth)).collect(); + let (ids, _) = oracle_ids(&roots); + if ids.len() < min_n || ids.len() > max_n { + continue; + } + let mut rng = Rng(seed ^ 0xABCD); + return wrap(&mut rng, roots); + } +} + +// =========================================================================== +// Serializer lengths +// =========================================================================== + +fn boundary_sizes() -> Vec { + let mut sizes = vec![0u64, 1, 7, 8, 9, 127, 128, 129, u64::MAX - 1, u64::MAX]; + for b in 1..8u32 { + let x = 1u64 << (8 * b); + sizes.extend([x - 1, x, x + 1]); + } + for f in [0u32, 2, 4] { + for e in [ + TagN::end1(f), + TagN::end2(f), + TagN::end3(f), + TagN::end4(f), + TagN::end5(f), + ] { + sizes.extend([e - 1, e, e + 1]); + } + } + sizes +} + +#[test] +fn tag_lengths_match_encoders() { + for s in boundary_sizes() { + assert_eq!(byte_count(s), u64::from(u64_byte_count(s)), "byte_count {s}"); + let mut b = Vec::new(); + TagN::put(4, Expr::FLAG_SHARE, s, &mut b); + assert_eq!(tag4_len(s), b.len() as u64, "tag4 {s}"); + assert_eq!(share_width(s), b.len() as u64, "share {s}"); + assert_eq!(expr_len(&Expr::Share(s)), Some(b.len() as u64)); + let mut b = Vec::new(); + TagN::put(0, 0, s, &mut b); + assert_eq!(tag0_len(s), b.len() as u64, "tag0 {s}"); + } + // Pinned header order: TagN bytes of one flag, unsigned lexicographic. + for a in boundary_sizes() { + for b in boundary_sizes() { + let (mut x, mut y) = (Vec::new(), Vec::new()); + TagN::put(4, Expr::FLAG_APP, a, &mut x); + TagN::put(4, Expr::FLAG_APP, b, &mut y); + assert_eq!(tag4_bytes_cmp(a, b), x.cmp(&y), "{a} vs {b}"); + } + } + // Share width boundaries named by the plan. + for (i, w) in [ + (7u64, 1u64), + (8, 2), + (1031, 2), + (1032, 3), + (66567, 3), + (66568, 4), + (16_843_783, 4), + (16_843_784, 5), + (4_311_811_079, 5), + (4_311_811_080, 9), + ] { + assert_eq!(share_width(i), w); + } + for (n, w) in [ + (127u64, 1u64), + (128, 2), + (16511, 2), + (16512, 3), + (82048, 4), + (16_859_264, 5), + (4_311_826_560, 9), + ] { + assert_eq!(tag0_len(n), w); + } +} + +fn telescope(kind: u8, n: usize, tail: E, rng: &mut Rng) -> E { + let mut e = tail; + for i in 0..n { + let side = if i % 3 == 0 { Expr::var(i as u64) } else { Expr::sort(1) }; + e = match kind { + 0 => Expr::app(e, side), + 1 => Expr::lam_contract(binder_contract(rng), side, e), + _ => { + Expr::all_contract(binder_contract(rng), value_contract(rng), side, e) + }, + }; + } + e +} + +#[test] +fn expr_len_matches_put_expr() { + let check = |e: &Expr| { + let mut b = Vec::new(); + put_expr(e, &mut b); + assert_eq!(expr_len(e), Some(b.len() as u64), "{e:?}"); + }; + let mut rng = Rng(7); + for kind in 0..3u8 { + for n in [1usize, 2, 7, 8, 9, 255, 256, 257] { + for tail in [ + Expr::var(0), + Expr::share(300), + telescope((kind + 1) % 3, 2, Expr::sort(0), &mut rng), + ] { + check(&telescope(kind, n, tail, &mut rng)); + } + } + } + // Share leaves at every width boundary inside telescopes and heads. + for s in boundary_sizes() { + check(&Expr::app(Expr::app(Expr::share(s), Expr::share(s)), Expr::var(0))); + check(&Expr::lam(Expr::share(s), Expr::share(s))); + check(&Expr::prj(s, s, Expr::share(s))); + check(&Expr::reference(s, vec![s, 0, s])); + } + // Pointer-shared DAGs. + let mut e = Expr::var(0); + for _ in 0..40 { + e = Expr::app(e.clone(), e); + } + let mut b = Vec::new(); + put_expr(&Expr::app(Expr::var(1), Expr::var(2)), &mut b); + assert!(expr_len(&e).is_some()); + for seed in 0..300 { + let mut g = ExprGen::new(seed, 30); + check(&g.expr(6)); + } + // Seeded, like every other random test here. + for seed in 0..300 { + let mut qc = quickcheck::Gen::from_size_and_seed(20, seed); + check(&crate::expr::tests::arbitrary_expr(&mut qc)); + } + // The 2^40-leaf doubling DAG above is measured without expansion. + let mut d = Expr::var(0); + for _ in 0..70 { + d = Expr::app(d.clone(), d); + } + assert_eq!(expr_len(&d), None, "length above u64 must be reported"); +} + +fn random_table(rng: &mut Rng, n: usize) -> Vec { + (0..n) + .map(|i| { + if i > 0 && rng.pct(50) { + Expr::app(Expr::share(rng.below(i as u64)), Expr::var(rng.below(9))) + } else { + Expr::var(rng.below(300)) + } + }) + .collect() +} + +#[test] +fn constant_len_matches_serializer() { + let mut checked = 0; + for seed in 0..400u64 { + let mut rng = Rng(seed); + let mut g = ExprGen::new(seed, 30); + let n = rng.below(5) as usize; + let roots: Vec = (0..n).map(|_| g.expr(4)).collect(); + let mut c = wrap(&mut rng, roots); + let table_len = *rng.pick(&[0usize, 1, 5, 127, 128, 255, 256]); + c.sharing = random_table(&mut rng, table_len); + c.refs = (0..*rng.pick(&[0u64, 1, 127, 128])) + .map(|i| Address::hash(&i.to_le_bytes())) + .collect(); + let b = put(&c); + assert_eq!(constant_len(&c), Some(b.len() as u64), "seed {seed}"); + let mut parts = constant_fixed_len(&c).unwrap(); + for r in constant_info_root_exprs(&c.info) { + parts += expr_len(&r).unwrap(); + } + parts += sharing_table_len(&c.sharing).unwrap(); + assert_eq!(parts, b.len() as u64); + checked += 1; + } + assert_eq!(checked, 400); +} + +// =========================================================================== +// Roots +// =========================================================================== + +#[test] +fn root_order_mirrors_constant_info_root_exprs() { + let v = |i: u64| Expr::var(i); + let def = |a, b| Definition { + kind: DefKind::Definition, + safety: DefinitionSafety::Safe, + lvls: 0, + typ: v(a), + value: v(b), + }; + let rec = |t, rs: &[u64]| Recursor { + k: false, + is_unsafe: false, + lvls: 0, + params: 0, + indices: 0, + motives: 0, + minors: 0, + typ: v(t), + rules: rs.iter().map(|&r| RecursorRule { fields: 0, rhs: v(r) }).collect(), + }; + let ctor = |t| Constructor { + is_unsafe: false, + lvls: 0, + cidx: 0, + params: 0, + fields: 0, + typ: v(t), + }; + let cases: Vec<(ConstantInfo, Vec)> = vec![ + (ConstantInfo::Defn(def(0, 1)), vec![0, 1]), + (ConstantInfo::Recr(rec(0, &[1, 2, 3])), vec![0, 1, 2, 3]), + ( + ConstantInfo::Axio(Axiom { is_unsafe: false, lvls: 0, typ: v(0) }), + vec![0], + ), + ( + ConstantInfo::Quot(Quotient { kind: QuotKind::Type, lvls: 0, typ: v(0) }), + vec![0], + ), + ( + ConstantInfo::DPrj(DefinitionProj { idx: 0, block: Address::hash(b"") }), + vec![], + ), + ( + ConstantInfo::Muts(vec![ + MutConst::Defn(def(0, 1)), + MutConst::Indc(Inductive { + is_unsafe: false, + lvls: 0, + params: 0, + indices: 0, + typ: v(2), + ctors: vec![ctor(3), ctor(4)], + }), + MutConst::Recr(rec(5, &[6])), + ]), + vec![0, 1, 2, 3, 4, 5, 6], + ), + ]; + for (info, want) in cases { + let roots = constant_info_root_exprs(&info); + let got: Vec = roots + .iter() + .map(|e| match e.as_ref() { + Expr::Var(i) => *i, + _ => unreachable!(), + }) + .collect(); + assert_eq!(got, want); + assert_eq!(constant_info_root_count(&info), want.len()); + assert_eq!(rebuild_constant_info(&info, &roots).unwrap(), info); + let fresh: Vec = (100..100 + want.len() as u64).map(v).collect(); + let rebuilt = rebuild_constant_info(&info, &fresh).unwrap(); + assert_eq!(constant_info_root_exprs(&rebuilt), fresh); + let mut short = fresh.clone(); + short.pop(); + let mut long = fresh.clone(); + long.push(v(9)); + for bad in [long, short].into_iter().filter(|b| b.len() != want.len()) { + assert!(matches!( + rebuild_constant_info(&info, &bad), + Err(SharingError::Malformed( + MalformedSharing::RootCountMismatch { .. } + )) + )); + } + } +} + +// =========================================================================== +// Structural IDs and expansion +// =========================================================================== + +#[test] +fn structural_ids_follow_height_then_key() { + let p = Expr::sort(0); + let t = Expr::sort(1); + let roots = vec![ + Expr::all(p.clone(), t.clone()), + Expr::app(Expr::var(0), p.clone()), + Expr::reference(1, vec![]), + Expr::reference(1, vec![0]), + Expr::reference(0, vec![5]), + Expr::nat(0), + Expr::rec(0, vec![]), + Expr::str(0), + ]; + let dag = SharingDag::from_expanded_roots(&roots, &limits()).unwrap(); + let terms = dag.term_exprs(); + let order: Vec = vec![ + Expr::sort(0), + Expr::sort(1), + Expr::var(0), + Expr::reference(0, vec![5]), + Expr::reference(1, vec![]), + Expr::reference(1, vec![0]), + Expr::rec(0, vec![]), + Expr::str(0), + Expr::nat(0), + Expr::app(Expr::var(0), p.clone()), + Expr::all(p, t), + ]; + assert_eq!(terms, order); + assert_eq!(dag.roots(), &[10, 9, 4, 5, 3, 8, 6, 7]); + for (i, node) in dag.nodes().iter().enumerate() { + for &c in node.children().as_slice() { + assert!((c as usize) < i); + } + if i > 0 { + let (h0, h1) = (dag.heights()[i - 1], dag.heights()[i]); + assert!( + h0 < h1 || (h0 == h1 && dag.key(i as u32 - 1) < dag.key(i as u32)) + ); + } + } +} + +#[test] +fn structural_ids_match_independent_oracle_ids() { + for seed in 0..200 { + let c = gen_constant(seed, 1, 60, 5); + let roots = constant_info_root_exprs(&c.info); + let dag = SharingDag::from_expanded_roots(&roots, &limits()).unwrap(); + let (ids, terms) = oracle_ids(&roots); + assert_eq!(dag.term_exprs(), terms, "seed {seed}"); + for (r, &id) in roots.iter().zip(dag.roots()) { + assert_eq!(ids[r.as_ref()], id); + } + } +} + +#[test] +fn expansion_rejects_bad_tables() { + let v0 = Expr::var(0); + let err = |roots: Vec, table: Vec| { + SharingDag::from_shared(&roots, &table, &limits()).unwrap_err() + }; + let m = |x: MalformedSharing| SharingError::Malformed(x); + assert_eq!( + err(vec![Expr::share(1)], vec![v0.clone()]), + m(MalformedSharing::ShareOutOfRange { + location: ShareLocation::Root(0), + index: 1, + table_len: 1 + }) + ); + assert_eq!( + err( + vec![v0.clone()], + vec![Expr::app(Expr::share(5), v0.clone()), v0.clone()] + ), + m(MalformedSharing::ShareOutOfRange { + location: ShareLocation::Entry(0), + index: 5, + table_len: 2 + }) + ); + assert_eq!( + err( + vec![v0.clone()], + vec![Expr::app(Expr::share(1), v0.clone()), Expr::var(1)] + ), + m(MalformedSharing::ForwardShare { entry: 0, index: 1 }) + ); + assert_eq!( + err(vec![v0.clone()], vec![Expr::app(Expr::share(0), v0.clone())]), + m(MalformedSharing::CyclicShare { entry: 0, index: 0 }) + ); + assert_eq!( + err( + vec![v0.clone()], + vec![ + Expr::app(Expr::share(2), v0.clone()), + Expr::var(3), + Expr::lam(Expr::share(0), v0.clone()) + ] + ), + m(MalformedSharing::CyclicShare { entry: 0, index: 2 }) + ); + assert_eq!( + optimize_sharing( + &[v0.clone(), Expr::app(v0.clone(), Expr::share(0))], + &limits() + ) + .unwrap_err(), + m(MalformedSharing::UnresolvedShare { root: 1, index: 0 }) + ); + // The same errors surface through the Constant API, including for + // unreachable entries. + let mut c = axiom(Expr::sort(0), 1); + c.sharing = vec![Expr::var(1), Expr::app(Expr::share(1), v0)]; + assert_eq!( + normalize_constant_sharing(&c, &limits()).unwrap_err(), + m(MalformedSharing::CyclicShare { entry: 1, index: 1 }) + ); + assert!(matches!( + check_exact_minimum(&c, &limits()), + Err(SharingError::Malformed(_)) + )); +} + +#[test] +fn expansion_ignores_unreachable_entries_and_incoming_order() { + // T2 -> T2 in several valid backward encodings, including a table whose + // first entry inlines a subterm that a later entry stores, and garbage + // entries that nothing references. + let p = || Expr::sort(0); + let t1 = || Expr::all(p(), p()); + let t2 = Expr::all(p(), t1()); + let base = axiom(Expr::all(t2.clone(), t2.clone()), 1); + let mut a = base.clone(); + a.sharing = vec![t2.clone(), t1(), Expr::var(77)]; + a.info = ConstantInfo::Axio(Axiom { + is_unsafe: false, + lvls: 0, + typ: Expr::all(Expr::share(0), Expr::share(0)), + }); + let mut b = base.clone(); + b.sharing = vec![ + p(), + Expr::all(Expr::share(0), Expr::share(0)), + Expr::all(Expr::share(0), Expr::share(1)), + ]; + b.info = ConstantInfo::Axio(Axiom { + is_unsafe: false, + lvls: 0, + typ: Expr::all(Expr::share(2), Expr::all(Expr::share(0), Expr::share(1))), + }); + let dag = SharingDag::from_constant(&base, &limits()).unwrap(); + for c in [&a, &b, &former_heuristic_t2()] { + roundtrip(c); + assert_eq!(SharingDag::from_constant(c, &limits()).unwrap(), dag); + assert_eq!(put(&normalize(c)), put(&normalize(&base))); + } +} + +// =========================================================================== +// Fixed-dictionary recurrence (§5) against enumeration +// =========================================================================== + +/// Minimum length and least bytes among all variants. +fn brute_best(e: &E, avail: &[(E, u64)]) -> (u64, Vec) { + variants(e, avail) + .iter() + .map(|v| bytes_of(v)) + .map(|b| (b.len() as u64, b)) + .min() + .unwrap() +} + +#[test] +fn fixed_dictionary_matches_enumeration() { + let interesting = + [0u64, 1, 5, 7, 8, 9, 200, 255, 256, 65535, 65536, 1 << 32, 1 << 40]; + let mut cases = 0u64; + let mut skipped = 0u64; + let mut with_self_share = 0u64; + for seed in 0..500u64 { + let c = gen_constant(seed, 2, 9, 4); + let roots = constant_info_root_exprs(&c.info); + let dag = SharingDag::from_expanded_roots(&roots, &limits()).unwrap(); + let terms = dag.term_exprs(); + let mut rng = Rng(seed.wrapping_mul(31)); + for _ in 0..4 { + // An arbitrary dictionary: random subset, random order, and either + // consecutive or boundary-straddling indices. + let mut chosen: Vec = + (0..dag.len() as u32).filter(|_| rng.pct(45)).collect(); + for i in (1..chosen.len()).rev() { + chosen.swap(i, rng.below(i as u64 + 1) as usize); + } + let sparse = rng.pct(50); + let mut pool: Vec = interesting.to_vec(); + let mut dict = FixedDictionary::new(); + let mut avail: Vec<(E, u64)> = Vec::new(); + for (pos, &t) in chosen.iter().enumerate() { + let idx = if sparse { + let k = rng.below(pool.len() as u64) as usize; + pool.swap_remove(k) + } else { + pos as u64 + }; + dict.insert(t, idx); + avail.push((terms[t as usize].clone(), idx)); + } + for t in 0..dag.len() as u32 { + if variant_count(&terms[t as usize], &avail) > 20_000 { + skipped += 1; + continue; + } + let (len, bytes) = brute_best(&terms[t as usize], &avail); + assert_eq!( + dictionary_cost(&dag, &dict, t), + Len::new(len), + "seed {seed} term {t}" + ); + let got = materialize_with_dictionary(&dag, &dict, &[t]).unwrap(); + assert_eq!(bytes_of(&got[0]), bytes, "seed {seed} term {t}"); + if chosen.contains(&t) { + with_self_share += 1; + } + cases += 1; + } + } + } + eprintln!( + "fixed-dictionary cases compared with enumeration: {cases} \ + ({with_self_share} with the term itself available, {skipped} skipped \ + above 20000 variants)" + ); + assert!(cases > 5000 && skipped * 20 < cases); +} + +// =========================================================================== +// §2 fixtures +// =========================================================================== + +#[test] +fn fixture_t2_witness_is_17_bytes() { + let t2 = chain(2); + let c = axiom(Expr::all(t2.clone(), t2), 1); + let unshared_bytes = roundtrip(&c); + assert_eq!(hex(&unshared_bytes), "d200009317921700170000170017000000000100"); + let h = roundtrip(&former_heuristic_t2()); + assert_eq!(hex(&h), "d200009117b1b10291170000911700b0000100"); + assert_eq!( + SharingDag::from_constant(&former_heuristic_t2(), &limits()).unwrap(), + SharingDag::from_constant(&c, &limits()).unwrap() + ); + let (exact, res) = + normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + let bytes = roundtrip(&exact); + eprintln!( + "T2->T2: former heuristic {} unshared {} exact {} {} Q={:?} stats={:?}", + h.len(), + unshared_bytes.len(), + bytes.len(), + hex(&bytes), + res.table_terms, + res.stats + ); + assert_eq!(hex(&bytes), "d200009117b0b001921700170000000100"); + let o = oracle_optimum(&c); + assert_eq!(o.bytes, bytes); + assert_eq!(o.q, res.table_terms); + assert_eq!(o.minimal_sequences, vec![res.table_terms.clone()]); + assert_eq!(put(&o.constant), o.bytes); + eprintln!("T2->T2 oracle: {} sequences", o.sequences); + assert_eq!(o.sequences, 65); +} + +#[test] +fn fixture_t16_improves_on_store_only_t16() { + let t16 = chain(16); + let c = axiom(Expr::all(t16.clone(), t16.clone()), 1); + let unshared_len = roundtrip(&c).len(); + let mut store_only = c.clone(); + store_only.sharing = vec![t16]; + store_only.info = ConstantInfo::Axio(Axiom { + is_unsafe: false, + lvls: 0, + typ: Expr::all(Expr::share(0), Expr::share(0)), + }); + let store_only_len = roundtrip(&store_only).len(); + assert_eq!((unshared_len, store_only_len), (78, 46)); + let (exact, res) = + normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + let bytes = roundtrip(&exact); + eprintln!( + "T16->T16: unshared {unshared_len} store-only {store_only_len} exact {} {} Q={:?} stats={:?}", + bytes.len(), + hex(&bytes), + res.table_terms, + res.stats + ); + assert!(bytes.len() <= 46); + // Certification is independent of the greedy seed and of limits. + let mut no_g = limits(); + no_g.greedy_upper_bound = false; + assert_eq!(put(&normalize_constant_sharing(&c, &no_g).unwrap()), bytes); + let exact_q_len = sequence_len( + &SharingDag::from_constant(&c, &limits()).unwrap(), + &res.table_terms, + ) + .unwrap(); + assert_eq!( + exact_q_len.exact().unwrap() + constant_fixed_len(&c).unwrap(), + bytes.len() as u64 + ); +} + +/// Nine independent 5-byte Ref atoms, in the order of the blake3 hashes of +/// their encodings (as Lean `nineRef`); the last one is used 100 times, the +/// others twice (the probe fixture of `docs/sharing-minimum.md` §2). +fn nine_ref_fixture() -> (Constant, E) { + let mut atoms: Vec = + (0..9).map(|i| Expr::reference(i, vec![0, 0, 0])).collect(); + atoms.sort_by_key(|e| { + let mut buf = Vec::new(); + put_expr(e, &mut buf); + *blake3::hash(&buf).as_bytes() + }); + let hot = atoms.last().unwrap().clone(); + let mut roots: Vec = + atoms.iter().flat_map(|a| [a.clone(), a.clone()]).collect(); + for _ in 0..98 { + roots.push(hot.clone()); + } + let c = Constant { + info: ConstantInfo::Recr(Recursor { + k: false, + is_unsafe: false, + lvls: 0, + params: 0, + indices: 0, + motives: 0, + minors: 0, + typ: roots[0].clone(), + rules: roots[1..] + .iter() + .map(|e| RecursorRule { fields: 0, rhs: e.clone() }) + .collect(), + }), + sharing: vec![], + refs: (0u64..9).map(|i| Address::hash(&i.to_le_bytes())).collect(), + univs: vec![Univ::zero()], + }; + (c, hot) +} + +#[test] +fn fixture_nine_refs_minimum_is_578() { + // The former heuristic wrote 676 bytes in its order and 578 reordered by + // frequency (docs/sharing-minimum.md §2). + let (c, hot) = nine_ref_fixture(); + assert_eq!(hot.as_ref(), &Expr::Ref(2, vec![0, 0, 0])); + let (exact, res) = + normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + let bytes = roundtrip(&exact); + eprintln!( + "nine refs: exact {} Q={:?} stats={:?}", + bytes.len(), + res.table_terms, + res.stats + ); + assert_eq!(bytes.len(), 578); + // Ref(i,[0,0,0]) has term ID i; the least tied sequence keeps ID order, + // which already gives the hot atom (ID 2) a one-byte index. + assert_eq!(res.table_terms, (0..9).collect::>()); + assert_eq!(exact.sharing[2].as_ref(), hot.as_ref()); +} + +#[test] +fn fixture_two_minima_pins_the_tie() { + let p = || Expr::sort(0); + let a = Expr::all(p(), p()); + let b = Expr::all(p(), Expr::sort(1)); + let root = + Expr::all(a.clone(), Expr::all(a.clone(), Expr::all(b.clone(), b.clone()))); + let c = axiom(root, 2); + // Both table orders, written out by hand. + let order = |first: &E, second: &E, sa: u64, sb: u64| { + let mut x = c.clone(); + x.sharing = vec![first.clone(), second.clone()]; + x.info = ConstantInfo::Axio(Axiom { + is_unsafe: false, + lvls: 0, + typ: Expr::all( + Expr::share(sa), + Expr::all(Expr::share(sa), Expr::all(Expr::share(sb), Expr::share(sb))), + ), + }); + roundtrip(&x) + }; + let ab = order(&a, &b, 0, 1); + let ba = order(&b, &a, 1, 0); + assert_eq!(hex(&ab), "d200009317b017b017b1b10291170000911700010002000100"); + assert_eq!(hex(&ba), "d200009317b117b117b0b00291170001911700000002000100"); + let (exact, res) = + normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + let bytes = roundtrip(&exact); + let dag = SharingDag::from_constant(&c, &limits()).unwrap(); + let terms = dag.term_exprs(); + let id = |e: &E| terms.iter().position(|t| t == e).unwrap() as u32; + eprintln!( + "two minima: exact {} {} Q={:?} (A={}, B={})", + bytes.len(), + hex(&bytes), + res.table_terms, + id(&a), + id(&b) + ); + assert_eq!(bytes, ab, "the pinned tie stores A (lower term ID) first"); + assert_eq!(res.table_terms, vec![id(&a), id(&b)]); + let o = oracle_optimum(&c); + assert_eq!(o.bytes, bytes); + assert_eq!(o.q, res.table_terms); + assert_eq!( + o.minimal_sequences, + vec![vec![id(&a), id(&b)], vec![id(&b), id(&a)]] + ); + eprintln!( + "two minima oracle: {} sequences, minimal {:?}", + o.sequences, o.minimal_sequences + ); +} + +#[test] +fn prop_chains_match_probe_and_oracle() { + // Production-probe measurements: (n, unshared, store-only-Tn). + let probe = [ + (1usize, 16usize, 15usize), + (2, 20, 17), + (3, 24, 19), + (4, 28, 21), + (7, 41, 27), + (8, 46, 30), + (9, 50, 32), + (16, 78, 46), + (32, 142, 78), + ]; + for (n, u, s) in probe { + let t = chain(n); + let c = axiom(Expr::all(t.clone(), t), 1); + assert_eq!(roundtrip(&c).len(), u, "unshared n={n}"); + let bytes = roundtrip(&normalize(&c)); + eprintln!("chain {n}: exact {} ({})", bytes.len(), hex(&bytes)); + assert!(bytes.len() <= s, "n={n}"); + if n <= 3 { + let o = oracle_optimum(&c); + assert_eq!(o.bytes, bytes, "oracle n={n}"); + } + } +} + +// =========================================================================== +// Width-state search against the exhaustive oracle +// =========================================================================== + +#[test] +fn optimizer_matches_exhaustive_oracle() { + let mut kinds: HashMap = HashMap::new(); + let mut shared = 0u64; + let mut parent_first = 0u64; + let cases = 160u64; + for seed in 0..cases { + let c = gen_constant(seed, 2, 6, 4); + let (exact, res) = + normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + let bytes = roundtrip(&exact); + let o = oracle_optimum(&c); + assert_eq!( + (o.len, &o.q, &o.bytes), + (bytes.len() as u64, &res.table_terms, &bytes), + "seed {seed}: {c:?}" + ); + // Record coverage. + let kind = match &c.info { + ConstantInfo::Muts(_) => "muts".to_string(), + other => format!("{}", other.variant().unwrap()), + }; + *kinds.entry(kind).or_default() += 1; + if !res.table_terms.is_empty() { + shared += 1; + } + let dag = SharingDag::from_constant(&c, &limits()).unwrap(); + let q = &res.table_terms; + let terms = dag.term_exprs(); + for i in 0..q.len() { + for j in i + 1..q.len() { + if contains(&terms[q[i] as usize], &terms[q[j] as usize]) { + parent_first += 1; + } + } + } + } + eprintln!( + "oracle agreement: {cases} constants, {shared} with a nonempty optimum table, \ + {parent_first} parent-before-descendant pairs, kinds {kinds:?}" + ); +} + +fn contains(hay: &E, needle: &E) -> bool { + hay == needle || hay.children().into_iter().any(|c| contains(c, needle)) +} + +#[test] +fn oracle_separability_matches_full_product() { + let t1 = chain(1); + let mut cases = vec![axiom(Expr::all(t1.clone(), t1), 1)]; + for seed in 0..40 { + cases.push(gen_constant(seed + 5000, 2, 4, 3)); + } + let mut complete = 0u64; + let mut compared = 0u64; + for c in &cases { + let Some((len, q, bytes, n)) = oracle_full_product(c, 20_000) else { + continue; + }; + let o = oracle_optimum(c); + assert_eq!((len, &q, &bytes), (o.len, &o.q, &o.bytes)); + let exact = roundtrip(&normalize(c)); + assert_eq!(exact, bytes); + complete += n; + compared += 1; + } + eprintln!( + "full-product oracle: {compared} constants, {complete} complete encodings" + ); + assert!(compared >= 20); +} + +// =========================================================================== +// Invariance, idempotence and comparison with other encodings +// =========================================================================== + +/// Rebuild with random partial pointer sharing. +fn remix(e: &E, rng: &mut Rng, memo: &mut HashMap) -> E { + if rng.pct(50) + && let Some(x) = memo.get(e.as_ref()) + { + return x.clone(); + } + let kids: Vec = + e.children().into_iter().map(|c| remix(c, rng, memo)).collect(); + let out = if kids.is_empty() { + Arc::new(e.as_ref().clone()) + } else { + Arc::new(e.with_children(&kids).unwrap()) + }; + memo.insert(e.as_ref().clone(), out.clone()); + out +} + +#[test] +fn representation_independence() { + // Results (or errors) that do not depend on the input's pointer layout. + fn outcome( + r: Result, + ) -> Result<(Vec, u64, Vec), SharingError> { + r.map(|x| { + let mut b = Vec::new(); + for e in x.roots.iter().chain(&x.sharing) { + put_expr(e, &mut b); + } + (x.table_terms, x.variable_len, b) + }) + } + let mut solved = 0; + for seed in 0..120 { + let c = gen_constant(seed + 900, 3, 30, 5); + let roots = constant_info_root_exprs(&c.info); + let reference = outcome(optimize_sharing(&roots, &limits())); + let dag = SharingDag::from_expanded_roots(&roots, &limits()).unwrap(); + let mut rng = Rng(seed); + let layouts: Vec> = + vec![roots.iter().map(deep_clone).collect(), dag.root_exprs(), { + let mut memo = HashMap::new(); + roots.iter().map(|r| remix(r, &mut rng, &mut memo)).collect() + }]; + for layout in layouts { + assert_eq!( + SharingDag::from_expanded_roots(&layout, &limits()).unwrap(), + dag + ); + assert_eq!( + outcome(optimize_sharing(&layout, &limits())), + reference, + "seed {seed}" + ); + } + if reference.is_ok() { + solved += 1; + } + } + eprintln!( + "representation independence: {solved}/120 solved, all layouts identical" + ); + assert!(solved >= 110); +} + +#[test] +fn exact_is_idempotent_and_never_worse() { + let mut stats = (0u64, 0u64, 0u64, 0u64); + let mut most_states = 0u64; + let mut l = limits(); + l.max_states = 200_000; + l.max_layer_states = 100_000; + for seed in 0..150 { + let c = gen_constant(seed + 20_000, 4, 45, 6); + let h = mss::mss_constant(&c, &limits()).unwrap(); + let u = unshared(&c); + let exact = match normalize_constant_sharing_with_stats(&c, &l) { + Ok((x, r)) => { + most_states = most_states.max(r.stats.states_created); + x + }, + Err(SharingError::ResourceExhausted(r)) => { + stats.3 += 1; + eprintln!("seed {seed}: resource limit {r:?}"); + continue; + }, + Err(e) => panic!("seed {seed}: {e}"), + }; + let eb = roundtrip(&exact); + let hb = roundtrip(&h); + let ub = roundtrip(&u); + assert!(eb.len() <= ub.len() && eb.len() <= hb.len(), "seed {seed}"); + stats.0 += 1; + stats.1 += (hb.len() - eb.len()) as u64; + stats.2 += (ub.len() - eb.len()) as u64; + // Expand-then-normalize is a fixpoint, from every incoming encoding. + for x in [&exact, &h, &u] { + assert_eq!(put(&normalize(x)), eb, "seed {seed}"); + } + assert_eq!( + check_exact_minimum(&exact, &limits()).unwrap(), + ExactMinimumCheck::Minimum + ); + if hb != eb { + assert!(matches!( + check_exact_minimum(&h, &limits()).unwrap(), + ExactMinimumCheck::NotMinimum { .. } + )); + } + } + eprintln!( + "never-worse: {} solved, saved {} bytes vs MSS and {} vs unshared, \ + {} resource errors, most states in a solved case {most_states}", + stats.0, stats.1, stats.2, stats.3 + ); + assert!(stats.0 >= 140); +} + +// =========================================================================== +// Resources, bounds and forced states +// =========================================================================== + +#[test] +fn resource_limits_fail_closed() { + let t16 = chain(16); + let c = axiom(Expr::all(t16.clone(), t16), 1); + let want = put(&normalize(&c)); + let cases: Vec<(Resource, Box)> = vec![ + (Resource::InputNodes, Box::new(|l| l.max_input_nodes = 3)), + (Resource::DistinctNodes, Box::new(|l| l.max_distinct_nodes = 5)), + (Resource::Height, Box::new(|l| l.max_height = 4)), + (Resource::Candidates, Box::new(|l| l.max_candidates = 3)), + (Resource::States, Box::new(|l| l.max_states = 5)), + (Resource::LayerStates, Box::new(|l| l.max_layer_states = 2)), + (Resource::Transitions, Box::new(|l| l.max_transitions = 4)), + (Resource::Work, Box::new(|l| l.max_work = 50)), + (Resource::OutputBytes, Box::new(|l| l.max_output_bytes = 45)), + ]; + for (resource, set) in cases { + let mut l = limits(); + l.greedy_upper_bound = false; + set(&mut l); + match normalize_constant_sharing(&c, &l) { + Err(SharingError::ResourceExhausted(r)) => { + assert_eq!(r.resource, resource) + }, + other => panic!("{resource:?}: expected exhaustion, got {other:?}"), + } + } + // Every successful invocation returns the same bytes, whatever the limits. + let mut tight = limits(); + let res = normalize_constant_sharing_with_stats(&c, &tight).unwrap().1; + tight.max_states = res.stats.states_created; + tight.max_transitions = res.stats.transitions; + tight.max_work = res.stats.work; + tight.max_output_bytes = want.len() as u64; + assert_eq!(put(&normalize_constant_sharing(&c, &tight).unwrap()), want); + let mut unbounded = ExactSharingLimits::unbounded(); + unbounded.greedy_upper_bound = false; + assert_eq!(put(&normalize_constant_sharing(&c, &unbounded).unwrap()), want); + // Counters are deterministic. + let again = normalize_constant_sharing_with_stats(&c, &limits()).unwrap().1; + assert_eq!(again.stats, res.stats); +} + +#[test] +fn overflowing_lengths_are_exact_or_errors() { + // x_{i+1} = App(x_i, x_i): the unshared length exceeds u64. + let mut x = Expr::var(0); + for _ in 0..70 { + x = Expr::app(x.clone(), x); + } + let mut l = limits(); + l.max_states = 20_000; + l.max_transitions = 2_000_000; + match optimize_sharing(std::slice::from_ref(&x), &l) { + Ok(r) => { + eprintln!( + "doubling-70 solved: {} bytes, Q len {}", + r.variable_len, + r.table_terms.len() + ); + assert_eq!(r.stats.unshared_len, None); + }, + Err(SharingError::ResourceExhausted(r)) => { + eprintln!("doubling-70: resource limit {r:?}"); + }, + Err(e) => panic!("unexpected {e}"), + } + // A small doubling DAG is solved exactly and beats the unshared form. + let mut y = Expr::var(0); + for _ in 0..6 { + y = Expr::app(y.clone(), y); + } + let r = optimize_sharing(std::slice::from_ref(&y), &limits()).unwrap(); + let u = r.stats.unshared_len.unwrap(); + eprintln!( + "doubling-6: exact {} unshared {u} Q={:?}", + r.variable_len, r.table_terms + ); + assert!(r.variable_len < u); +} + +#[test] +fn forced_states_cross_tag0_and_share_width_boundaries() { + // 300 independent atoms, each used twice, as one recursor. + let atoms: Vec = (0..300).map(|i| Expr::reference(i, vec![])).collect(); + let roots: Vec = + atoms.iter().flat_map(|a| [a.clone(), a.clone()]).collect(); + let c = Constant { + info: ConstantInfo::Recr(Recursor { + k: false, + is_unsafe: false, + lvls: 0, + params: 0, + indices: 0, + motives: 0, + minors: 0, + typ: roots[0].clone(), + rules: roots[1..] + .iter() + .map(|e| RecursorRule { fields: 0, rhs: e.clone() }) + .collect(), + }), + sharing: vec![], + refs: vec![], + univs: vec![], + }; + let dag = SharingDag::from_constant(&c, &limits()).unwrap(); + let fixed = constant_fixed_len(&c).unwrap(); + let lim = limits(); + let mut meter = Meter::new(&lim); + for k in [0usize, 7, 8, 9, 127, 128, 129, 255, 256, 257, 300] { + // Store the atoms in reverse ID order so every width class is used. + let q: Vec = (0..k as u32).rev().collect(); + let predicted = sequence_len(&dag, &q).unwrap().exact().unwrap(); + let (rw, table) = materialize_sequence( + &dag, + &dag.nodes().iter().map(Node::own_len).collect::>(), + &q, + &mut meter, + ) + .unwrap(); + let mut x = c.clone(); + x.info = rebuild_constant_info(&c.info, &rw).unwrap(); + x.sharing = table; + let b = roundtrip(&x); + assert_eq!(fixed + predicted, b.len() as u64, "k={k}"); + assert_eq!(constant_len(&x), Some(b.len() as u64)); + assert_eq!(SharingDag::from_constant(&x, &limits()).unwrap(), dag); + } +} + +#[test] +fn projections_and_empty_roots() { + let c = Constant { + info: ConstantInfo::IPrj(InductiveProj { + idx: 3, + block: Address::hash(b"b"), + }), + sharing: vec![Expr::var(0), Expr::app(Expr::share(0), Expr::share(0))], + refs: vec![Address::hash(b"r")], + univs: vec![Univ::zero()], + }; + let n = normalize(&c); + assert!(n.sharing.is_empty()); + assert_eq!(n.info, c.info); + assert_eq!(normalize(&n), n); + let r = optimize_sharing(&[], &limits()).unwrap(); + assert_eq!((r.roots.len(), r.sharing.len(), r.variable_len), (0, 0, 1)); +} + +#[test] +fn pruning_never_changes_the_result() { + // (lower-bound pruning, materialization bound, greedy seed) + const MODES: [(bool, bool, bool); 5] = [ + (false, false, false), + (true, false, false), + (true, false, true), + (true, true, false), + (true, true, true), + ]; + let mut compared = 0u64; + let mut states = [0u64; MODES.len()]; + for seed in 0..150 { + let c = gen_constant(seed + 40_000, 4, 18, 5); + let mut results: Vec<(Vec, Vec)> = Vec::new(); + let mut seen = [0u64; MODES.len()]; + let mut complete = true; + for (i, (p, m, g)) in MODES.into_iter().enumerate() { + let mut l = limits(); + l.lower_bound_pruning = p; + l.materialization_bound = m; + l.greedy_upper_bound = g; + l.max_states = 300_000; + match normalize_constant_sharing_with_stats(&c, &l) { + Ok((x, r)) => { + seen[i] = r.stats.states_expanded; + results.push((put(&x), r.table_terms)); + }, + Err(SharingError::ResourceExhausted(_)) => complete = false, + Err(e) => panic!("seed {seed}: {e}"), + } + } + assert!(!results.is_empty(), "seed {seed}: every mode exhausted"); + for r in &results[1..] { + assert_eq!(r, &results[0], "seed {seed}"); + } + if complete { + compared += 1; + for i in 0..MODES.len() { + states[i] += seen[i]; + } + } + } + eprintln!( + "pruning modes agree on {compared} constants with every mode complete; \ + states expanded per mode {states:?}" + ); + assert!(compared >= 100); +} + +#[test] +fn ordering_parent_stored_before_its_inlined_descendant() { + // Seven hot atoms and a hot parent P take the eight one-byte slots; P's + // descendant D is also stored, but only in slot 8, so P's entry must + // inline D. Storing D first would push P to a two-byte index. + let hot: Vec = (0..7).map(|i| Expr::reference(i, vec![0, 0, 0])).collect(); + let d = Expr::reference(20, vec![0, 0, 0, 0, 0]); + let p = Expr::app(Expr::var(0), d.clone()); + let mut roots: Vec = Vec::new(); + for h in &hot { + roots.extend(std::iter::repeat_n(h.clone(), 50)); + } + roots.extend(std::iter::repeat_n(p.clone(), 40)); + roots.extend(std::iter::repeat_n(d.clone(), 3)); + let c = Constant { + info: ConstantInfo::Recr(Recursor { + k: false, + is_unsafe: false, + lvls: 0, + params: 0, + indices: 0, + motives: 0, + minors: 0, + typ: roots[0].clone(), + rules: roots[1..] + .iter() + .map(|e| RecursorRule { fields: 0, rhs: e.clone() }) + .collect(), + }), + sharing: vec![], + refs: vec![], + univs: vec![Univ::zero()], + }; + let dag = SharingDag::from_constant(&c, &limits()).unwrap(); + let terms = dag.term_exprs(); + let id = |e: &E| terms.iter().position(|t| t == e).unwrap() as u32; + let (exact, res) = + normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + let bytes = roundtrip(&exact); + let hot_ids: Vec = hot.iter().map(id).collect(); + let mut want = hot_ids.clone(); + want.extend([id(&p), id(&d)]); + eprintln!( + "parent-first: exact {} bytes Q={:?} (P={}, D={})", + bytes.len(), + res.table_terms, + id(&p), + id(&d) + ); + assert_eq!(res.table_terms, want); + // P's entry inlines D, which is stored separately afterwards. + assert_eq!(exact.sharing[7].as_ref(), p.as_ref()); + assert_eq!(exact.sharing[8].as_ref(), d.as_ref()); + // Storing D before P is feasible but strictly longer. + let mut child_first = hot_ids; + child_first.extend([id(&d), id(&p)]); + let parent_first = sequence_len(&dag, &res.table_terms).unwrap(); + let child_first = sequence_len(&dag, &child_first).unwrap(); + eprintln!("parent-first {parent_first:?} vs child-first {child_first:?}"); + assert!(parent_first < child_first); +} + +#[test] +fn byte_level_normalization() { + let t2 = chain(2); + let c = axiom(Expr::all(t2.clone(), t2), 1); + let incoming = put(&former_heuristic_t2()); + assert_eq!(put(&normalize(&former_heuristic_t2())), put(&normalize(&c))); + let out = normalize_constant_bytes(&incoming, &limits()).unwrap(); + assert_eq!(hex(&out), "d200009117b0b001921700170000000100"); + assert_eq!(normalize_constant_bytes(&out, &limits()).unwrap(), out); + let mut trailing = out.clone(); + trailing.push(0); + assert!(matches!( + normalize_constant_bytes(&trailing, &limits()), + Err(NormalizeBytesError::Decode(_)) + )); + assert!(matches!( + normalize_constant_bytes(&out[..5], &limits()), + Err(NormalizeBytesError::Decode(_)) + )); + let mut cyclic = c.clone(); + cyclic.sharing = vec![Expr::app(Expr::share(0), Expr::var(0))]; + assert_eq!( + normalize_constant_bytes(&put(&cyclic), &limits()).unwrap_err().to_string(), + "malformed sharing: CyclicShare { entry: 0, index: 0 }" + ); +} + +#[test] +fn telescope_cuts_at_header_boundaries_match_enumeration() { + let mut rng = Rng(99); + let mut checked = 0u64; + for kind in 0..3u8 { + for n in [1usize, 6, 7, 8, 9, 15, 16, 17, 255, 256, 257] { + // Mixed contracts and side children; the tail is another family. + let tail = telescope((kind + 1) % 3, 2, Expr::sort(0), &mut rng); + let e = telescope(kind, n, tail, &mut rng); + let dag = + SharingDag::from_expanded_roots(std::slice::from_ref(&e), &limits()) + .unwrap(); + let terms = dag.term_exprs(); + // The spine suffixes of the root, outermost first. + let mut spine: Vec = vec![dag.roots()[0]]; + loop { + let cur = *spine.last().unwrap(); + let next = match dag.node(cur) { + Node::App(f, _) => *f, + Node::Lam(_, _, b) | Node::All(_, _, _, b) => *b, + _ => break, + }; + if dag.node(next).family() != dag.node(cur).family() { + break; + } + spine.push(next); + } + assert_eq!(spine.len(), n); + for trial in 0..6 { + let mut dict = FixedDictionary::new(); + let mut avail: Vec<(E, u64)> = Vec::new(); + let indices = [0u64, 7, 8, 255, 256, 65535, 65536]; + for (slot, _) in (0..1 + trial % 3).enumerate() { + let t = spine[rng.below(spine.len() as u64) as usize]; + if dict.index_of(t).is_some() { + continue; + } + let idx = indices[(slot + trial) % indices.len()]; + dict.insert(t, idx); + avail.push((terms[t as usize].clone(), idx)); + } + for &t in &[spine[0], spine[spine.len() / 2]] { + assert!(variant_count(&terms[t as usize], &avail) <= 64); + let (len, bytes) = brute_best(&terms[t as usize], &avail); + assert_eq!( + dictionary_cost(&dag, &dict, t), + Len::new(len), + "{kind} {n}" + ); + let got = materialize_with_dictionary(&dag, &dict, &[t]).unwrap(); + assert_eq!(bytes_of(&got[0]), bytes, "{kind} {n}"); + checked += 1; + } + } + } + } + eprintln!("telescope boundary cases compared with enumeration: {checked}"); +} + +#[test] +fn every_valid_incoming_encoding_normalizes_identically() { + let lim = limits(); + let mut encodings = 0u64; + for seed in 0..80 { + let c = gen_constant(seed + 60_000, 3, 25, 5); + let want = put(&normalize(&c)); + let dag = SharingDag::from_constant(&c, &lim).unwrap(); + let own: Vec = dag.nodes().iter().map(Node::own_len).collect(); + let mut rng = Rng(seed); + for _ in 0..8 { + // Any distinct subterms in any order, including non-candidates and + // entries nothing will reference. + let mut q: Vec = + (0..dag.len() as u32).filter(|_| rng.pct(35)).collect(); + for i in (1..q.len()).rev() { + q.swap(i, rng.below(i as u64 + 1) as usize); + } + let mut meter = Meter::new(&lim); + let (roots, table) = + materialize_sequence(&dag, &own, &q, &mut meter).unwrap(); + let mut x = c.clone(); + x.info = rebuild_constant_info(&c.info, &roots).unwrap(); + x.sharing = table; + let b = roundtrip(&x); + assert_eq!( + constant_fixed_len(&c).unwrap() + + sequence_len(&dag, &q).unwrap().exact().unwrap(), + b.len() as u64 + ); + assert_eq!(SharingDag::from_constant(&x, &lim).unwrap(), dag); + assert!(want.len() <= b.len()); + assert_eq!(put(&normalize(&x)), want, "seed {seed} q {q:?}"); + encodings += 1; + } + } + eprintln!("incoming encodings normalized identically: {encodings}"); +} + +/// Extended oracle agreement; run with +/// `cargo test --release -p ixon oracle_extended -- --ignored --nocapture`. +#[test] +#[ignore = "long-running; run explicitly in release mode"] +fn oracle_extended() { + let mut tags = [0u64; 11]; + let mut contracts = std::collections::BTreeSet::new(); + let mut cases = 0u64; + let mut seven = 0u64; + let mut skipped = 0u64; + for seed in 0..1500u64 { + let max_n = if seed % 25 == 0 { 7 } else { 6 }; + let c = gen_constant(seed + 100_000, 2, max_n, 4); + if !oracle_tractable(&c, 5_000) { + skipped += 1; + continue; + } + let dag = SharingDag::from_constant(&c, &limits()).unwrap(); + for node in dag.nodes() { + tags[node.tag() as usize] += 1; + match node { + Node::Lam(bc, ..) => { + contracts.insert((8u8, u64::from(bc.to_bits()))); + }, + Node::All(bc, vc, ..) => { + contracts.insert(( + 9, + u64::from(crate::contract::pack_all_contract(*bc, *vc)), + )); + }, + Node::Let(lc, ..) => { + contracts + .insert((10, lc.flags() * 16 + u64::from(lc.binder.to_bits()))); + }, + _ => {}, + } + } + let (exact, res) = + normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + let bytes = roundtrip(&exact); + let o = oracle_optimum(&c); + assert_eq!( + (o.len, &o.q, &o.bytes), + (bytes.len() as u64, &res.table_terms, &bytes), + "seed {seed}" + ); + cases += 1; + if dag.len() == 7 { + seven += 1; + } + if seed % 100 == 99 { + eprintln!("oracle_extended: {} seeds, {cases} compared", seed + 1); + } + } + eprintln!( + "extended oracle agreement: {cases} constants ({seven} with N = 7, \ + {skipped} skipped as intractable for the oracle), \ + node tags {tags:?}, distinct binder/let contract codes {}", + contracts.len() + ); +} + +/// Independent exhaustive table-order search: every ordered sequence of +/// distinct terms from `pool`, each evaluated exactly, without state +/// merging or pruning. Returns the least `(variable length, Q)`. +fn brute_force_tables(dag: &SharingDag, pool: &[u32]) -> (Len, Vec, u64) { + use super::dict::{DenseIndex, all_costs}; + fn go( + dag: &SharingDag, + own: &[Len], + pool: &[u32], + dict: &mut DenseIndex, + q: &mut Vec, + f: Len, + best: &mut (Len, Vec), + visited: &mut u64, + ) { + *visited += 1; + let mut work = 0; + let costs = all_costs(dag.nodes(), own, &*dict, &mut work); + let mut total = f.plus(Len::new(tag0_len(q.len() as u64))); + for &r in dag.roots() { + total = total.plus(costs[r as usize]); + } + if (total, &*q) < (best.0, &best.1) { + *best = (total, q.clone()); + } + for &t in pool { + if q.contains(&t) { + continue; + } + let nf = f.plus(costs[t as usize]); + dict.set(t, q.len() as u64); + q.push(t); + go(dag, own, pool, dict, q, nf, best, visited); + q.pop(); + dict.set(t, u64::MAX); + } + } + let own: Vec = dag.nodes().iter().map(Node::own_len).collect(); + let mut dict = DenseIndex::new(dag.len()); + let mut best = (Len::OVERFLOW, Vec::new()); + let mut visited = 0; + go( + dag, + &own, + pool, + &mut dict, + &mut Vec::new(), + Len::ZERO, + &mut best, + &mut visited, + ); + (best.0, best.1, visited) +} + +fn check_against_brute_force(c: &Constant) -> u64 { + let dag = SharingDag::from_constant(c, &limits()).unwrap(); + let pool: Vec = (0..dag.len() as u32).collect(); + let (len, q, visited) = brute_force_tables(&dag, &pool); + let (exact, res) = + normalize_constant_sharing_with_stats(c, &limits()).unwrap(); + assert_eq!((Len::new(res.variable_len), &res.table_terms), (len, &q)); + let lim = limits(); + let mut meter = Meter::new(&lim); + let own: Vec = dag.nodes().iter().map(Node::own_len).collect(); + let (roots, table) = + materialize_sequence(&dag, &own, &q, &mut meter).unwrap(); + let mut x = c.clone(); + x.info = rebuild_constant_info(&c.info, &roots).unwrap(); + x.sharing = table; + assert_eq!(put(&x), put(&exact)); + visited +} + +#[test] +fn width_classes_match_exhaustive_table_orders() { + // Nine independent atoms: every table of 9 entries puts one in slot 8. + let (c, _) = nine_ref_fixture(); + let visited = check_against_brute_force(&c); + eprintln!("nine refs: brute force visited {visited} table sequences"); + assert_eq!(visited, 986_410); +} + +/// Multi-width agreement on random instances; run with +/// `cargo test --release -p ixon width_classes_extended -- --ignored`. +#[test] +#[ignore = "long-running; run explicitly in release mode"] +fn width_classes_extended() { + let mut total = 0u64; + let mut wide = 0u64; + for seed in 0..60u64 { + let mut rng = Rng(seed + 7_000); + // Up to ten distinct terms, all of which may be stored, with skewed + // use counts so the choice of the one-byte slots matters. + let n_atoms = 8 + rng.below(2); + let atoms: Vec = (0..n_atoms) + .map(|i| Expr::reference(i, vec![0; 1 + rng.below(4) as usize])) + .collect(); + let mut roots: Vec = Vec::new(); + for a in &atoms { + for _ in 0..2 + rng.below(12) { + roots.push(a.clone()); + } + } + if n_atoms == 8 { + let pair = Expr::app(atoms[0].clone(), atoms[1].clone()); + for _ in 0..1 + rng.below(6) { + roots.push(pair.clone()); + } + } + let c = wrap(&mut rng, roots); + let dag = SharingDag::from_constant(&c, &limits()).unwrap(); + assert!(dag.len() <= 10); + total += check_against_brute_force(&c); + let (_, res) = + normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + if res.table_terms.len() > 8 { + wide += 1; + } + } + eprintln!( + "width classes: 60 instances agree with exhaustive table orders \ + ({wide} optima with more than 8 entries, {total} sequences visited)" + ); + assert!(wide >= 10); +} + +/// T16 -> T16 with every pruning rule and seed disabled: the full +/// width-state space (about 3.3M states) must give the same result. Run with +/// `cargo test --release -p ixon t16_without_pruning -- --ignored`. +#[test] +#[ignore = "long-running; run explicitly in release mode"] +fn t16_without_pruning() { + let t16 = chain(16); + let c = axiom(Expr::all(t16.clone(), t16), 1); + let mut full = ExactSharingLimits::unbounded(); + full.lower_bound_pruning = false; + full.materialization_bound = false; + full.greedy_upper_bound = false; + let (a, ra) = normalize_constant_sharing_with_stats(&c, &full).unwrap(); + let (b, rb) = normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + eprintln!( + "T16 unpruned: {} bytes, Q={:?}, states {} (pruned search: {} states)", + put(&a).len(), + ra.table_terms, + ra.stats.states_created, + rb.stats.states_created + ); + assert_eq!(put(&a), put(&b)); + assert_eq!(ra.table_terms, rb.table_terms); +} + +/// Whether the exhaustive oracle stays tractable on `c`: the number of +/// occurrence variants of every root with every subterm available. +fn oracle_tractable(c: &Constant, cap: u128) -> bool { + let roots = constant_info_root_exprs(&c.info); + let (_, terms) = oracle_ids(&roots); + let avail: Vec<(E, u64)> = + terms.iter().enumerate().map(|(i, t)| (t.clone(), i as u64)).collect(); + roots.iter().all(|r| variant_count(r, &avail) <= cap) +} + +#[test] +fn deep_inputs_are_handled_iteratively() { + // A 3000-binder telescope whose repeated domain is worth sharing. + let dom = Expr::app(Expr::var(0), Expr::var(1)); + let mut e = Expr::var(0); + for i in 0..3000 { + let ty = if i % 2 == 0 { dom.clone() } else { Expr::sort(0) }; + e = Expr::lam(ty, e); + } + let c = axiom(e, 1); + let (exact, res) = + normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + let bytes = roundtrip(&exact); + // The innermost binder has height 2 (its domain is an App). + assert_eq!(res.stats.height, 3001); + assert_eq!(exact.sharing.len(), 1); + assert_eq!(exact.sharing[0].as_ref(), dom.as_ref()); + assert_eq!(constant_len(&exact), Some(bytes.len() as u64)); + assert!(bytes.len() < put(&c).len()); +} + +#[test] +fn candidate_terms_apply_r1_and_r2() { + // T2 -> T2: Prop is one byte (R2), the root occurs once (R1). + let t2 = chain(2); + let c = axiom(Expr::all(t2.clone(), t2), 1); + let dag = SharingDag::from_constant(&c, &limits()).unwrap(); + assert_eq!(candidate_terms(&dag), vec![1, 2]); + let (_, res) = normalize_constant_sharing_with_stats(&c, &limits()).unwrap(); + assert_eq!(res.stats.candidates, 2); +} + +// =========================================================================== +// Uniform Share width (port of Tests/Ix/SharingUniform.lean) +// =========================================================================== + +use super::dict::{Hide, UniformIndex, all_costs, eval_node}; +use super::search::uniform_reference_dag; +use super::uniform::set_prec; + +fn uni(w: u64, roots: &[E]) -> UniformSharingResult { + optimize_sharing_uniform(w, roots, &limits()).unwrap() +} + +fn uni_reference(w: u64, roots: &[E], deg2: bool) -> (u64, Vec) { + let lim = limits(); + let mut meter = Meter::new(&lim); + let dag = SharingDag::from_expanded_roots(roots, &lim).unwrap(); + uniform_reference_dag(&dag, w as u8, deg2, &mut meter).unwrap() +} + +/// Exact uniform-model length of a stored set (entries in any dependency +/// order see every stored descendant). +fn uniform_set_len(dag: &SharingDag, w: u64, set: &[u32]) -> u64 { + let nodes = dag.nodes(); + let own: Vec = nodes.iter().map(Node::own_len).collect(); + let mut index = vec![None; nodes.len()]; + for &t in set { + index[t as usize] = Some(0); + } + let dict = UniformIndex { index, width: w }; + let mut work = 0; + let costs = all_costs(nodes, &own, &dict, &mut work); + let mut total = Len::new(tag0_len(set.len() as u64)); + for &t in set { + let hide = Hide { inner: &dict, hidden: t }; + total = total.plus( + eval_node( + nodes, + &own, + t, + &hide, + &|x| costs[x as usize], + false, + &mut work, + ) + .0, + ); + } + for &r in dag.roots() { + total = total.plus(costs[r as usize]); + } + total.exact().unwrap() +} + +fn in_degrees(dag: &SharingDag) -> Vec { + let mut deg = vec![0u64; dag.len()]; + for &r in dag.roots() { + deg[r as usize] += 1; + } + for node in dag.nodes() { + for &c in node.children().as_slice() { + deg[c as usize] += 1; + } + } + deg +} + +/// Exhaustive canonical uniform optimum over a candidate pool: the least +/// `(model length, set)` with sets ordered by `set_prec`. +fn uniform_brute(dag: &SharingDag, w: u64, pool: &[u32]) -> (u64, Vec) { + let mut best: Option<(u64, Vec)> = None; + for mask in 0u64..(1u64 << pool.len()) { + let set: Vec = (0..pool.len()) + .filter(|&i| mask >> i & 1 == 1) + .map(|i| pool[i]) + .collect(); + let l = uniform_set_len(dag, w, &set); + let better = match &best { + None => true, + Some((bl, bs)) => l < *bl || (l == *bl && set_prec(&set, bs)), + }; + if better { + best = Some((l, set)); + } + } + best.unwrap() +} + +#[test] +fn uniform_witness_t2() { + let t2 = chain(2); + let roots = vec![Expr::all(t2.clone(), t2)]; + let u1 = uni(1, &roots); + assert_eq!( + ( + u1.certain_stored.clone(), + u1.stored.clone(), + u1.model_len, + u1.variable_len + ), + (vec![2], vec![2], 11, 11) + ); + let u2 = uni(2, &roots); + // T2 has gain 1 at w = 2; no count bracket is within reach, so the + // threshold is 1 and T2 is certain-stored. + assert_eq!( + (u2.certain_stored.clone(), u2.stored.clone(), u2.model_len), + (vec![2], vec![2], 13) + ); + let u3 = uni(3, &roots); + assert_eq!( + (u3.uncertain.clone(), u3.stored.is_empty(), u3.model_len), + (vec![2], true, 14) + ); + assert!(u3.certain_excluded.contains(&1)); + for w in 1..=3 { + assert_eq!(uni(w, &roots).model_len, uni_reference(w, &roots, false).0); + } + assert_eq!( + optimize_sharing_uniform(0, &roots, &limits()).unwrap_err(), + SharingError::FormatBound(FormatBound::UniformWidth { w: 0 }) + ); + eprintln!( + "uniform T2: w=1 {} bytes {:?}; w=2 classes cs={:?} unc={:?}; w=3 model {}", + u1.model_len, u1.table_terms, u2.certain_stored, u2.uncertain, u3.model_len + ); +} + +#[test] +fn uniform_brackets_and_atoms() { + let atoms = |n: u64| -> Vec { + (0..n).map(|i| Expr::reference(i, vec![0])).collect() + }; + let roots_of = |n: u64| -> Vec { + atoms(n).into_iter().flat_map(|a| [a.clone(), a]).collect() + }; + let u = uni(1, &roots_of(128)); + assert_eq!(u.uncertain.len(), 128); + assert_eq!(u.stored.len(), 127); + assert!(!u.stored.contains(&0) && u.lower_bracket); + assert_eq!(u.model_len, 642); + let u = uni(1, &roots_of(129)); + assert_eq!( + (u.stored.len(), u.lower_bracket, u.certain_stored.clone(), u.model_len), + (129, false, vec![128], 648) + ); + // Atom brute force with mixed sizes and uses. + let atoms10: Vec = + (0..10u64).map(|i| Expr::reference(i, vec![0; (i % 3) as usize])).collect(); + let occs: Vec = (0..10).map(|i| 1 + i % 4).collect(); + let roots: Vec = (0..10) + .flat_map(|i| std::iter::repeat_n(atoms10[i].clone(), occs[i] as usize)) + .collect(); + for w in 1..=3u64 { + let mut best = u64::MAX; + for mask in 0u64..1024 { + let ins = |i: usize| mask >> i & 1 == 1; + let mut cost = tag0_len((0..10).filter(|&i| ins(i)).count() as u64); + for i in 0..10 { + let s = expr_len(&atoms10[i]).unwrap(); + cost += if ins(i) { s + occs[i] * w } else { occs[i] * s }; + } + best = best.min(cost); + } + assert_eq!(uni(w, &roots).model_len, best, "w={w}"); + } +} + +#[test] +fn uniform_in_degree_one_tie() { + // t (a 20-byte leaf) has the single parent p = App(Var0, t), which only + // continues two App telescopes. Storing {t} and {p} tie; the canonical + // class (in-degree >= 2) stores p. + let t = Expr::reference(1, vec![0; 18]); + let p = Expr::app(Expr::var(0), t.clone()); + let roots = + vec![Expr::app(p.clone(), Expr::var(1)), Expr::app(p, Expr::var(2))]; + let dag = SharingDag::from_expanded_roots(&roots, &limits()).unwrap(); + let id = |e: &E| dag.term_exprs().iter().position(|x| x == e).unwrap() as u32; + let (tid_, pid) = (id(&t), id(&Expr::app(Expr::var(0), t.clone()))); + let u = uni(1, &roots); + let len_t = uniform_set_len(&dag, 1, &[tid_]); + let len_p = uniform_set_len(&dag, 1, &[pid]); + eprintln!( + "in-degree-1 tie: {{t}} {len_t} bytes, {{p}} {len_p} bytes, uniform stores {:?}", + u.stored + ); + assert_eq!(len_t, len_p); + assert_eq!(u.model_len, len_p); + assert_eq!(u.stored, vec![pid]); + assert_eq!(uni_reference(1, &roots, false).0, u.model_len); + // Over all R1/R2 candidates the pinned order also leaves out the smaller + // ID (t), so here the in-degree restriction does not change the result. + let pool = candidate_terms(&dag); + assert_eq!(uniform_brute(&dag, 1, &pool), (len_t, vec![pid])); +} + +fn gen_uniform_roots(rng: &mut Rng) -> Vec { + let mut g = ExprGen::new(rng.next(), 30); + let leaf = |g: &mut ExprGen| g.leaf(); + match rng.below(6) { + 0 => { + let (f, a, b) = (leaf(&mut g), leaf(&mut g), leaf(&mut g)); + let pre = if rng.pct(50) { + Expr::app(f, a) + } else { + Expr::app(Expr::app(f, a), b) + }; + (0..2 + rng.below(4)) + .map(|i| { + let x = Expr::var(i % 3); + if rng.pct(50) { + Expr::app(pre.clone(), x) + } else { + Expr::app(Expr::app(pre.clone(), x), leaf(&mut g)) + } + }) + .collect() + }, + 1 => { + let e = Expr::app(Expr::var(rng.below(2)), Expr::var(1)); + (0..2 + rng.below(5)) + .map(|_| match rng.below(3) { + 0 => Expr::app(Expr::reference(1, vec![]), e.clone()), + 1 => Expr::lam(e.clone(), Expr::var(0)), + _ => Expr::all(e.clone(), Expr::sort(0)), + }) + .collect() + }, + 2 => { + let pool: Vec = (0..3).map(|_| leaf(&mut g)).collect(); + let c = Expr::app( + pool[rng.below(3) as usize].clone(), + pool[rng.below(3) as usize].clone(), + ); + let p = match rng.below(3) { + 0 => Expr::app(c.clone(), pool[0].clone()), + 1 => Expr::all(pool[1].clone(), c.clone()), + _ => Expr::prj(0, 1, c.clone()), + }; + let mut roots = Vec::new(); + for _ in 0..1 + rng.below(4) { + roots.push(Expr::app(Expr::var(2), p.clone())); + } + for _ in 0..1 + rng.below(4) { + roots.push(Expr::lam(c.clone(), Expr::var(0))); + } + roots + }, + 3 => { + let leaves: Vec = (0..3).map(|_| leaf(&mut g)).collect(); + let mut u = Expr::app(leaves[0].clone(), leaves[1].clone()); + let mut roots = Vec::new(); + for _ in 0..3 + rng.below(6) { + for _ in 0..1 + rng.below(2) { + roots.push(if rng.pct(50) { + Expr::app(Expr::var(7), u.clone()) + } else { + Expr::all(u.clone(), Expr::sort(0)) + }); + } + u = Expr::app(u, leaves[rng.below(3) as usize].clone()); + } + roots.push(u); + roots + }, + _ => (0..1 + rng.below(3)).map(|_| g.expr(4)).collect(), + } +} + +#[test] +fn uniform_agrees_with_reference_and_brute_force() { + let mut rng = Rng(61); + let (mut checked, mut cs, mut ce, mut un, mut max_comp, mut with_unc) = + (0, 0, 0, 0, 0, 0); + let mut brute_checked = 0; + let (mut full_checked, mut restricted_differs) = (0, 0); + let mut attempts = 0; + while checked < 400 { + attempts += 1; + assert!(attempts < 20_000); + let roots = gen_uniform_roots(&mut rng); + let w = [1u64, 2, 3, 5][rng.below(4) as usize]; + let dag = SharingDag::from_expanded_roots(&roots, &limits()).unwrap(); + let cands = candidate_terms(&dag); + if cands.len() > 11 { + continue; + } + let u = uni(w, &roots); + let (rm, rq) = uni_reference(w, &roots, false); + let (rrm, rrq) = uni_reference(w, &roots, true); + assert_eq!((u.model_len, rrm), (rm, rm), "w={w} roots={roots:?}"); + assert!( + u.certain_stored.iter().all(|t| rrq.contains(t)), + "w={w} {roots:?}" + ); + assert!( + u.certain_excluded.iter().all(|t| !rq.contains(t) && !rrq.contains(t)) + ); + assert!(u.model_len <= u.unshared_len.unwrap()); + // The full key over the restricted class, by exhaustive subsets. + let deg = in_degrees(&dag); + let pool: Vec = + cands.iter().copied().filter(|&t| deg[t as usize] >= 2).collect(); + if pool.len() <= 10 { + assert_eq!( + uniform_brute(&dag, w, &pool), + (u.model_len, u.stored.clone()), + "w={w} {roots:?}" + ); + brute_checked += 1; + if cands.len() <= 10 { + let full = uniform_brute(&dag, w, &cands); + assert_eq!(full.0, u.model_len); + if full.1 != u.stored { + restricted_differs += 1; + eprintln!( + "restricted != unrestricted canonical set: w={w} {:?} vs {:?} roots={roots:?}", + u.stored, full.1 + ); + } + full_checked += 1; + } + } + checked += 1; + cs += u.certain_stored.len(); + ce += u.certain_excluded.len(); + un += u.uncertain.len(); + max_comp = + max_comp.max(u.components.iter().map(Vec::len).max().unwrap_or(0)); + if !u.uncertain.is_empty() { + with_unc += 1; + } + } + eprintln!( + "uniform vs reference: {checked} inputs ({brute_checked} also by exhaustive subsets): \ + {cs} certain-stored, {ce} certain-excluded, {un} uncertain; {with_unc} inputs with \ + uncertain terms; largest component {max_comp}; unrestricted subsets checked \ + {full_checked}, canonical set differs from the restricted class {restricted_differs}" + ); + assert!(with_unc > 50 && brute_checked > 300); +} + +#[test] +fn uniform_t16_and_properties() { + let t16 = chain(16); + let roots = vec![Expr::all(t16.clone(), t16)]; + let u = uni(1, &roots); + let (rm, _) = uni_reference(1, &roots, false); + eprintln!( + "uniform T16 w=1: model {} = reference {rm}; classes {}/{}/{}; {} states", + u.model_len, + u.certain_stored.len(), + u.uncertain.len(), + u.certain_excluded.len(), + u.states_visited + ); + assert_eq!(u.model_len, rm); + let mut checked = 0; + for seed in 0..200u64 { + let c = gen_constant(seed + 70_000, 6, 16, 4); + let w = [1u64, 2, 4][(seed % 3) as usize]; + let (n, r) = normalize_constant_sharing_uniform(w, &c, &limits()).unwrap(); + let bytes = roundtrip(&n); + let (again, _) = + normalize_constant_sharing_uniform(w, &n, &limits()).unwrap(); + assert_eq!(put(&again), bytes, "seed {seed}"); + let fresh = Constant::get(&mut put(&c).as_slice()).unwrap(); + let (f, _) = + normalize_constant_sharing_uniform(w, &fresh, &limits()).unwrap(); + assert_eq!(put(&f), bytes); + assert!(r.model_len <= r.unshared_len.unwrap()); + checked += 1; + } + assert_eq!(checked, 200); +} + +#[test] +fn uniform_byte_level() { + let t2 = chain(2); + let c = axiom(Expr::all(t2.clone(), t2), 1); + let out = normalize_constant_bytes_uniform(1, &put(&c), &limits()).unwrap(); + // At w = 1 the uniform optimum is the 17-byte exact minimum. + assert_eq!(hex(&out), "d200009117b0b001921700170000000100"); + let out3 = normalize_constant_bytes_uniform(3, &put(&c), &limits()).unwrap(); + assert_eq!(out3, put(&c)); + assert!(matches!( + normalize_constant_bytes_uniform(0, &put(&c), &limits()), + Err(NormalizeBytesError::Sharing(SharingError::FormatBound(_))) + )); +} + +// =========================================================================== +// Tiered construction (port of Tests/Ix/SharingTiered.lean) +// =========================================================================== + +const LAYOUTS: [ShareLayout; 1] = [ShareLayout::TagN]; + +#[test] +fn tiered_layout_widths() { + let at = [ + 7u64, + 8, + 1031, + 1032, + 66567, + 66568, + 66568 + (1 << 24) - 1, + 66568 + (1 << 24), + 66568 + (1 << 24) + (1 << 32) - 1, + 66568 + (1 << 24) + (1 << 32), + ]; + let got: Vec = + at.iter().map(|&i| ShareLayout::TagN.width_at(i)).collect(); + assert_eq!(got, vec![1, 2, 2, 3, 3, 4, 4, 5, 5, 9]); + assert_eq!( + ( + TAGN_RUNG1_END, + TAGN_RUNG2_END, + TAGN_RUNG3_END, + TAGN_RUNG4_END, + TAGN_RUNG5_END + ), + (8, 1032, 66568, 66568 + (1 << 24), 66568 + (1 << 24) + (1 << 32)) + ); + // The Share pricing is the wire width of the Share code. + for i in at { + assert_eq!(tagn_width(i), TagN::byte_width(4, i) as u64); + } + assert_eq!(ShareLayout::TagN.width_at(u64::MAX), 9); + assert_eq!(ShareLayout::wire(), ShareLayout::TagN); +} + +#[test] +fn tiered_fixtures() { + let t2 = chain(2); + let w2 = axiom(Expr::all(t2.clone(), t2), 1); + let t16 = chain(16); + let w16 = axiom(Expr::all(t16.clone(), t16), 1); + let (nine, hot) = nine_ref_fixture(); + for l in LAYOUTS { + let (n, _) = normalize_constant_sharing_tiered(l, &w2, &limits()).unwrap(); + assert_eq!( + hex(&roundtrip(&n)), + "d200009117b0b001921700170000000100", + "{l:?}" + ); + let (n, _) = normalize_constant_sharing_tiered(l, &w16, &limits()).unwrap(); + assert_eq!(roundtrip(&n).len(), 46, "{l:?}"); + let (n, r) = + normalize_constant_sharing_tiered(l, &nine, &limits()).unwrap(); + let pos = n.sharing.iter().position(|e| e == &hot).unwrap(); + eprintln!( + "tiered nine refs {l:?}: {} bytes, w={}, first tier {:?}, phase-1 layout {}, final {}, kept phase-1 order {}", + roundtrip(&n).len(), + r.stats.w, + r.stats.first_tier, + r.stats.phase1_layout_bytes, + r.stats.phase3_layout_bytes, + r.stats.kept_phase1_order + ); + assert_eq!(roundtrip(&n).len(), 578); + // The candidate at w = 2 alone writes the same bytes. + let (m, _) = + normalize_constant_sharing_tiered_at_width(l, &nine, &limits(), 2) + .unwrap(); + assert_eq!(put(&m), put(&n)); + assert!(r.stats.first_tier.contains(&2) && pos < 8); + } +} + +/// A heavy parent over two lighter children next to more than eight atoms +/// used a few times each (Lean `genHeavyParent`). +fn gen_heavy_parent(rng: &mut Rng) -> Vec { + let n_atoms = 9 + rng.below(4); + let atoms: Vec = (0..n_atoms) + .map(|j| Expr::reference(j + 10, vec![0; (1 + j % 3) as usize])) + .collect(); + let c1 = Expr::reference(1, vec![0, 0, 0]); + let c2 = Expr::reference(2, vec![0, 0, 1]); + let parent = if rng.pct(50) { + Expr::app(c1.clone(), c2.clone()) + } else { + Expr::all(c1.clone(), c2.clone()) + }; + let mut roots = Vec::new(); + for a in &atoms { + for _ in 0..2 + rng.below(3) { + roots.push(a.clone()); + } + } + for _ in 0..8 + rng.below(15) { + roots.push(Expr::app(Expr::var(1), parent.clone())); + } + roots.push(c1); + roots.push(c2); + roots +} + +#[test] +fn tiered_allocation_properties() { + let mut rng = Rng(71); + let (mut checked, mut changed, mut saved, mut kept) = (0, 0, 0, 0); + for i in 0..120u64 { + let c = if i % 2 == 0 { + let roots = gen_heavy_parent(&mut rng); + wrap(&mut rng, roots) + } else { + gen_constant(i + 80_000, 6, 30, 5) + }; + for l in LAYOUTS { + let (n, r) = normalize_constant_sharing_tiered(l, &c, &limits()).unwrap(); + let s = &r.stats; + assert!(s.phase3_layout_bytes <= s.phase1_layout_bytes, "case {i} {l:?}"); + assert!(s.final_ref_cost <= s.phase1_ref_cost, "case {i} {l:?}"); + assert_eq!( + roundtrip(&n).len() as u64, + constant_fixed_len(&c).unwrap() + r.variable_len + ); + if l == ShareLayout::wire() { + assert_eq!(r.model_len, r.variable_len); + } + let (again, _) = + normalize_constant_sharing_tiered(l, &n, &limits()).unwrap(); + assert_eq!(put(&again), put(&n), "case {i} {l:?} not idempotent"); + checked += 1; + if s.final_ref_cost < s.phase1_ref_cost { + changed += 1; + } + if s.savings > 0 { + saved += 1; + } + if s.kept_phase1_order { + kept += 1; + } + } + } + eprintln!( + "tiered: {checked} runs; allocation lowered the reference cost in {changed}, \ + positive savings in {saved}, phase-1 order kept in {kept}" + ); + assert!(checked == 120 && changed > 0); +} + +/// Brute force over all subsets: dependency-closed, at most `cap` terms, +/// maximum weight, ties by the greatest indicator vector in the order +/// (weight descending, ID ascending). +fn brute_tier( + n: usize, + weight: &[u64], + deps: &[Vec], + cap: usize, +) -> Vec { + let mut items: Vec = (0..n as u32).collect(); + items.sort_by(|&a, &b| { + weight[b as usize].cmp(&weight[a as usize]).then(a.cmp(&b)) + }); + let mut best: Option<(u64, Vec)> = None; + for mask in 0u32..(1 << n) { + let ins = |t: u32| mask >> t & 1 == 1; + let members: Vec = (0..n as u32).filter(|&t| ins(t)).collect(); + if members.len() > cap + || !members.iter().all(|&t| deps[t as usize].iter().all(|&d| ins(d))) + { + continue; + } + let wsum: u64 = members.iter().map(|&t| weight[t as usize]).sum(); + let vec: Vec = items.iter().map(|&t| ins(t)).collect(); + let better = match &best { + None => true, + Some((bw, bv)) => { + wsum > *bw + || (wsum == *bw + && vec + .iter() + .zip(bv) + .find(|(a, b)| a != b) + .is_some_and(|(a, _)| *a)) + }, + }; + if better { + best = Some((wsum, vec)); + } + } + let (_, vec) = best.unwrap(); + let mut out: Vec = + items.iter().zip(&vec).filter(|(_, b)| **b).map(|(t, _)| *t).collect(); + out.sort_unstable(); + out +} + +#[test] +fn tiered_first_tier_matches_brute_force() { + let mut rng = Rng(73); + for case in 0..300 { + let n = 1 + rng.below(12) as usize; + let mut weight = Vec::new(); + let mut deps: Vec> = Vec::new(); + for t in 0..n { + weight.push(1 + rng.below(4)); + deps.push((0..t as u32).filter(|_| rng.below(4) == 0).collect()); + } + let cap = 8.min(1 + rng.below(n as u64) as usize); + let wmap: FxHashMap = + (0..n).map(|t| (t as u32, weight[t])).collect(); + let dmap: FxHashMap> = + (0..n).map(|t| (t as u32, deps[t].clone())).collect(); + let stored: Vec = (0..n as u32).collect(); + let (s, _) = first_tier(&stored, &wmap, &dmap, cap, &limits()).unwrap(); + assert_eq!( + s, + brute_tier(n, &weight, &deps, cap), + "case {case}: n={n} cap={cap} w={weight:?} deps={deps:?}" + ); + } +} + +#[test] +fn tiered_byte_level() { + let t2 = chain(2); + let c = axiom(Expr::all(t2.clone(), t2), 1); + for l in LAYOUTS { + let out = normalize_constant_bytes_tiered(l, &put(&c), &limits()).unwrap(); + assert_eq!(hex(&out), "d200009117b0b001921700170000000100"); + } +} + +// --------------------------------------------------------------------------- +// Reclassifying branch and bound vs the subset enumeration +// --------------------------------------------------------------------------- + +/// `mk a1 ... an`-style prefix chains: `u_k = u_{k-1} a_k`, each prefix also +/// used once as the head of a longer spine with other arguments, plus a few +/// repeated arguments. +fn gen_prefix_chain(rng: &mut Rng) -> Vec { + let mut g = ExprGen::new(rng.next(), 0); + let pool: Vec = (0..4).map(|_| g.leaf()).collect(); + let len = 3 + rng.below(14); + let mut u = pool[0].clone(); + let mut roots = Vec::new(); + for k in 0..len { + let a = if rng.below(3) == 0 { + rng.pick(&pool).clone() + } else { + Expr::var(k % 5) + }; + u = Expr::app(u, a); + let mut x = Expr::app(u.clone(), Expr::sort(1)); + for _ in 0..rng.below(4) { + x = Expr::app(x, rng.pick(&pool).clone()); + } + roots.push(if rng.below(2) == 0 { x } else { Expr::all(x, Expr::sort(0)) }); + } + roots.push(u); + roots +} + +/// Nested binder telescopes whose prefixes and bodies repeat. +fn gen_telescopes(rng: &mut Rng) -> Vec { + let mut g = ExprGen::new(rng.next(), 0); + let pool: Vec = (0..4).map(|_| g.leaf()).collect(); + let mut body = pool[0].clone(); + let mut roots = Vec::new(); + for _ in 0..2 + rng.below(10) { + let ty = rng.pick(&pool).clone(); + body = match rng.below(3) { + 0 => Expr::lam_contract(binder_contract(rng), ty, body), + 1 => Expr::all(ty, body), + _ => Expr::app(body, ty), + }; + if rng.below(2) == 0 { + roots.push(Expr::app(Expr::var(3), body.clone())); + } + } + roots.push(body); + roots +} + +/// Long App/binder spines, each used twice. +fn gen_spines(rng: &mut Rng) -> Vec { + let mut g = ExprGen::new(rng.next(), 0); + let mut roots = Vec::new(); + for _ in 0..1 + rng.below(3) { + let mut e = g.leaf(); + for _ in 0..5 + rng.below(40) { + let x = g.leaf(); + e = match rng.below(4) { + 0 | 1 => Expr::app(e, x), + 2 => Expr::lam_contract(binder_contract(rng), x, e), + _ => Expr::all(x, e), + }; + } + roots.push(e.clone()); + roots.push(Expr::app(e.clone(), e)); + } + roots +} + +fn gen_search_roots(rng: &mut Rng) -> Vec { + match rng.below(7) { + 0 => gen_prefix_chain(rng), + 1 => gen_telescopes(rng), + 2 | 3 => gen_spines(rng), + 4 => gen_uniform_roots(rng), + _ => { + let mut g = ExprGen::new(rng.next(), 40); + (0..1 + rng.below(5)).map(|_| g.expr(5)).collect() + }, + } +} + +fn subset_reference_limits() -> ExactSharingLimits { + ExactSharingLimits { + uniform_subset_search: true, + max_states: 1 << 16, + ..limits() + } +} + +/// The reclassifying branch and bound returns exactly what the subset +/// enumeration returns (same set, so the same tie-break, and the same +/// output), on inputs with larger uncertain components. +#[test] +fn uniform_branch_and_bound_matches_subset_enumeration() { + let mut rng = Rng(71); + let reference = subset_reference_limits(); + let (mut checked, mut skipped, mut max_comp) = (0, 0, 0); + for i in 0..4000 { + if checked >= 600 { + break; + } + let roots = gen_search_roots(&mut rng); + let w = [1u64, 2, 3, 5][rng.below(4) as usize]; + let u = optimize_sharing_uniform(w, &roots, &limits()) + .unwrap_or_else(|e| panic!("case {i} w={w}: {e:?} roots={roots:?}")); + let comp = u.components.iter().map(Vec::len).max().unwrap_or(0); + if comp < 2 { + continue; + } + match optimize_sharing_uniform(w, &roots, &reference) { + Ok(r) => { + assert_eq!( + (&u.stored, u.model_len, u.lower_bracket), + (&r.stored, r.model_len, r.lower_bracket), + "case {i} w={w} roots={roots:?}" + ); + assert_eq!( + (&u.table_terms, &u.sharing, &u.roots), + (&r.table_terms, &r.sharing, &r.roots) + ); + }, + Err(SharingError::ResourceExhausted(_)) => skipped += 1, + Err(e) => panic!("case {i} w={w}: subset enumeration error {e:?}"), + } + checked += 1; + max_comp = max_comp.max(comp); + } + eprintln!( + "uniform branch and bound vs subset enumeration: {checked} inputs with a \ + component of >= 2 uncertain terms, largest component {max_comp}, \ + {skipped} skipped where the enumeration exceeded 2^16 states" + ); + assert_eq!(checked, 600); + assert!(checked - skipped >= 400); +} + +/// Search agreement across the 128-entry table-count bracket: 120 one-byte +/// atoms used twice (uncertain, gain 1) plus an App prefix chain. +#[test] +fn uniform_branch_and_bound_across_a_bracket() { + let mut roots = Vec::new(); + for i in 0..120 { + let a = Expr::reference(i, vec![0]); + roots.push(a.clone()); + roots.push(a); + } + roots.extend(gen_prefix_chain(&mut Rng(5))); + let reference = + ExactSharingLimits { uniform_subset_search: true, ..limits() }; + for w in 1..=3 { + let u = optimize_sharing_uniform(w, &roots, &limits()).unwrap(); + let r = optimize_sharing_uniform(w, &roots, &reference).unwrap(); + assert_eq!((&u.stored, u.model_len), (&r.stored, r.model_len), "w={w}"); + } +} + +// --------------------------------------------------------------------------- +// Width selection against the single-width candidates +// --------------------------------------------------------------------------- + +/// The canonical construction is the single-width candidate (`tiered_at`) +/// with the fewest layout bytes (ties to the lower width), and reports every +/// candidate length; every candidate is a valid encoding of the same +/// constant, priced and serialized consistently. +#[test] +fn tiered_selects_the_best_width_candidate() { + let mut rng = Rng(73); + for i in 0..60u64 { + let c = if i % 2 == 0 { + let roots = gen_heavy_parent(&mut rng); + wrap(&mut rng, roots) + } else { + gen_constant(i + 90_000, 6, 30, 5) + }; + for l in LAYOUTS { + let (n, r) = normalize_constant_sharing_tiered(l, &c, &limits()).unwrap(); + let mut lengths = Vec::new(); + let mut best: Option<(u64, u64)> = None; + for w in 1..=3 { + let (m, s) = + normalize_constant_sharing_tiered_at_width(l, &c, &limits(), w) + .unwrap(); + assert_eq!(s.stats.w, w); + assert_eq!( + roundtrip(&m).len() as u64, + constant_fixed_len(&c).unwrap() + s.variable_len + ); + assert_eq!( + put(&unshared(&m)), + put(&unshared(&c)), + "case {i} {l:?} w={w}: different constant" + ); + assert_eq!(s.stats.candidate_lengths, vec![(w, s.model_len)]); + lengths.push((w, s.model_len)); + if best.is_none_or(|(_, b)| s.model_len < b) { + best = Some((w, s.model_len)); + } + // The meters: the returned candidate's include the work of its + // one-pass decisions, as the single candidate's do; the others' do + // not (they make none). + let (all, one) = ( + r.stats.candidate_meters[w as usize - 1], + s.stats.candidate_meters[0], + ); + assert_eq!((all.0, all.1, all.2), (one.0, one.1, one.2)); + assert!(all.3 <= one.3, "case {i} w={w}"); + if w == r.stats.w { + assert_eq!((put(&m), s.model_len), (put(&n), r.model_len)); + assert_eq!(all, one, "case {i} w={w}"); + } + } + // The selection rule: fewest layout bytes, ties to the lower width. + assert_eq!(best, Some((r.stats.w, r.model_len)), "case {i} {l:?}"); + assert_eq!(r.stats.candidate_lengths, lengths); + } + } +} + +// --------------------------------------------------------------------------- +// Parallelism inside one constant +// --------------------------------------------------------------------------- + +fn par(widths: usize, components: usize, materialize: usize) -> Parallelism { + Parallelism { widths, components, materialize } +} + +const PAR_BUDGETS: [(usize, usize, usize); 6] = + [(3, 1, 1), (1, 4, 1), (1, 1, 4), (3, 4, 4), (2, 16, 3), (3, 64, 64)]; + +fn par_cases() -> Vec { + let t2 = chain(2); + let t16 = chain(16); + let (nine, _) = nine_ref_fixture(); + let mut cases = vec![ + axiom(Expr::all(t2.clone(), t2), 1), + axiom(Expr::all(t16.clone(), t16), 1), + nine, + ]; + let mut rng = Rng(83); + // Enough cases for more than 20 multi-component runs. + for i in 0..180u64 { + let c = match i % 3 { + 0 => { + let roots = gen_heavy_parent(&mut rng); + wrap(&mut rng, roots) + }, + 1 => { + let roots = gen_search_roots(&mut rng); + wrap(&mut rng, roots) + }, + _ => gen_constant(i + 97_000, 6, 30, 5), + }; + cases.push(c); + } + cases +} + +/// Every parallel budget gives the sequential bytes and the same result, +/// counters included, on the section-2 fixtures and generated families, +/// with the one-pass phase 3 and with the per-prefix phase 3 +/// (`phase3_per_prefix`), whose tasks the `materialize` budget splits. +#[test] +fn parallel_tiered_matches_sequential() { + let (mut compared, mut multi_comp) = (0, 0); + for (i, c) in par_cases().iter().enumerate() { + for per_prefix in [false, true] { + let l = ShareLayout::TagN; + let lim = + ExactSharingLimits { phase3_per_prefix: per_prefix, ..limits() }; + let (n, r) = normalize_constant_sharing_tiered(l, c, &lim).unwrap(); + if !per_prefix && r.phase1.components.len() > 1 { + multi_comp += 1; + } + for (w, k, m) in PAR_BUDGETS { + let (pn, pr) = + normalize_constant_sharing_tiered_par(l, c, &lim, par(w, k, m)) + .unwrap(); + let at = format!("case {i} per prefix {per_prefix} budget {w},{k},{m}"); + assert_eq!(put(&pn), put(&n), "{at}"); + assert_eq!(pr, r, "{at}"); + compared += 1; + } + } + } + eprintln!( + "parallel vs sequential: {compared} runs identical ({multi_comp} sequential runs with more than one component)" + ); + assert!(multi_comp > 10); +} + +/// Limits still fail closed under parallelism. With sequential components +/// the error is the sequential one; with parallel components the call fails +/// exactly when the sequential call fails (the reported resource may differ, +/// see `Parallelism`). Every other case runs the per-prefix phase 3 +/// (`phase3_per_prefix`), whose work the `materialize` budget splits. +#[test] +fn parallel_tiered_limits_fail_closed() { + let (mut both_fail, mut both_ok) = (0, 0); + let tight_limits = + [(3, u64::MAX), (40, u64::MAX), (u64::MAX, 2_000), (60, 20_000)]; + for (i, c) in par_cases().iter().enumerate() { + for (max_states, max_work) in tight_limits { + let tight = ExactSharingLimits { + max_states, + max_work, + phase3_per_prefix: i % 2 == 1, + ..limits() + }; + let seq = normalize_constant_sharing_tiered(ShareLayout::TagN, c, &tight); + for (w, k, m) in PAR_BUDGETS { + let res = normalize_constant_sharing_tiered_par( + ShareLayout::TagN, + c, + &tight, + par(w, k, m), + ); + match (&seq, &res) { + (Ok((a, _)), Ok((b, _))) => { + assert_eq!(put(a), put(b), "case {i}"); + both_ok += 1; + }, + (Err(e), Err(f)) => { + if k <= 1 { + assert_eq!(e, f, "case {i} budget {w},{k},{m}"); + } + assert!( + matches!(f, SharingError::ResourceExhausted(_)), + "case {i}: {f:?}" + ); + both_fail += 1; + }, + _ => panic!( + "case {i} budget {w},{k},{m} states {max_states} work {max_work}: sequential ok {} vs parallel ok {}", + seq.is_ok(), + res.is_ok() + ), + } + } + } + } + eprintln!("parallel limits: {both_ok} both succeed, {both_fail} both fail"); + assert!(both_fail > 50 && both_ok > 50); +} + +/// The Kahn priority order of phase 2 against a direct reference: the +/// available term of largest weight, ties by the smaller ID, on random DAGs +/// (dependencies outside `rest` are ignored). +#[test] +fn kahn_order_matches_reference() { + use super::tiered::kahn_order; + let mut rng = Rng(89); + for case in 0..300 { + let m = 1 + rng.below(30) as usize; + // Distinct IDs in a random topological sequence; a term may depend on + // earlier terms of the sequence (some twice) and on IDs outside `rest`. + let mut ids: Vec = (0..m as u32).map(|i| i * 3 + (i % 2)).collect(); + for i in (1..m).rev() { + ids.swap(i, rng.below(i as u64 + 1) as usize); + } + let mut weight: FxHashMap = FxHashMap::default(); + let mut deps: FxHashMap> = FxHashMap::default(); + for (i, &t) in ids.iter().enumerate() { + weight.insert(t, rng.below(5)); + let mut ds = Vec::new(); + for &u in &ids[..i] { + if rng.below(4) == 0 { + ds.push(u); + } + } + if rng.below(3) == 0 { + ds.push(10_000 + rng.below(5) as u32); + } + // A repeated dependency does not change the order. + if !ds.is_empty() && rng.below(4) == 0 { + ds.push(ds[rng.below(ds.len() as u64) as usize]); + } + deps.insert(t, ds); + } + let mut rest = ids.clone(); + rest.sort_unstable(); + let in_rest: FxHashMap = + rest.iter().map(|&t| (t, ())).collect(); + let w = |t: TermId| weight[&t]; + let mut placed: Vec = Vec::new(); + while placed.len() < m { + let next = rest + .iter() + .copied() + .filter(|t| !placed.contains(t)) + .filter(|t| { + deps[t].iter().all(|d| !in_rest.contains_key(d) || placed.contains(d)) + }) + .min_by(|&a, &b| w(b).cmp(&w(a)).then(a.cmp(&b))) + .unwrap(); + placed.push(next); + } + assert_eq!(kahn_order(&weight, &deps, &rest), placed, "case {case}"); + } +} + +/// The MSS reference encoding reproduces the `docs/sharing-minimum.md` §2 +/// numbers (T2 17 bytes, T16 46) and encodes the same constant. +#[test] +fn mss_reference_encoding() { + let t2 = chain(2); + let w2 = axiom(Expr::all(t2.clone(), t2), 1); + let t16 = chain(16); + let w16 = axiom(Expr::all(t16.clone(), t16), 1); + assert_eq!(roundtrip(&mss::mss_constant(&w2, &limits()).unwrap()).len(), 17); + assert_eq!(roundtrip(&mss::mss_constant(&w16, &limits()).unwrap()).len(), 46); + let mut rng = Rng(91); + for i in 0..60u64 { + let c = if i % 2 == 0 { + let roots = gen_heavy_parent(&mut rng); + wrap(&mut rng, roots) + } else { + gen_constant(i + 99_000, 6, 30, 5) + }; + let n = mss::mss_constant(&c, &limits()).unwrap(); + assert_eq!(put(&unshared(&n)), put(&unshared(&c)), "case {i}"); + } +} + +// --------------------------------------------------------------------------- +// Limits: defaults and overrides +// --------------------------------------------------------------------------- + +/// The production defaults are the safety-net values. +#[test] +fn limit_defaults_are_the_safety_net() { + let d = ExactSharingLimits::default(); + assert_eq!( + ( + d.max_input_nodes, + d.max_distinct_nodes, + d.max_height, + d.max_candidates, + d.max_states, + d.max_layer_states, + d.max_transitions, + d.max_work, + d.max_output_bytes, + d.max_knapsack_cells + ), + ( + 1 << 40, + 1 << 32, + 1 << 32, + 1 << 16, + 1 << 40, + 1 << 40, + 1 << 40, + 1 << 56, + 1 << 40, + 1 << 28 + ) + ); +} + +/// `with_overrides`: values, `unbounded`, Lean-only keys and errors. +#[test] +fn limit_overrides_parse() { + let d = ExactSharingLimits::default(); + let l = d + .clone() + .with_overrides(" states = 2^10 ,work=12345, output_bytes=max,,") + .unwrap(); + assert_eq!( + (l.max_states, l.max_work, l.max_output_bytes), + (1024, 12345, u64::MAX) + ); + assert_eq!(l.max_height, d.max_height); + // Lean-only keys are accepted and ignored. + assert_eq!( + d.clone() + .with_overrides("depth=5,cost_evals=2^3,materialize_work=9") + .unwrap(), + d + ); + // `unbounded`, then a later item still applies. + let u = d.clone().with_overrides("unbounded,states=2").unwrap(); + assert_eq!( + (u.max_work, u.max_height, u.max_candidates, u.max_states), + (u64::MAX, u64::MAX, u64::MAX, 2) + ); + assert_eq!(u.lower_bound_pruning, d.lower_bound_pruning); + for bad in + ["bogus=1", "states", "states=2^64", "states=-1", "states=1e3", "=3"] + { + assert!(d.clone().with_overrides(bad).is_err(), "accepted {bad}"); + } + assert!(d.clone().with_overrides("states=18446744073709551616").is_err()); + assert_eq!( + d.clone().with_overrides("states=18446744073709551615").unwrap().max_states, + u64::MAX + ); +} + +/// Override specs and the `states` limit each sets (`None`: rejected). This is +/// the grammar of Lean `Ix.Sharing.Exact.Limits.withOverrides`; the Lean +/// test `limitSpecParity` (`Tests/Ix/SharingExact.lean`) pins the same list. +/// Values are ASCII digits, `2^k` or `max` (no sign, no `_` separator, no +/// other spelling); items and keys are trimmed of space, tab, line feed and +/// carriage return only. +const LIMIT_SPEC_PARITY: &[(&str, Option)] = &[ + ("states=5", Some(5)), + ("states=007", Some(7)), + (" states = 2^10 ", Some(1 << 10)), + ("states=2^0", Some(1)), + ("states=2^63", Some(1 << 63)), + ("states=max", Some(u64::MAX)), + ("states=18446744073709551615", Some(u64::MAX)), + ("unbounded", Some(u64::MAX)), + ("", Some(1 << 40)), + (",,states=5,,", Some(5)), + ("\tstates=5\n", Some(5)), + ("states=5\r", Some(5)), + ("states= 5", Some(5)), + ("states =5", Some(5)), + ("states=1_000", None), + ("states=2^1_0", None), + ("states=+5", None), + ("states=2^+5", None), + ("states=-1", None), + ("states=1e3", None), + ("states=0x10", None), + ("states=2^64", None), + ("states=18446744073709551616", None), + ("states=", None), + ("states=2^", None), + ("=5", None), + ("states", None), + ("a=b=c", None), + ("bogus=1", None), + ("STATES=5", None), + ("states=MAX", None), + ("states=\u{a0}5", None), + ("states=\u{ff15}", None), + ("states=\u{c}5", None), + ("states=\u{b}5", None), +]; + +#[test] +fn limit_overrides_shared_spec_list() { + let d = ExactSharingLimits::default(); + for &(spec, states) in LIMIT_SPEC_PARITY { + match (d.clone().with_overrides(spec), states) { + (Ok(l), Some(s)) => assert_eq!(l.max_states, s, "{spec:?}"), + (Err(_), None) => {}, + (got, want) => panic!("{spec:?}: got {got:?}, want states {want:?}"), + } + } +} + +/// The error of an exhausted limit names the override key. +#[test] +fn exhausted_limit_names_its_key() { + let c = axiom(Expr::all(chain(2), chain(2)), 1); + let tiny = ExactSharingLimits { max_distinct_nodes: 2, ..limits() }; + let err = normalize_constant_sharing_tiered(ShareLayout::TagN, &c, &tiny) + .expect_err("two distinct nodes cannot hold this input"); + assert_eq!(err.to_string(), "resource exhausted: distinct_nodes (limit 2)"); + for r in [ + Resource::InputNodes, + Resource::DistinctNodes, + Resource::Height, + Resource::Candidates, + Resource::States, + Resource::LayerStates, + Resource::Transitions, + Resource::Work, + Resource::OutputBytes, + Resource::KnapsackCells, + ] { + let mut l = ExactSharingLimits::default(); + assert!(l.set_limit(r.key(), 3), "{r:?}"); + } +} + +/// The telescope-spine guard of the uniform optimizer (Lean's +/// `teleSubaddEnd` check): the bound, the predicate at the bound, and the +/// Share-flag width's subadditivity just below it at the rung ends. +#[test] +fn telescope_spine_guard() { + use super::uniform::{TELE_SUBADD_END, spines_within_bound}; + assert_eq!(TELE_SUBADD_END, 4_311_811_080); + assert_eq!(TELE_SUBADD_END, TagN::end5(4)); + assert!(spines_within_bound(&[])); + assert!(spines_within_bound(&[0, 1, TELE_SUBADD_END - 1])); + assert!(!spines_within_bound(&[0, TELE_SUBADD_END])); + assert!(!spines_within_bound(&[u64::MAX])); + let ends = [ + TAGN_RUNG1_END, + TAGN_RUNG2_END, + TAGN_RUNG3_END, + TAGN_RUNG4_END, + TAGN_RUNG5_END, + ]; + let mut xs: Vec = vec![0, 1, 2]; + for e in ends { + xs.extend([e - 2, e - 1, e, e + 1]); + } + for &a in &xs { + for &b in &xs { + if a.checked_add(b).is_some_and(|s| s < TELE_SUBADD_END) { + assert!(tag4_len(a + b) <= tag4_len(a) + tag4_len(b), "{a} {b}"); + } + } + } +} + +/// The table-count knapsack has its own limit (`max_knapsack_cells`, +/// resource `KnapsackCells`), separate from `max_states`: the bracket input +/// of `uniform_branch_and_bound_across_a_bracket` runs the knapsack, fails +/// closed under a one-cell limit, and certifies at the defaults even with a +/// `max_states` below the knapsack's cell count. +#[test] +fn knapsack_cells_limit() { + let mut roots = Vec::new(); + for i in 0..120 { + let a = Expr::reference(i, vec![0]); + roots.push(a.clone()); + roots.push(a); + } + roots.extend(gen_prefix_chain(&mut Rng(5))); + let mut knapsack_failures = 0; + for w in 1..=3 { + let ok = optimize_sharing_uniform(w, &roots, &limits()).unwrap(); + let tight = ExactSharingLimits { max_knapsack_cells: 1, ..limits() }; + match optimize_sharing_uniform(w, &roots, &tight) { + Ok(r) => { + assert_eq!((&r.stored, r.model_len), (&ok.stored, ok.model_len)); + }, + Err(SharingError::ResourceExhausted(e)) => { + assert_eq!((e.resource, e.limit), (Resource::KnapsackCells, 1)); + knapsack_failures += 1; + }, + Err(e) => panic!("w={w}: {e:?}"), + } + let few_states = + ExactSharingLimits { max_states: ok.states_visited.max(1), ..limits() }; + let r = optimize_sharing_uniform(w, &roots, &few_states).unwrap(); + assert_eq!((r.stored, r.model_len), (ok.stored, ok.model_len), "w={w}"); + } + assert!(knapsack_failures > 0); +} + +/// `max_candidates` bounds only the width-state search. The canonical +/// construction and its uniform phase record their candidate count without +/// limiting it, as Lean does (its limits have no candidate count): 70,000 +/// distinct references, each used twice, are 70,000 candidates, above the +/// default of 2^16, and the compiler's construction shares them all. +#[test] +fn candidate_count_is_not_a_canonical_limit() { + let roots: Vec = (0..70_000u64) + .flat_map(|i| { + let r = Expr::reference(i, vec![0; 6]); + [r.clone(), r] + }) + .collect(); + assert!(70_000 > limits().max_candidates); + let r = canonical_sharing_tiered(ShareLayout::TagN, &roots, &limits()) + .expect("the candidate count does not limit the canonical construction"); + assert_eq!((r.sharing.len(), r.stats.w), (70_000, 1)); + assert_eq!(r.phase1.stats.candidates, 70_000); + let u = optimize_sharing_uniform(2, &roots, &limits()).unwrap(); + assert_eq!((u.stored.len(), u.stats.candidates), (70_000, 70_000)); + // The width-state search still enforces it. + match optimize_sharing(&roots, &limits()) { + Err(SharingError::ResourceExhausted(e)) => { + assert_eq!((e.resource, e.limit), (Resource::Candidates, 1 << 16)); + }, + other => panic!("width-state search: {other:?}"), + } +} + +/// The incremental evaluation of a growing dictionary equals a full +/// evaluation (`all_costs`) after every addition, costs and work count, for +/// additions in any order; the sparse materializer writes the same +/// expressions with the same work as `materialize`. +#[test] +fn incremental_costs_and_sparse_materialize_match_full_evaluation() { + use super::dict::{ + Evaluation, IncrementalCosts, LazyCosts, Materializer, ReadEdges, + all_costs, materialize, + }; + let mut rng = Rng(97); + let mut cases: Vec> = + par_cases().iter().map(|c| constant_info_root_exprs(&c.info)).collect(); + for _ in 0..60 { + cases.push(gen_search_roots(&mut rng)); + cases.push(gen_spines(&mut rng)); + } + let (mut steps, mut materialized, mut lazy_steps, mut late_steps) = + (0u64, 0u64, 0u64, 0u64); + for (i, roots) in cases.iter().enumerate() { + if roots.is_empty() { + continue; + } + let dag = SharingDag::from_expanded_roots(roots, &limits()).unwrap(); + let nodes = dag.nodes(); + let n = nodes.len(); + let own: Vec = nodes.iter().map(Node::own_len).collect(); + // A random sequence of distinct terms, in any order, with indices that + // cross the TagN width boundaries. + let mut terms: Vec = (0..n as TermId).collect(); + for k in (1..terms.len()).rev() { + terms.swap(k, rng.below(k as u64 + 1) as usize); + } + terms.truncate(1 + rng.below(n as u64) as usize); + let mut dict = FixedDictionary::new(); + let edges = ReadEdges::new(nodes); + let mut eval = IncrementalCosts::new( + nodes, + &own, + &edges, + Evaluation::new(nodes, &own, &dict), + ); + let base = Evaluation::new(nodes, &own, &dict); + let lazy_applies = LazyCosts::applies(&base); + let mut lazy = LazyCosts::new(nodes, &own, &edges, base, &dict); + // A second lazy evaluation started halfway, from the evaluation of the + // non-empty dictionary at that point (as the parallel per-prefix phase 3 + // starts every range but the first). + let mut late: Option> = None; + let all: Vec = (0..n as TermId).collect(); + let mut mat = Materializer::new(n); + let mut index = rng.below(20); + for (step, &t) in terms.iter().enumerate() { + let gap = if rng.pct(10) { 200 } else { 3 }; + index += 1 + rng.below(gap); + dict.insert(t, index); + eval.add(t, &dict); + let mut w = 0u64; + let full = all_costs(nodes, &own, &dict, &mut w); + assert_eq!(eval.costs(), &full[..], "case {i} step {step}"); + assert_eq!(eval.work(), w, "case {i} step {step}"); + if lazy_applies { + lazy.add(t, &dict); + assert_eq!(lazy.work(), w, "lazy case {i} step {step}"); + // Some steps prepare one target, others every term. + let targets: &[TermId] = + if step % 4 == 3 { &all } else { std::slice::from_ref(&t) }; + lazy.prepare(targets, &dict); + for &x in targets { + assert_eq!( + lazy.costs()[x as usize], + full[x as usize], + "lazy case {i} step {step}" + ); + } + assert_eq!(lazy.work(), w, "lazy case {i} step {step}"); + if let Some(late) = late.as_mut() { + late.add(t, &dict); + late.prepare(targets, &dict); + for &x in targets { + assert_eq!(late.costs()[x as usize], full[x as usize]); + } + assert_eq!(late.work(), w, "late lazy case {i} step {step}"); + late_steps += 1; + } else if step >= terms.len() / 2 { + let start = Evaluation::new(nodes, &own, &dict); + late = Some(LazyCosts::new(nodes, &own, &edges, start, &dict)); + } + lazy_steps += 1; + } + steps += 1; + if step % 3 == 0 || step + 1 == terms.len() { + let mut targets = + vec![t, terms[rng.below(terms.len() as u64) as usize]]; + targets.push(rng.below(n as u64) as TermId); + targets.extend_from_slice(dag.roots()); + let (mut wa, mut wb) = (w, w); + let a = + materialize(nodes, &own, &dict, &full, &targets, &mut wa).unwrap(); + let b = mat.run(nodes, &own, &dict, &full, &targets, &mut wb).unwrap(); + assert_eq!(wa, wb, "case {i} step {step}"); + let bytes = |es: &[E]| { + let mut out = Vec::new(); + for e in es { + put_expr(e, &mut out); + } + out + }; + assert_eq!(bytes(&a), bytes(&b), "case {i} step {step}"); + materialized += 1; + } + } + } + eprintln!( + "incremental evaluation: {steps} steps, {materialized} materializations" + ); + assert!(steps > 1000 && materialized > 300 && lazy_steps > 1000); + assert!(late_steps > 300, "{late_steps}"); +} + +/// Replace one random leaf of `e` (a Share index or a variable) by a +/// different one, returning whether something changed. +fn mutate_leaf(e: &E, rng: &mut Rng, budget: &mut u64) -> E { + match e.as_ref() { + Expr::Share(k) if *budget == 0 => { + *budget = u64::MAX; + Arc::new(Expr::Share(k ^ (1 + rng.below(3)))) + }, + Expr::Var(n) if *budget == 0 => { + *budget = u64::MAX; + Arc::new(Expr::Var(n + 1)) + }, + Expr::Share(_) | Expr::Var(_) => { + *budget = budget.saturating_sub(1); + e.clone() + }, + _ => { + let kids: Vec = + e.children().into_iter().map(|c| mutate_leaf(c, rng, budget)).collect(); + Arc::new(e.with_children(&kids).unwrap()) + }, + } +} + +/// The re-expansion check without interning (`check_encoding`) accepts +/// exactly the encodings that `build_full` expands back to the DAG with the +/// table terms, and counts the input nodes `build_full` charges. +#[test] +fn encoding_check_matches_reexpansion() { + let mut rng = Rng(101); + let (mut valid, mut rejected) = (0, 0); + let unbounded = ExactSharingLimits::unbounded(); + let reference = |dag: &SharingDag, order: &[TermId], es: &[E], rs: &[E]| { + let mut m = Meter::new(&unbounded); + match SharingDag::build_full(rs, Some(es), &mut m) { + Ok((d, ids)) => (d == *dag + && ids + .iter() + .map(|x| x.unwrap_or(TermId::MAX)) + .eq(order.iter().copied())) + .then_some(m.stats.input_nodes), + Err(_) => None, + } + }; + for c in par_cases() { + let roots = constant_info_root_exprs(&c.info); + if roots.is_empty() { + continue; + } + let (_, t) = + normalize_constant_sharing_tiered(ShareLayout::TagN, &c, &limits()) + .unwrap(); + let u = + optimize_sharing_uniform(1 + rng.below(3), &roots, &limits()).unwrap(); + let dag = SharingDag::from_expanded_roots(&roots, &limits()).unwrap(); + for (order, es, rs) in [ + (&t.table_terms, &t.sharing, &t.roots), + (&u.table_terms, &u.sharing, &u.roots), + ] { + let fast = dag.check_encoding(order, es, rs); + assert!(fast.is_some()); + let len = + cost::exprs_len_with(es.len() as u64, es.iter().chain(rs), &tag4_len); + assert_eq!( + dag.check_and_measure(order, es, rs, &tag4_len), + fast.zip(len) + ); + assert_eq!(fast, reference(&dag, order, es, rs)); + valid += 1; + for _ in 0..4 { + let (mut es2, mut rs2) = (es.clone(), rs.clone()); + let pick = rng.below((es2.len() + rs2.len()) as u64) as usize; + let mut budget = rng.below(6); + let target = if pick < es2.len() { + &mut es2[pick] + } else { + &mut rs2[pick - es.len()] + }; + *target = mutate_leaf(target, &mut rng, &mut budget); + if rng.below(4) == 0 && es2.len() > 1 { + let i = rng.below(es2.len() as u64 - 1) as usize; + es2.swap(i, i + 1); + } + let fast = dag.check_encoding(order, &es2, &rs2); + let slow = reference(&dag, order, &es2, &rs2); + let fused = dag.check_and_measure(order, &es2, &rs2, &tag4_len); + let len = cost::exprs_len_with( + es2.len() as u64, + es2.iter().chain(&rs2), + &tag4_len, + ); + assert_eq!(fused, fast.zip(len)); + if fast.is_some() { + assert_eq!(fast, slow); + } else { + rejected += 1; + assert_eq!(slow, None); + } + } + } + } + eprintln!( + "encoding check: {valid} valid encodings, {rejected} mutations rejected" + ); + assert!(valid > 300 && rejected > 300); +} + +/// Phase 3 in one pass (orders closed under stored descendants) gives the +/// bytes, tables and lengths of the per-prefix phase 3, which the test +/// forces with `phase3_per_prefix`, sequentially and under parallel budgets +/// (the parallel per-prefix path starts a range from the evaluation of a +/// non-empty prefix), on the parallel cases and generated families. +#[test] +fn one_pass_phase3_matches_per_prefix() { + let mut rng = Rng(103); + let mut cases = par_cases(); + for _ in 0..80 { + let roots = gen_search_roots(&mut rng); + cases.push(wrap(&mut rng, roots)); + } + let per_prefix = ExactSharingLimits { phase3_per_prefix: true, ..limits() }; + let mut compared = 0; + for (i, c) in cases.iter().enumerate() { + let one = + normalize_constant_sharing_tiered(ShareLayout::TagN, c, &limits()); + let per = + normalize_constant_sharing_tiered(ShareLayout::TagN, c, &per_prefix); + match (one, per) { + (Ok((a, ra)), Ok((b, rb))) => { + assert_eq!(put(&a), put(&b), "case {i}"); + assert_eq!(ra.table_terms, rb.table_terms, "case {i}"); + assert_eq!(ra.stats.candidate_lengths, rb.stats.candidate_lengths); + assert_eq!(ra.stats.w, rb.stats.w, "case {i}"); + assert_eq!(rb.stats.per_prefix_candidates, 3, "case {i}"); + // Every budget splits the per-prefix tasks into ranges. + if i % 4 == 0 { + for (w, k, m) in PAR_BUDGETS { + let (pc, pr) = normalize_constant_sharing_tiered_par( + ShareLayout::TagN, + c, + &per_prefix, + par(w, k, m), + ) + .unwrap(); + assert_eq!(put(&pc), put(&b), "case {i} budget {w},{k},{m}"); + assert_eq!(pr, rb, "case {i} budget {w},{k},{m}"); + } + } + compared += 1; + }, + (a, b) => panic!( + "case {i}: one-pass ok {} per-prefix ok {}", + a.is_ok(), + b.is_ok() + ), + } + } + assert!(compared > 200); +} + +/// The checked mode (`full_check`) gives the default mode's bytes and +/// result, and the default mode's outcome under tight limits (the same +/// error, or the same success), on the parallel cases and generated +/// families, sequentially and under parallel budgets. +#[test] +fn full_check_matches_the_default_mode() { + let default = ExactSharingLimits::default(); + let checked = limits(); + assert!(!default.full_check && checked.full_check); + let mut rng = Rng(109); + let mut cases = par_cases(); + for _ in 0..60 { + let roots = gen_search_roots(&mut rng); + cases.push(wrap(&mut rng, roots)); + } + let tight_limits = + [(3, u64::MAX), (40, u64::MAX), (u64::MAX, 2_000), (60, 20_000)]; + let (mut same, mut both_fail) = (0, 0); + for (i, c) in cases.iter().enumerate() { + let a = normalize_constant_sharing_tiered(ShareLayout::TagN, c, &default); + let b = normalize_constant_sharing_tiered(ShareLayout::TagN, c, &checked); + let ((na, ra), (nb, rb)) = (a.unwrap(), b.unwrap()); + assert_eq!(put(&na), put(&nb), "case {i}"); + assert_eq!(ra, rb, "case {i}"); + same += 1; + let budget = PAR_BUDGETS[i % PAR_BUDGETS.len()]; + let pb = par(budget.0, budget.1, budget.2); + let (np, rp) = + normalize_constant_sharing_tiered_par(ShareLayout::TagN, c, &checked, pb) + .unwrap(); + assert_eq!((put(&np), &rp), (put(&na), &ra), "case {i} budget {budget:?}"); + for (max_states, max_work) in tight_limits { + let tight = |full_check| ExactSharingLimits { + max_states, + max_work, + full_check, + ..ExactSharingLimits::default() + }; + let a = + normalize_constant_sharing_tiered(ShareLayout::TagN, c, &tight(false)); + let b = + normalize_constant_sharing_tiered(ShareLayout::TagN, c, &tight(true)); + match (a, b) { + (Ok((na, ra)), Ok((nb, rb))) => { + assert_eq!((put(&na), ra), (put(&nb), rb), "case {i}"); + }, + (Err(e), Err(f)) => { + assert_eq!(e, f, "case {i}"); + both_fail += 1; + }, + (a, b) => panic!( + "case {i} states {max_states} work {max_work}: default ok {} vs \ + checked ok {}", + a.is_ok(), + b.is_ok() + ), + } + } + } + assert!(same > 200 && both_fail > 100, "{same} {both_fail}"); +} + +/// The checked mode fails on a discrepancy: a phase-1 dry run that differs +/// from the built expressions, and a one-pass phase-3 length that differs +/// from the per-prefix evaluation, are internal errors. +#[test] +fn full_check_detects_discrepancies() { + use super::tiered::{check_phase1, per_prefix_reference, per_prefix_tasks}; + use super::uniform::{DagPrep, optimize_uniform_with}; + let (nine, _) = nine_ref_fixture(); + let roots = constant_info_root_exprs(&nine.info); + let dag = SharingDag::from_expanded_roots(&roots, &limits()).unwrap(); + let prep = DagPrep::new(&dag); + let internal = |r: Result<(), SharingError>| matches!(r, Err(SharingError::Internal(m)) if m.starts_with("full check")); + let layout = ShareLayout::TagN; + for w in 1..=3 { + let (mut u, plan) = + optimize_uniform_with(w, &dag, &prep, &mut Meter::new(&limits())) + .unwrap(); + let (shares, real) = plan.shares(&dag, &u.table_terms, &limits()).unwrap(); + u.variable_len = real; + assert!(check_phase1(layout, &dag, &u, &plan, &shares).is_ok()); + let mut bad = shares.clone(); + bad.refs[0] += 1; + assert!(internal(check_phase1(layout, &dag, &u, &plan, &bad))); + let mut bad = shares.clone(); + bad.deps[0].push(u.table_terms[0]); + assert!(internal(check_phase1(layout, &dag, &u, &plan, &bad))); + let mut bad = shares.clone(); + bad.nodes += 1; + assert!(internal(check_phase1(layout, &dag, &u, &plan, &bad))); + let mut off = u.clone(); + off.variable_len += 1; + assert!(internal(check_phase1(layout, &dag, &off, &plan, &shares))); + // Phase 3: the per-prefix lengths of the phase-1 order, then one of + // them changed. + let order = &u.table_terms; + let lengths: Vec = per_prefix_tasks(layout, &dag, &prep, order, 1) + .into_iter() + .map(|t| t.unwrap().1) + .collect(); + let reference = + per_prefix_reference(layout, &dag, &prep, order, 2, &lengths); + assert!(reference.is_ok()); + let mut wrong = lengths.clone(); + wrong[0] = wrong[0].plus_u64(1); + let reference = per_prefix_reference(layout, &dag, &prep, order, 3, &wrong); + assert!(internal(reference.map(|_| ()))); + } +} + +/// The phase-1 dry run reports what the materialized phase-1 expressions +/// contain: the Shares of each entry in all expression trees, the entries +/// each entry shares in pre-order of first occurrence, the number of +/// expression nodes (the re-expansion check's input nodes) and the real +/// length; everything else in the result is the same. +#[test] +fn phase1_dry_run_matches_materialized_expressions() { + use super::tiered::share_indices; + use super::uniform::{DagPrep, optimize_uniform, optimize_uniform_with}; + let mut rng = Rng(107); + let mut cases: Vec> = + par_cases().iter().map(|c| constant_info_root_exprs(&c.info)).collect(); + for _ in 0..80 { + cases.push(gen_search_roots(&mut rng)); + cases.push(gen_spines(&mut rng)); + } + let mut compared = 0; + for (i, roots) in cases.iter().enumerate() { + if roots.is_empty() { + continue; + } + let dag = SharingDag::from_expanded_roots(roots, &limits()).unwrap(); + let prep = DagPrep::new(&dag); + for w in 1..=3 { + let full = optimize_uniform(w, &dag, &mut Meter::new(&limits())).unwrap(); + let (mut dry, plan) = + optimize_uniform_with(w, &dag, &prep, &mut Meter::new(&limits())) + .unwrap(); + let (shares, real) = + plan.shares(&dag, &dry.table_terms, &limits()).unwrap(); + dry.variable_len = real; + let order = &full.table_terms; + let mut refs = vec![0u64; order.len()]; + let mut deps: Vec> = Vec::new(); + let mut idx = Vec::new(); + for e in full.sharing.iter().chain(&full.roots) { + idx.clear(); + share_indices(e, &mut idx); + for &j in &idx { + refs[j as usize] += 1; + } + } + for e in &full.sharing { + idx.clear(); + share_indices(e, &mut idx); + let mut ds: Vec = Vec::new(); + for &j in &idx { + let d = order[j as usize]; + if !ds.contains(&d) { + ds.push(d); + } + } + deps.push(ds); + } + let visited = dag.check_encoding(order, &full.sharing, &full.roots); + assert_eq!(shares.refs, refs, "case {i} w {w}"); + assert_eq!(shares.deps, deps, "case {i} w {w}"); + assert_eq!(Some(shares.nodes), visited, "case {i} w {w}"); + assert_eq!(dry.variable_len, full.variable_len, "case {i} w {w}"); + assert_eq!( + (&dry.table_terms, dry.model_len, &dry.stored, &dry.stats), + (&full.table_terms, full.model_len, &full.stored, &full.stats), + "case {i} w {w}" + ); + assert!(dry.sharing.is_empty() && dry.roots.is_empty()); + compared += 1; + } + } + assert!(compared > 900); +} + +/// The per-prefix witness: an App spine `t` of `2 + extra` nodes over +/// `u = App(Var 0, Var 1)` (100 roots), `u` itself (20 roots) and eight +/// atoms used 500 times each. +fn per_prefix_witness(extra: u64) -> Vec { + let u = Expr::app(Expr::var(0), Expr::var(1)); + let mut t = u.clone(); + for i in 0..extra { + t = Expr::app(t, Expr::var(2 + i)); + } + let mut roots = vec![t; 100]; + roots.extend(vec![u; 20]); + for h in 0..8 { + roots.extend(vec![Expr::reference(100 + h, vec![0, 0]); 500]); + } + roots +} + +/// The per-prefix phase 3 is reachable. In the witness of 1,288 spine nodes +/// phase 1 at w = 2 stores `u`, but `t`'s phase-1 body is the whole +/// telescope: the cut at `u` (j = 1287, header `7c ff 00`) and the full +/// telescope (j = 1288, header `7c 00 01`) have the same length and the +/// byte-least header wins, so `t` does not reference `u`, and the Kahn order +/// places `t` before its stored descendant `u`. That candidate is not closed +/// under stored descendants (one pass would evaluate `t`'s entry with `u` +/// available at its later index) and runs per prefix. One spine node fewer +/// and the tie does not arise. The result is the bytes of the Lean reference +/// construction (`canonicalSharingTiered`), in both modes and under every +/// parallel budget; every width alone is a valid encoding. +#[test] +fn per_prefix_phase3_witness() { + use super::tiered::descendant_closed; + let l = ShareLayout::TagN; + let c = wrap(&mut Rng(113), per_prefix_witness(1287)); + let (n, r) = normalize_constant_sharing_tiered(l, &c, &limits()).unwrap(); + assert_eq!(r.stats.per_prefix_candidates, 1); + assert_eq!(r.stats.candidate_lengths, vec![(1, 7106), (2, 7106), (3, 7123)]); + assert_eq!((r.stats.w, r.sharing.len()), (1, 10)); + // The table entries, then the roots, as `put_expr` (Lean `serExpr`) + // writes them: the blake3 of Lean's `canonicalSharingTiered` output. + let mut bytes = Vec::new(); + for e in r.sharing.iter().chain(&r.roots) { + put_expr(e, &mut bytes); + } + assert_eq!( + (bytes.len(), blake3::hash(&bytes).to_hex().to_string()), + ( + 7105, + "3024b70893d7121520cac690c305129190affc0aa5bbc1cd4186123d9543147f".into() + ) + ); + // Each width alone: a valid encoding of the same constant; at w = 2 the + // order is not closed and phase 3 runs per prefix. + let dag = SharingDag::from_constant(&c, &limits()).unwrap(); + for (w, len) in [(1, 7106), (2, 7106), (3, 7123)] { + let (m, s) = + normalize_constant_sharing_tiered_at_width(l, &c, &limits(), w).unwrap(); + assert_eq!(s.stats.candidate_lengths, vec![(w, len)]); + assert_eq!(s.stats.per_prefix_candidates, u64::from(w == 2), "w={w}"); + assert_eq!(descendant_closed(dag.nodes(), &s.table_terms), w != 2); + assert_eq!(put(&unshared(&m)), put(&unshared(&c)), "w={w}"); + } + // The default mode and every parallel budget give the same bytes and + // result (the per-prefix candidate's tasks split by `materialize`). + let default = ExactSharingLimits::default(); + let (d, rd) = normalize_constant_sharing_tiered(l, &c, &default).unwrap(); + assert_eq!((put(&d), &rd), (put(&n), &r)); + for (w, k, m) in PAR_BUDGETS { + for lim in [&default, &limits()] { + let (p, rp) = + normalize_constant_sharing_tiered_par(l, &c, lim, par(w, k, m)) + .unwrap(); + assert_eq!((put(&p), &rp), (put(&n), &r), "budget {w},{k},{m}"); + } + } + // Control: one spine node fewer. + let r0 = + canonical_sharing_tiered(l, &per_prefix_witness(1286), &limits()).unwrap(); + assert_eq!(r0.stats.per_prefix_candidates, 0); +} + +/// `descendant_closed` against a direct check (every stored descendant of +/// every stored term comes before it), on random stored sets of generated +/// DAGs in random orders and in increasing-ID orders with a few swaps. +#[test] +fn descendant_closed_matches_brute_force() { + use super::tiered::descendant_closed; + let mut rng = Rng(127); + let (mut closed, mut open) = (0, 0); + for case in 0..600 { + let roots = gen_search_roots(&mut rng); + if roots.is_empty() { + continue; + } + let dag = SharingDag::from_expanded_roots(&roots, &limits()).unwrap(); + let nodes = dag.nodes(); + let n = nodes.len(); + let mut order: Vec = + (0..n as TermId).filter(|_| rng.pct(40)).collect(); + if rng.pct(50) { + for k in (1..order.len()).rev() { + order.swap(k, rng.below(k as u64 + 1) as usize); + } + } else { + for _ in 0..rng.below(3) { + if order.len() > 1 { + let k = rng.below(order.len() as u64 - 1) as usize; + order.swap(k, k + 1); + } + } + } + let pos: HashMap = + order.iter().enumerate().map(|(i, &t)| (t, i)).collect(); + let brute = order.iter().enumerate().all(|(i, &t)| { + let mut stack: Vec = + nodes[t as usize].children().as_slice().to_vec(); + let mut seen = vec![false; n]; + while let Some(x) = stack.pop() { + if std::mem::replace(&mut seen[x as usize], true) { + continue; + } + if pos.get(&x).is_some_and(|&p| p > i) { + return false; + } + stack.extend_from_slice(nodes[x as usize].children().as_slice()); + } + true + }); + assert_eq!(descendant_closed(nodes, &order), brute, "case {case}"); + if brute { + closed += 1; + } else { + open += 1; + } + } + assert!(closed > 100 && open > 100, "{closed} closed, {open} open"); +} diff --git a/crates/ixon/src/sharing_exact/tiered.rs b/crates/ixon/src/sharing_exact/tiered.rs new file mode 100644 index 000000000..9b645b431 --- /dev/null +++ b/crates/ixon/src/sharing_exact/tiered.rs @@ -0,0 +1,1382 @@ +//! Tiered canonical sharing: uniform-width selection, slot allocation and +//! re-materialization under a Share layout. +//! +//! A rule-for-rule port of the Lean `Ix/Sharing/Exact/Tiered.lean`. +//! +//! The one layout, [`ShareLayout::TagN`], prices a Share at table index `i` by +//! the wire width of the TagN Share code ([`tagn_width`]: 1, 2, 3, 4, 5 or 9 +//! bytes, the width of `TagN::put(4, 0xB, i)`). The output is written with +//! that code, so its price is its serialized length, which is checked. +//! +//! **Width selection.** Phase 1 runs at each uniform width `w` in 1, 2, 3, +//! each result is carried through phases 2 and 3, and the construction +//! returns the candidate with the fewest final layout bytes; ties go to the +//! lower `w`, then `set_prec` on the stored set. Every limit and every +//! length check of phases 1-3 applies to every candidate, and an error at +//! any width fails the call (with the lowest failing width's error); the +//! self-checks of the built expressions apply to the returned candidate +//! (see "Checks"). Each candidate is exact per phase as described below; +//! the final choice is the real-byte minimum over the three candidates, not +//! a global optimum. One candidate is `tiered_at` (Lean `tieredAtWidth`). +//! +//! **Phase 1 (selection).** The stored set and its bodies are the +//! uniform-`w` optimum ([`super::optimize_sharing_uniform`]). Phase 2 reads only +//! what the phase-1 expressions contain, so they are not built: the dry run +//! (`UniformPlan::shares`) reports it from the same decisions. +//! +//! **Phase 2 (slot allocation).** From the phase-1 output, `ref(t)` counts +//! the `Share(t)` in its entries and roots; `t` depends on `u` when `t`'s +//! phase-1 body contains `Share(u)`. The first tier is a maximum-`ref` set +//! of at most 8 stored terms closed under dependencies (ties: order stored +//! terms by `ref` descending then ID ascending, and prefer the set that +//! contains the first term where two sets differ), found by branch and +//! bound. The table is the first tier in pinned priority order, then the +//! rest in the Kahn priority order: repeatedly the available entry (every +//! entry its phase-1 body references already placed) with the largest +//! `ref`, ties by the smaller ID. If that order's reference cost +//! `sum ref(t) * width_at(index t)` exceeds the phase-1 order's, the phase-1 +//! order is kept. The final order is checked to respect the dependencies. +//! +//! **Phase 3 (re-materialization).** Every entry is re-encoded with `C_M` +//! under the entries before it, priced by `width_at(index)`, and the roots +//! under all entries; byte-least ties. The result is checked to be no +//! longer (in layout bytes) than phase 1. The selection needs only the +//! lengths, so only the returned candidate's expressions are built +//! ([`finish`]). +//! +//! When the order is closed under stored descendants (every stored +//! descendant of an entry precedes it; `descendant_closed` decides it in one +//! pass), the cost and choice of every term below entry `j` are the same +//! under the prefix `order[..j]` as under the whole table (Lean +//! `gCost_local`), so one evaluation of the whole table gives every task: +//! entry `j` with its own Share hidden, the roots as they are (the one-pass +//! phase 3). Every order of Init and Mathlib is closed. An order that is not +//! is evaluated per prefix (`per_prefix_tasks`): one evaluation of each +//! prefix, maintained from one prefix to the next. Such an order needs an +//! entry whose phase-1 body does not reference a stored descendant, which +//! takes a tie between a telescope cut at that descendant and a longer +//! telescope, so a telescope spine of at least 1,032 nodes (the 3-byte +//! header rung). +//! +//! # Checks +//! +//! In the default mode (the compiler's), every candidate (`tiered_at`) is +//! checked, in this order, for: +//! +//! 1. phase 1: the telescope-spine bound, the length domain, `states`, +//! `work`, `knapsack_cells`, `output_bytes` (on the model length) and the +//! model length against the full evaluation; +//! 2. the phase-1 dry run: the consistency of the decisions, `input_nodes` +//! on the expression nodes the phase-1 build would allocate (what the +//! re-expansion check of the built expressions charges) and the domain of +//! the real length; +//! 3. phase 2: `states` of the first-tier search and the dependency order; +//! 4. phase 3: `work` of the evaluations (and, per prefix, of the +//! decisions), the domain of the length, the length against phase 1, +//! `input_nodes` on the expression nodes the build allocates (exact per +//! prefix; in one pass bounded by twice the length and counted exactly +//! only when that bound exceeds the limit) and `output_bytes`. +//! +//! The returned candidate alone ([`finish`]) is then checked for: +//! +//! 5. the one-pass decisions and their `work`, added to the candidate's; +//! 6. the build of its expressions; +//! 7. their layout price against the evaluated length; +//! 8. their re-expansion to the DAG and the stored terms, with as many +//! expression nodes as counted; +//! 9. their serialized length (`put_expr`) against the evaluated length. +//! +//! The phase-1 expressions are never built, and checks 5-9 do not run for +//! the two other candidates; their limits are checked with the same counts +//! as the returned candidate's, except the work of check 5. A wrong length +//! of another candidate would change the selection without an error; the +//! checked mode exists to show that this does not happen. +//! +//! With [`ExactSharingLimits::full_check`] (the checked mode) every +//! candidate also builds its phase-1 expressions from the same decisions, +//! checks them as `optimize_uniform` does (re-expansion, real length) and +//! compares them with the dry run (the Shares of each entry, the entries +//! each entry shares, the expression nodes, the real length and the layout +//! price); a one-pass candidate is also evaluated per prefix and its task +//! lengths and decisions are compared; and checks 5-9 run for every +//! candidate, the returned one first (the work of check 5 is charged to the +//! returned candidate only, as in the default mode, so every limit has the +//! outcome it has there). The output and the result equal the default +//! mode's; any discrepancy is an internal error. + +use std::sync::Arc; + +use rustc_hash::FxHashMap; + +use super::cost::{Len, exprs_len_with, tag0_len}; +use super::dag::{Node, SharingDag, TermId, ix}; +use super::dict::{ + Evaluation, Hide, IncrementalCosts, Indices, LazyCosts, Materializer, Plan, + PlanShares, Widths, eval_node, +}; +use super::prof::{self, Phase}; +use super::uniform::{ + DagPrep, UniformPlan, UniformSharingResult, optimize_uniform_with, + pinned_order, set_prec, +}; +use super::{ + ExactSharingLimits, FormatBound, Meter, NormalizeBytesError, Parallelism, + Resource, ResourceExhausted, SharingError, constant_fixed_len, + constant_info_root_exprs, rebuild_constant_info, +}; +use crate::constant::Constant; +use crate::expr::Expr; +use crate::serialize::put_expr; +use crate::tag::TagN; + +fn internal(msg: impl Into) -> SharingError { + SharingError::Internal(msg.into()) +} + +fn overflow() -> SharingError { + SharingError::FormatBound(FormatBound::LengthOverflow) +} + +fn len64(n: usize) -> u64 { + u64::try_from(n).unwrap_or(u64::MAX) +} + +/// End (exclusive) of the 1-byte TagN Share rung (the Share flag is 4 bits, +/// so the payload has 4 bits; `TagN::end1(4)`). +pub const TAGN_RUNG1_END: u64 = TagN::end1(4); +/// End of the 2-byte rung (2 + 8 value bits; `TagN::end2(4)`). +pub const TAGN_RUNG2_END: u64 = TagN::end2(4); +/// End of the 3-byte rung (2 following bytes; `TagN::end3(4)`). +pub const TAGN_RUNG3_END: u64 = TagN::end3(4); +/// End of the 4-byte rung (3 following bytes; `TagN::end4(4)`). +pub const TAGN_RUNG4_END: u64 = TagN::end4(4); +/// End of the 5-byte rung (4 following bytes; `TagN::end5(4)`); every larger +/// `u64` index is in the 9-byte rung. +pub const TAGN_RUNG5_END: u64 = TagN::end5(4); + +/// Byte width of the TagN Share at index `i` (`TagN::byte_width(4, i)`: +/// 1, 2, 3, 4, 5 or 9), as Lean's `tagNWidth`. +pub fn tagn_width(i: u64) -> u64 { + len64(TagN::byte_width(4, i)) +} + +/// The Share width layout: the TagN Share code, the only wire code. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum ShareLayout { + /// The TagN Share code ([`tagn_width`]). + TagN, +} + +impl ShareLayout { + /// Width of the Share at table index `i`. + pub fn width_at(self, i: u64) -> u64 { + match self { + ShareLayout::TagN => tagn_width(i), + } + } + + /// The layout of the wire Share code (TagN). + pub fn wire() -> ShareLayout { + ShareLayout::TagN + } +} + +/// Variable length of an encoding with every Share priced by `layout`. +pub fn layout_bytes( + layout: ShareLayout, + sharing: &[Arc], + roots: &[Arc], +) -> Option { + let price = |i: u64| layout.width_at(i); + exprs_len_with(len64(sharing.len()), sharing.iter().chain(roots), &price) +} + +/// All `Share` indices of an expression, with multiplicity, in left-to-right +/// pre-order. +pub(crate) fn share_indices(e: &Expr, out: &mut Vec) { + let mut stack: Vec<&Expr> = vec![e]; + while let Some(x) = stack.pop() { + if let Expr::Share(i) = x { + out.push(*i); + } + for c in super::cost::expr_children(x).into_iter().rev().flatten() { + stack.push(c.as_ref()); + } + } +} + +/// Real table indices priced by a layout. +struct LayoutIndex { + index: Vec>, + layout: ShareLayout, +} + +impl Widths for LayoutIndex { + fn width(&self, t: TermId) -> Option { + self.index[ix(t)].map(|i| self.layout.width_at(i)) + } +} + +impl Indices for LayoutIndex { + fn index(&self, t: TermId) -> Option { + self.index[ix(t)] + } +} + +// --------------------------------------------------------------------------- +// First-tier allocation +// --------------------------------------------------------------------------- + +/// Whether every term of `order` comes after all its dependencies (Lean +/// `respectsDeps`). +fn respects_deps( + order: &[TermId], + deps: &FxHashMap>, +) -> bool { + let pos: FxHashMap = + order.iter().enumerate().map(|(i, &t)| (t, i)).collect(); + order.iter().enumerate().all(|(i, t)| { + deps + .get(t) + .is_none_or(|ds| ds.iter().all(|d| pos.get(d).is_some_and(|&p| p < i))) + }) +} + +/// The Kahn priority order of `rest` (Lean `kahnOrder`): repeatedly place +/// the available term (every dependency of it in `rest` already placed) of +/// the largest weight, ties by the smaller ID. Terms left over, which +/// acyclic dependencies never leave, follow in priority order. +pub(crate) fn kahn_order( + weight: &FxHashMap, + deps: &FxHashMap>, + rest: &[TermId], +) -> Vec { + let w = |t: TermId| weight.get(&t).copied().unwrap_or(0); + let mut sorted = rest.to_vec(); + sorted.sort_by(|&a, &b| w(b).cmp(&w(a)).then(a.cmp(&b))); + let m = sorted.len(); + let rank: FxHashMap = + sorted.iter().enumerate().map(|(i, &t)| (t, i)).collect(); + // A repeated dependency is counted once per repetition in `pend` and + // listed as often in `users`, so it is released as often as it is counted: + // repetitions do not change the order, and no dedup (quadratic in an + // entry's dependencies) is needed. + let mut pend = vec![0usize; m]; + let mut users: Vec> = vec![Vec::new(); m]; + for (i, t) in sorted.iter().enumerate() { + for d in deps.get(t).into_iter().flatten() { + if let Some(&r) = rank.get(d) { + pend[i] += 1; + users[r].push(i); + } + } + } + let mut ready: std::collections::BTreeSet = + (0..m).filter(|&i| pend[i] == 0).collect(); + let mut placed = vec![false; m]; + let mut out = Vec::with_capacity(m); + while let Some(r) = ready.pop_first() { + placed[r] = true; + out.push(sorted[r]); + for &u in &users[r] { + pend[u] -= 1; + if pend[u] == 0 { + ready.insert(u); + } + } + } + out.extend((0..m).filter(|&i| !placed[i]).map(|i| sorted[i])); + out +} + +/// Maximum-weight dependency-closed set of at most `cap` stored terms, with +/// the tie order of the module docs. `deps[t]` are the terms `t` +/// references. Returns the set (ascending) and the states visited. +pub(crate) fn first_tier( + stored: &[TermId], + weight: &FxHashMap, + deps: &FxHashMap>, + cap: usize, + limits: &ExactSharingLimits, +) -> Result<(Vec, u64), SharingError> { + let w = |t: TermId| weight.get(&t).copied().unwrap_or(0); + let mut items: Vec = stored.to_vec(); + items.sort_by(|&a, &b| w(b).cmp(&w(a)).then(a.cmp(&b))); + // Closures with early cutoff above `cap`, with the same pop budget as + // the reference (`4 * |stored| + 4` pops). + let mut closure: FxHashMap> = FxHashMap::default(); + let fuel = stored.len().saturating_mul(4).saturating_add(4); + // The visited set never exceeds `cap + 1` terms (the search stops there), + // so it is a short vector. + let mut seen: Vec = Vec::new(); + let mut stack: Vec = Vec::new(); + for &t in stored { + seen.clear(); + stack.clear(); + stack.push(t); + let mut ok = true; + for _ in 0..fuel { + let Some(u) = stack.pop() else { break }; + if seen.contains(&u) { + continue; + } + seen.push(u); + if seen.len() > cap { + ok = false; + break; + } + if let Some(ds) = deps.get(&u) { + stack.extend_from_slice(ds); + } + } + if ok { + let mut cl: Vec = seen.clone(); + cl.sort_unstable(); + closure.insert(t, cl); + } + } + // Depth-first branch and bound, "include" before "exclude"; the first + // maximum found wins ties, so later subtrees are pruned when their bound + // does not exceed the best weight. + // `excluded` holds the item positions decided "exclude" on the path, as a + // bit set (a term is excluded exactly when its item position is). + struct Frame { + pos: usize, + cur: u64, + in_f: Vec, + excluded: Vec, + } + let item_pos: FxHashMap = + items.iter().enumerate().map(|(i, &t)| (t, i)).collect(); + let is_excluded = |excluded: &[u64], u: &TermId| { + item_pos.get(u).is_some_and(|&i| { + excluded.get(i / 64).is_some_and(|w| w >> (i % 64) & 1 == 1) + }) + }; + let mut best: Option<(u64, Vec)> = None; + let mut states: u64 = 0; + let mut stack = + vec![Frame { pos: 0, cur: 0, in_f: Vec::new(), excluded: Vec::new() }]; + while let Some(Frame { pos, cur, in_f, excluded }) = stack.pop() { + states += 1; + if states > limits.max_states { + return Err(SharingError::ResourceExhausted(ResourceExhausted { + resource: Resource::States, + limit: limits.max_states, + })); + } + let room = cap.saturating_sub(in_f.len()); + let mut bound = cur; + let mut taken = 0usize; + for &t in &items[pos.min(items.len())..] { + if taken >= room { + break; + } + if in_f.contains(&t) { + continue; + } + bound = bound.saturating_add(w(t)); + taken += 1; + } + if let Some((b, _)) = &best + && bound <= *b + { + continue; + } + if pos >= items.len() { + if best.as_ref().is_none_or(|(b, _)| cur > *b) { + best = Some((cur, in_f)); + } + continue; + } + let t = items[pos]; + if in_f.contains(&t) { + stack.push(Frame { pos: pos + 1, cur, in_f, excluded }); + continue; + } + let mut exclude = excluded.clone(); + if exclude.len() <= pos / 64 { + exclude.resize(pos / 64 + 1, 0); + } + exclude[pos / 64] |= 1 << (pos % 64); + let mut include: Option = None; + if let Some(cl) = closure.get(&t) { + let new: Vec = + cl.iter().copied().filter(|u| !in_f.contains(u)).collect(); + if !cl.iter().any(|u| is_excluded(&excluded, u)) + && in_f.len() + new.len() <= cap + { + let add = new.iter().fold(0u64, |acc, &u| acc.saturating_add(w(u))); + let mut in2 = in_f.clone(); + in2.extend_from_slice(&new); + include = Some(Frame { + pos: pos + 1, + cur: cur.saturating_add(add), + in_f: in2, + excluded, + }); + } + } + stack.push(Frame { pos: pos + 1, cur, in_f, excluded: exclude }); + if let Some(f) = include { + stack.push(f); + } + } + match best { + Some((_, mut s)) => { + s.sort_unstable(); + Ok((s, states)) + }, + None => Ok((Vec::new(), states)), + } +} + +/// Whether every stored term of `order` comes after all its stored +/// descendants (the order is closed under stored descendants). One pass in +/// increasing ID: the frontier of a term is the largest position among its +/// nearest stored descendants-or-self, and every stored term's children's +/// frontiers must be before it (then, by induction, every stored descendant +/// is). +pub(crate) fn descendant_closed(nodes: &[Node], order: &[TermId]) -> bool { + let n = nodes.len(); + let mut pos: Vec = vec![u64::MAX; n]; + for (i, &t) in order.iter().enumerate() { + pos[ix(t)] = len64(i); + } + // `frontier[x] = 0` for none, else the position plus one. + let mut frontier: Vec = vec![0; n]; + for x in 0..n { + let below = nodes[x] + .children() + .as_slice() + .iter() + .map(|&c| frontier[ix(c)]) + .max() + .unwrap_or(0); + if pos[x] == u64::MAX { + frontier[x] = below; + } else { + if below > pos[x] { + return false; + } + frontier[x] = pos[x] + 1; + } + } + true +} + +/// The phase-3 decisions of every task of a candidate whose order is closed +/// under stored descendants, from the evaluation `costs` of the full +/// dictionary `dict`: entry `j` under `dict` with its own Share hidden, the +/// roots under `dict`. They equal the per-prefix decisions: the choice and +/// cost of a term read only the dictionary at and below it, and below entry +/// `j` the prefix `order[..j]` and the full dictionary agree (every stored +/// descendant is in the prefix, at the same index; the entry itself is +/// absent from one and hidden in the other). +#[allow(clippy::too_many_arguments)] +fn one_pass_plans( + dag: &SharingDag, + own: &[Len], + order: &[TermId], + dict: &LayoutIndex, + costs: &[Len], + mat: &mut Materializer, + work: &mut u64, +) -> Result, SharingError> { + let nodes = dag.nodes(); + let mut plans = Vec::with_capacity(order.len() + 1); + for t in order { + let hide = Hide { inner: dict, hidden: *t }; + plans.push(mat.decide( + nodes, + own, + &hide, + costs, + std::slice::from_ref(t), + work, + )?); + } + plans.push(mat.decide(nodes, own, dict, costs, dag.roots(), work)?); + Ok(plans) +} + +/// The phase-3 evaluation of the growing dictionary: [`LazyCosts`] when its +/// work argument applies, otherwise [`IncrementalCosts`]. Both give the +/// costs of the descendants of prepared targets and the work count of a +/// full evaluation of the current dictionary. +enum Phase3Eval<'a> { + Lazy(LazyCosts<'a>), + Eager(IncrementalCosts<'a>), +} + +impl Phase3Eval<'_> { + fn add(&mut self, t: TermId, widths: &W) { + match self { + Phase3Eval::Lazy(e) => e.add(t, widths), + Phase3Eval::Eager(e) => e.add(t, widths), + } + } + + fn prepare(&mut self, targets: &[TermId], widths: &W) { + if let Phase3Eval::Lazy(e) = self { + e.prepare(targets, widths); + } + } + + fn costs(&self) -> &[Len] { + match self { + Phase3Eval::Lazy(e) => e.costs(), + Phase3Eval::Eager(e) => e.costs(), + } + } + + fn work(&self) -> u64 { + match self { + Phase3Eval::Lazy(e) => e.work(), + Phase3Eval::Eager(e) => e.work(), + } + } +} + +/// One task of the per-prefix phase 3: its decisions, its length (entry +/// `j`'s inline cost under the entries before it, or the roots' cost under +/// all entries) and its work (a full evaluation of its prefix plus its +/// decisions). +pub(crate) type Task = Result<(Plan, Len, u64), SharingError>; + +/// The per-prefix phase 3 of `order` (module docs). Task `j < k` is entry +/// `j`, task `k` the roots; each depends only on the prefix `order[..j]`, so +/// the tasks run in up to `budget` independent ranges (see +/// `Parallelism::materialize`) and come back in task order. Each range +/// starts from the evaluation of its first prefix (`C_0` for the empty one) +/// and maintains it from one prefix to the next (`LazyCosts`, or +/// `IncrementalCosts` when its work argument does not apply), which yields +/// the same costs for the materialized terms and the same work count as +/// evaluating every prefix from scratch; the decisions +/// (`Materializer::decide`) are those of `materialize`, with its work. +pub(crate) fn per_prefix_tasks( + layout: ShareLayout, + dag: &SharingDag, + prep: &DagPrep, + order: &[TermId], + budget: usize, +) -> Vec { + let nodes = dag.nodes(); + let n = nodes.len(); + let own = &prep.own; + let tasks = |range: std::ops::Range| { + let p = prof::scope(Phase::RematerializeCosts); + let mut dict = LayoutIndex { index: vec![None; n], layout }; + for (i, &t) in order[..range.start].iter().enumerate() { + dict.index[ix(t)] = Some(len64(i)); + } + // The evaluation of the empty prefix is `C_0`, the same for every + // candidate. + let start = if range.start == 0 { + prep.base.clone() + } else { + Evaluation::new(nodes, own, &dict) + }; + let mut eval = if LazyCosts::applies(&prep.base) { + Phase3Eval::Lazy(LazyCosts::new(nodes, own, &prep.edges, start, &dict)) + } else { + Phase3Eval::Eager(IncrementalCosts::new(nodes, own, &prep.edges, start)) + }; + let mut mat = Materializer::new(n); + drop(p); + let mut out: Vec = Vec::with_capacity(range.len()); + for j in range.clone() { + if j > range.start { + let p = prof::scope(Phase::RematerializeCosts); + let t = order[j - 1]; + dict.index[ix(t)] = Some(len64(j - 1)); + eval.add(t, &dict); + drop(p); + } + let target = order.get(j).map(std::slice::from_ref); + let p = prof::scope(Phase::RematerializeCosts); + eval.prepare(target.unwrap_or(dag.roots()), &dict); + drop(p); + let _p = prof::scope(Phase::RematerializeDecide); + let mut w = eval.work(); + let costs = eval.costs(); + if let Some(&t) = order.get(j) { + let r = mat.decide(nodes, own, &dict, costs, &[t], &mut w); + out.push(r.map(|plan| (plan, costs[ix(t)], w))); + } else { + let mut c = Len::ZERO; + for &r in dag.roots() { + c = c.plus(costs[ix(r)]); + } + let r = mat.decide(nodes, own, &dict, costs, dag.roots(), &mut w); + out.push(r.map(|plan| (plan, c, w))); + } + } + out + }; + super::par::map_ranges(order.len() + 1, budget, tasks) +} + +// --------------------------------------------------------------------------- +// Result and driver +// --------------------------------------------------------------------------- + +/// Statistics of the tiered construction. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct TieredStats { + pub layout: ShareLayout, + /// Terms with in-degree >= 2 and unshared length >= 2. + pub candidate_count: u64, + /// Phase-1 uniform width of the returned candidate (the winning width). + pub w: u64, + /// Final layout length of every candidate run, as `(w, bytes)` in + /// increasing `w` (one entry for a single candidate, `tiered_at`). + pub candidate_lengths: Vec<(u64, u64)>, + /// Per candidate run, in increasing `w`: `(w, phase-1 uniform-model + /// length, states_created, work)`, the last two the totals charged to that + /// candidate (for the returned candidate including the work of its + /// one-pass decisions, which only it makes). Diagnostic: the counts that + /// the limits act on. + pub candidate_meters: Vec<(u64, u64, u64, u64)>, + /// Candidates whose phase 3 ran per prefix (their order is not closed + /// under stored descendants, or `phase3_per_prefix`); the others ran in + /// one pass. + pub per_prefix_candidates: u64, + /// Phase-1 uniform-model length. + pub phase1_model_bytes: u64, + /// Phase-1 output priced by the layout (its own order). + pub phase1_layout_bytes: u64, + /// First-tier search states. + pub slot_states: u64, + pub first_tier: Vec, + /// The guard kept the phase-1 order. + pub kept_phase1_order: bool, + /// Reference cost `sum ref * width_at` of the phase-1 and final orders. + pub phase1_ref_cost: u128, + pub final_ref_cost: u128, + /// Final length priced by the layout. + pub phase3_layout_bytes: u64, + /// `phase1_layout_bytes - phase3_layout_bytes`. + pub savings: u64, +} + +/// Tiered result. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct TieredSharingResult { + pub roots: Vec>, + pub sharing: Vec>, + pub table_terms: Vec, + /// Variable length priced by the layout. + pub model_len: u64, + /// Real variable length: the table count and the entries and roots as + /// the wire codec (`put_expr`) writes them, which the construction + /// serializes and compares with `model_len`. + pub variable_len: u64, + pub unshared_len: Option, + /// The phase-1 result of the returned candidate's width. Its expressions + /// are not built: `roots` and `sharing` are empty, and `variable_len` is + /// the real length the dry run computed (the model with every Share priced + /// at its TagN width). + pub phase1: UniformSharingResult, + pub stats: TieredStats, +} + +/// The tiered canonical construction on a DAG (Lean +/// `canonicalTieredCore`): phases 1-3 at each phase-1 width 1, 2 and 3, +/// returning the candidate with the fewest final layout bytes; ties go to +/// the lower width, then `set_prec` on the stored set. Each candidate runs +/// under its own meter with the same limits, and an error at any width +/// fails the whole call; the returned candidate (with +/// [`ExactSharingLimits::full_check`], every candidate) is built and checked +/// (module docs, "Checks"). `par` sets the thread budgets ([`Parallelism`]). +pub(crate) fn tiered( + layout: ShareLayout, + dag: &SharingDag, + limits: &ExactSharingLimits, + par: Parallelism, +) -> Result { + // The width-independent tables, shared by the three candidates. + let prep = DagPrep::new(dag); + let run = |w: u64| { + let mut meter = Meter::with_parallelism(limits, par); + tiered_at(layout, dag, &prep, &mut meter, w) + }; + let candidates: Vec> = if par.widths <= 1 { + // The sequential reference stops at the first failing width. + let mut v = Vec::with_capacity(3); + for w in 1..=3 { + v.push(Ok(run(w)?)); + } + v + } else { + super::par::map_ranges(3, par.widths, |r| { + r.map(|i| run(len64(i) + 1)).collect() + }) + }; + let mut built: Vec = Vec::with_capacity(3); + let mut best: Option = None; + let mut lengths = Vec::with_capacity(3); + let mut meters = Vec::with_capacity(3); + let mut per_prefix = 0; + for (w, c) in (1..=3).zip(candidates) { + // In width order: the error of the lowest failing width, as above. + let c = c?; + per_prefix += u64::from(matches!(c.phase3, Phase3::Plans(_))); + lengths.push((w, c.result.stats.phase3_layout_bytes)); + meters.extend_from_slice(&c.result.stats.candidate_meters); + if best.is_none_or(|b| tiered_better(&c.result, &built[b].result)) { + best = Some(built.len()); + } + built.push(c); + } + let best_ix = best.ok_or_else(|| internal("no tiered candidate"))?; + // The returned candidate first, so that its errors are the default + // mode's; then, in the checked mode, the others. + let mut rest: Vec = Vec::with_capacity(2); + let mut chosen: Option = None; + for (i, c) in built.into_iter().enumerate() { + if i == best_ix { + chosen = Some(c); + } else { + rest.push(c); + } + } + let chosen = chosen.ok_or_else(|| internal("no tiered candidate"))?; + let mut best = finish(layout, dag, &prep, limits, chosen, true)?; + if limits.full_check { + for c in rest { + finish(layout, dag, &prep, limits, c, false)?; + } + } + // The returned candidate's meter includes the work charged in `finish`. + if let (Some(m), Some(&f)) = + (meters.get_mut(best_ix), best.stats.candidate_meters.first()) + { + *m = f; + } + best.stats.candidate_lengths = lengths; + best.stats.candidate_meters = meters; + best.stats.per_prefix_candidates = per_prefix; + Ok(best) +} + +/// A candidate before its expressions are built: the result with empty +/// `roots` and `sharing`, and how its phase-3 decisions are obtained. +/// +/// Only the returned candidate is built ([`finish`]; with +/// [`ExactSharingLimits::full_check`], every candidate): the selection reads +/// the final length, the width and the stored set, which phase 3 computes +/// from the costs. Every limit of a candidate is checked in [`tiered_at`], +/// with the counts of the build where it allocates (the input nodes of the +/// re-expansion check are the expression nodes the build allocates) and the +/// output length that the checks of [`finish`] prove equal to the evaluated +/// one; only the work of the one-pass decisions, which only [`finish`] +/// makes, is charged to the returned candidate alone (module docs, +/// "Checks"). +pub(crate) struct Candidate { + result: TieredSharingResult, + phase3: Phase3, + /// With [`ExactSharingLimits::full_check`], for a one-pass candidate: the + /// decisions of the per-prefix phase 3, which [`finish`] compares with + /// the one-pass decisions. + reference: Option>, +} + +/// How a candidate's phase-3 decisions are obtained. +enum Phase3 { + /// The order is closed under stored descendants: every task is decided + /// under the full dictionary (with the entry's own Share hidden), whose + /// evaluation `costs` is kept. + OnePass { costs: Vec }, + /// The per-prefix decisions of every task. + Plans(Vec), +} + +/// Build the expressions of a candidate and check them: the layout price +/// against the evaluation, the re-expansion (same DAG, entries expanding to +/// the stored terms, as many expression nodes as counted) and the +/// serialized length. With `charge` the work of the one-pass decisions is +/// added to the candidate's and checked against `max_work` (the returned +/// candidate); without (another candidate, checked mode) it is not charged. +fn finish( + layout: ShareLayout, + dag: &SharingDag, + prep: &DagPrep, + limits: &ExactSharingLimits, + cand: Candidate, + charge: bool, +) -> Result { + let Candidate { mut result, phase3, reference } = cand; + let nodes = dag.nodes(); + let p = prof::scope(Phase::RematerializeDecide); + let order = &result.table_terms; + let k_entries = order.len(); + // Every Share of a task names an entry before it, whose index is its + // position in the final order. + let mut dict = LayoutIndex { index: vec![None; nodes.len()], layout }; + for (i, &t) in order.iter().enumerate() { + dict.index[ix(t)] = Some(len64(i)); + } + let mut mat = Materializer::new(nodes.len()); + let plans = match phase3 { + Phase3::Plans(plans) => plans, + Phase3::OnePass { costs } => { + // The decisions of every task under the full dictionary (see + // `one_pass_plans`), and their work. + let mut work = 0u64; + let plans = one_pass_plans( + dag, &prep.own, order, &dict, &costs, &mut mat, &mut work, + )?; + if charge { + let total = result + .stats + .candidate_meters + .first() + .map_or(0, |m| m.3) + .saturating_add(work); + if total > limits.max_work { + return Err(SharingError::ResourceExhausted(ResourceExhausted { + resource: Resource::Work, + limit: limits.max_work, + })); + } + if let Some(m) = result.stats.candidate_meters.first_mut() { + m.3 = total; + } + } + plans + }, + }; + if let Some(reference) = reference + && plans != reference + { + let j = plans.iter().zip(&reference).position(|(a, b)| a != b); + return Err(internal(format!( + "full check: the one-pass phase-3 decisions of task {j:?} differ from \ + the per-prefix decisions" + ))); + } + drop(p); + let p = prof::scope(Phase::RematerializeBuild); + let mut entries = Vec::with_capacity(k_entries); + let mut roots = Vec::new(); + let mut allocated = 0u64; + for (j, plan) in plans.iter().enumerate() { + let mut es = mat.build(nodes, &dict, plan)?; + allocated = allocated.saturating_add(plan.nodes); + if j < k_entries { + entries.push(es.pop().ok_or_else(|| internal("missing entry"))?); + } else { + roots = es; + } + } + drop(p); + let _p = prof::scope(Phase::RematerializeCheck); + let predicted = result.model_len; + // The layout price and the re-expansion check in one walk; when it + // reports a mismatch or an overflow, the separate checks run. + let price = |i: u64| layout.width_at(i); + let fused = dag.check_and_measure(order, &entries, &roots, &price); + let priced = match fused { + Some((_, len)) => len, + None => layout_bytes(layout, &entries, &roots).ok_or_else(overflow)?, + }; + if priced != predicted { + return Err(internal(format!( + "layout length {priced} differs from the evaluation {predicted}" + ))); + } + match fused { + Some((visited, _)) => { + if visited != allocated { + return Err(internal(format!( + "the re-materialized expressions have {visited} nodes, {allocated} counted" + ))); + } + }, + None => dag.check_reexpansion( + order, + &entries, + &roots, + &ExactSharingLimits::unbounded(), + "re-materialized encoding changes the expanded AST", + "re-materialized entries do not expand to the stored terms", + )?, + } + // The input-node limit was checked in `tiered_at` on an exact count, or, + // for a one-pass candidate, on the bound `2 * predicted`; check the bound. + if limits.full_check && allocated > predicted.saturating_mul(2) { + return Err(internal(format!( + "full check: {allocated} expression nodes exceed twice the length \ + {predicted}" + ))); + } + // The real length: the table count and every entry and root as the wire + // codec writes them (`put_sharing`, `put_expr`), one expression at a time + // into a reused buffer; linear in the output. + let mut buf = Vec::new(); + TagN::put(0, 0, len64(entries.len()), &mut buf); + let mut measured = len64(buf.len()); + for e in entries.iter().chain(&roots) { + buf.clear(); + put_expr(e, &mut buf); + measured = measured.saturating_add(len64(buf.len())); + } + if measured != predicted { + return Err(internal(format!( + "serialized length {measured} differs from the evaluation {predicted}" + ))); + } + result.roots = roots; + result.sharing = entries; + result.variable_len = measured; + Ok(result) +} + +/// Whether candidate `a` beats `b` (Lean `tieredBetter`): fewer final layout +/// bytes, then the lower width, then `set_prec` on the stored set. +fn tiered_better(a: &TieredSharingResult, b: &TieredSharingResult) -> bool { + let (x, y) = (&a.stats, &b.stats); + x.phase3_layout_bytes < y.phase3_layout_bytes + || (x.phase3_layout_bytes == y.phase3_layout_bytes + && (x.w < y.w + || (x.w == y.w && set_prec(&a.phase1.stored, &b.phase1.stored)))) +} + +/// The checked mode's phase-1 check of one candidate: build the phase-1 +/// expressions from the decisions of `plan`, check them as +/// `optimize_uniform` does (re-expansion, real length), and compare them +/// with the dry run `shares`: the Shares of each entry in all the +/// expressions and the entries each entry shares (the phase-2 weights and +/// dependencies, computed from the expressions as before the dry run), the +/// expression nodes (the dry run's input-node count), the real length and +/// the layout price of phase 1 (`u.variable_len`). +pub(crate) fn check_phase1( + layout: ShareLayout, + dag: &SharingDag, + u: &UniformSharingResult, + plan: &UniformPlan, + shares: &PlanShares, +) -> Result<(), SharingError> { + let order1 = &u.table_terms; + let built = plan.build(dag, order1, &ExactSharingLimits::unbounded())?; + let fail = |what: &str| { + Err(internal(format!( + "full check: the phase-1 dry run differs from the built expressions \ + ({what})" + ))) + }; + let mut refs = vec![0u64; order1.len()]; + let mut idx = Vec::new(); + for e in built.entries.iter().chain(&built.roots) { + idx.clear(); + share_indices(e, &mut idx); + for &i in &idx { + if let Some(r) = usize::try_from(i).ok().and_then(|i| refs.get_mut(i)) { + *r += 1; + } + } + } + let mut deps: Vec> = Vec::with_capacity(order1.len()); + for e in &built.entries { + idx.clear(); + share_indices(e, &mut idx); + let mut ds: Vec = Vec::new(); + for &j in &idx { + if let Some(&d) = usize::try_from(j).ok().and_then(|j| order1.get(j)) + && !ds.contains(&d) + { + ds.push(d); + } + } + deps.push(ds); + } + if refs != shares.refs { + return fail("Shares per entry"); + } + if deps != shares.deps { + return fail("dependencies"); + } + if built.visited != Some(shares.nodes) { + return fail("expression nodes"); + } + if built.measured != u.variable_len { + return fail("real length"); + } + if layout_bytes(layout, &built.entries, &built.roots) != Some(u.variable_len) + { + return fail("layout price"); + } + Ok(()) +} + +/// The checked mode's reference for a one-pass candidate: its phase 3 per +/// prefix, whose task lengths must equal the one-pass ones (`lengths`, in +/// task order); returns the per-prefix decisions, which [`finish`] compares +/// with the one-pass decisions. Nothing is charged: the work differs by +/// path by design. +pub(crate) fn per_prefix_reference( + layout: ShareLayout, + dag: &SharingDag, + prep: &DagPrep, + order: &[TermId], + budget: usize, + lengths: &[Len], +) -> Result, SharingError> { + let tasks = per_prefix_tasks(layout, dag, prep, order, budget); + if tasks.len() != lengths.len() { + return Err(internal("full check: per-prefix task count")); + } + let mut plans = Vec::with_capacity(tasks.len()); + for (j, (task, &len)) in tasks.into_iter().zip(lengths).enumerate() { + let (plan, cost, _) = task?; + if cost != len { + return Err(internal(format!( + "full check: the one-pass phase-3 length of task {j} ({len:?}) \ + differs from the per-prefix length ({cost:?})" + ))); + } + plans.push(plan); + } + Ok(plans) +} + +/// One candidate of the tiered construction (Lean `tieredAtWidth`): phases +/// 1-3 with phase-1 uniform width `w`. +fn tiered_at( + layout: ShareLayout, + dag: &SharingDag, + prep: &DagPrep, + meter: &mut Meter<'_>, + w: u64, +) -> Result { + let nodes = dag.nodes(); + let n = nodes.len(); + let limits = meter.limits(); + let p = prof::scope(Phase::Prep); + let own = &prep.own; + // The work of the evaluation `C_0` (`prep.base`), charged with phase 3. + let work = prep.base.work(); + let facts = &prep.facts; + let k = len64( + (0..n) + .filter(|&t| facts.deg[t] >= 2 && prep.base.costs[t] >= Len::new(2)) + .count(), + ); + drop(p); + // Phase 1, without building its expressions: phase 2 reads only what they + // contain, which the dry run reports from the same decisions + // (`PlanShares`), with the real length. + let (mut u, plan1) = optimize_uniform_with(w, dag, prep, meter)?; + let (shares, real1) = plan1.shares(dag, &u.table_terms, limits)?; + u.variable_len = real1; + if limits.full_check { + check_phase1(layout, dag, &u, &plan1, &shares)?; + } + drop(plan1); + let p = prof::scope(Phase::Allocate); + let order1 = u.table_terms.clone(); + // The phase-1 output priced by the layout. The TagN layout prices a Share + // at its wire width, so this is the real length of phase 1. + let phase1_layout = match layout { + ShareLayout::TagN => u.variable_len, + }; + // Phase 2: reference counts (the Shares of each entry in all the phase-1 + // expression trees) and dependencies (the entries an entry's phase-1 + // expression shares, in pre-order of first occurrence). + let mut weight: FxHashMap = FxHashMap::default(); + let mut deps: FxHashMap> = FxHashMap::default(); + let PlanShares { refs, deps: entry_deps, .. } = shares; + for ((&t, &r), ds) in order1.iter().zip(&refs).zip(entry_deps) { + weight.insert(t, r); + deps.insert(t, ds); + } + let mut stored = order1.clone(); + stored.sort_unstable(); + let cap = stored.len().min(8); + let (tier, slot_states) = first_tier(&stored, &weight, &deps, cap, limits)?; + let rest: Vec = + stored.iter().copied().filter(|t| !tier.contains(t)).collect(); + let mut order2 = pinned_order(dag, &facts.deg, &tier); + order2.extend(kahn_order(&weight, &deps, &rest)); + let ref_cost = |ord: &[TermId]| -> u128 { + ord.iter().enumerate().fold(0u128, |acc, (i, t)| { + let wt = u128::from(weight.get(t).copied().unwrap_or(0)); + acc.saturating_add(wt * u128::from(layout.width_at(len64(i)))) + }) + }; + let kept = ref_cost(&order2) > ref_cost(&order1); + let order = if kept { order1.clone() } else { order2 }; + if !respects_deps(&order, &deps) { + return Err(internal( + "the allocated order places a body reference after its user", + )); + } + drop(p); + // Phase 3: each entry under the entries before it, priced by the layout, + // then the roots under all entries (module docs). + // + // One pass (the order is closed under stored descendants): one + // evaluation of the full dictionary gives every task's length, entry `j` + // with its own Share hidden and the roots as they are; the decisions are + // made for the returned candidate only (`finish`). The work charged is the + // work done: the evaluation and the hidden-top evaluations. + // + // Per prefix (otherwise): `per_prefix_tasks`, each task charged the work + // of a full evaluation of its prefix plus its decisions, combined in task + // order exactly as the sequential loop proceeds. + let k_entries = order.len(); + let one_pass = !limits.phase3_per_prefix && descendant_closed(nodes, &order); + // With `full_check`, the one-pass length of every task. + let mut task_lengths: Vec = Vec::new(); + let (phase3, predicted, allocated) = if one_pass { + let p = prof::scope(Phase::RematerializeCosts); + let mut dict = LayoutIndex { index: vec![None; n], layout }; + for (i, &t) in order.iter().enumerate() { + dict.index[ix(t)] = Some(len64(i)); + } + let eval = Evaluation::new(nodes, own, &dict); + let mut w = eval.work(); + let mut predicted = Len::new(tag0_len(len64(k_entries))); + for &t in &order { + let hide = Hide { inner: &dict, hidden: t }; + let costs = &eval.costs; + let (c, _) = + eval_node(nodes, own, t, &hide, &|x| costs[ix(x)], false, &mut w); + predicted = predicted.plus(c); + if limits.full_check { + task_lengths.push(c); + } + } + let mut roots = Len::ZERO; + for &r in dag.roots() { + roots = roots.plus(eval.costs[ix(r)]); + } + predicted = predicted.plus(roots); + if limits.full_check { + task_lengths.push(roots); + } + // The work counted before phase 3 (`C_0`) is charged with it. + meter.work(work.saturating_add(w))?; + drop(p); + (Phase3::OnePass { costs: eval.costs }, predicted, None) + } else { + let tasks = + per_prefix_tasks(layout, dag, prep, &order, meter.parallel.materialize); + let mut plans = Vec::with_capacity(k_entries + 1); + let mut predicted = Len::new(tag0_len(len64(k_entries))); + // The work counted before phase 3 is charged with the first task, as the + // sequential loop does. + let mut carried = work; + for task in tasks { + let (plan, cost, w) = task?; + plans.push(plan); + predicted = predicted.plus(cost); + meter.work(carried.saturating_add(w))?; + carried = 0; + } + let allocated = + plans.iter().fold(0u64, |acc, plan| acc.saturating_add(plan.nodes)); + (Phase3::Plans(plans), predicted, Some(allocated)) + }; + let p = prof::scope(Phase::RematerializeCheck); + let predicted = predicted.exact().ok_or_else(overflow)?; + if predicted > phase1_layout { + return Err(internal(format!( + "re-materialization {predicted} is longer than phase 1 {phase1_layout}" + ))); + } + // The input nodes the re-expansion check of the built expressions + // charges: one per expression node, all of them pointer-distinct (every + // task builds fresh nodes). A serialized tree has at most two nodes per + // byte (every node but an App writes at least one byte of its own, and an + // App's argument starts with a byte no other App claims), so the count is + // at most twice the length; only when that bound exceeds the limit are + // the one-pass decisions made here to count exactly. + let allocated = match allocated { + Some(a) => Some(a), + None if predicted.saturating_mul(2) > limits.max_input_nodes => { + let Phase3::OnePass { costs } = &phase3 else { + return Err(internal("one-pass phase 3 without its evaluation")); + }; + let mut dict = LayoutIndex { index: vec![None; n], layout }; + for (i, &t) in order.iter().enumerate() { + dict.index[ix(t)] = Some(len64(i)); + } + let mut scratch = 0u64; + let plans = one_pass_plans( + dag, + own, + &order, + &dict, + costs, + &mut Materializer::new(n), + &mut scratch, + )?; + Some(plans.iter().fold(0u64, |acc, plan| acc.saturating_add(plan.nodes))) + }, + None => None, + }; + if let Some(a) = allocated { + dag.check_input_nodes(a, limits)?; + } + // The real length equals the evaluated one (checked when the candidate + // is built). + meter.output(predicted)?; + drop(p); + // With `full_check`, the per-prefix reference of a one-pass candidate, + // after every check of the default mode (so that its errors come first). + let reference = if limits.full_check && one_pass { + Some(per_prefix_reference( + layout, + dag, + prep, + &order, + meter.parallel.materialize, + &task_lengths, + )?) + } else { + None + }; + let stats = TieredStats { + layout, + candidate_count: k, + w, + candidate_lengths: vec![(w, predicted)], + candidate_meters: vec![( + w, + u.model_len, + meter.stats.states_created, + meter.stats.work, + )], + per_prefix_candidates: u64::from(matches!(phase3, Phase3::Plans(_))), + phase1_model_bytes: u.model_len, + phase1_layout_bytes: phase1_layout, + slot_states, + first_tier: tier, + kept_phase1_order: kept, + phase1_ref_cost: ref_cost(&order1), + final_ref_cost: ref_cost(&order), + phase3_layout_bytes: predicted, + savings: phase1_layout - predicted, + }; + let unshared_len = u.unshared_len; + let result = TieredSharingResult { + roots: Vec::new(), + sharing: Vec::new(), + table_terms: order, + model_len: predicted, + variable_len: predicted, + unshared_len, + phase1: u, + stats, + }; + Ok(Candidate { result, phase3, reference }) +} + +/// Tiered canonical sharing of fully expanded roots under a layout. +pub fn canonical_sharing_tiered( + layout: ShareLayout, + roots: &[Arc], + limits: &ExactSharingLimits, +) -> Result { + let mut meter = Meter::new(limits); + let p = prof::scope(Phase::Dag); + let dag = SharingDag::build(roots, None, &mut meter)?; + drop(p); + let _p = prof::scope(Phase::Total); + tiered(layout, &dag, limits, Parallelism::SEQUENTIAL) +} + +/// Expand `c`'s table and re-share it with the tiered canonical +/// construction (the best of the phase-1 widths 1, 2 and 3). +pub fn normalize_constant_sharing_tiered( + layout: ShareLayout, + c: &Constant, + limits: &ExactSharingLimits, +) -> Result<(Constant, TieredSharingResult), SharingError> { + normalize_tiered_with(c, limits, |dag| { + tiered(layout, dag, limits, Parallelism::SEQUENTIAL) + }) +} + +/// [`normalize_constant_sharing_tiered`] with the thread budgets `par` +/// ([`Parallelism`]): the same bytes and result for every budget. +pub fn normalize_constant_sharing_tiered_par( + layout: ShareLayout, + c: &Constant, + limits: &ExactSharingLimits, + par: Parallelism, +) -> Result<(Constant, TieredSharingResult), SharingError> { + normalize_tiered_with(c, limits, |dag| tiered(layout, dag, limits, par)) +} + +/// The single candidate with phase-1 width `w` ([`tiered_at`], Lean +/// `tieredAtWidth`) on `c`, for the tests of the width selection: the +/// canonical construction returns one of the candidates at `w = 1, 2, 3`. +#[cfg(test)] +pub(crate) fn normalize_constant_sharing_tiered_at_width( + layout: ShareLayout, + c: &Constant, + limits: &ExactSharingLimits, + w: u64, +) -> Result<(Constant, TieredSharingResult), SharingError> { + normalize_tiered_with(c, limits, |dag| { + let prep = DagPrep::new(dag); + let c = tiered_at(layout, dag, &prep, &mut Meter::new(limits), w)?; + finish(layout, dag, &prep, limits, c, true) + }) +} + +/// Expand `c`'s table, run `run` on its DAG, and reassemble the Constant, +/// checking its serialized length against the result's accounting. +fn normalize_tiered_with( + c: &Constant, + limits: &ExactSharingLimits, + run: impl FnOnce(&SharingDag) -> Result, +) -> Result<(Constant, TieredSharingResult), SharingError> { + let mut meter = Meter::new(limits); + let p = prof::scope(Phase::Dag); + let roots = constant_info_root_exprs(&c.info); + let dag = SharingDag::build(&roots, Some(&c.sharing), &mut meter)?; + drop(p); + let fixed = constant_fixed_len(c).ok_or_else(overflow)?; + let p = prof::scope(Phase::Total); + let result = run(&dag)?; + drop(p); + let _p = prof::scope(Phase::Output); + let info = rebuild_constant_info(&c.info, &result.roots)?; + let out = Constant { + info, + sharing: result.sharing.clone(), + refs: c.refs.clone(), + univs: c.univs.clone(), + }; + let mut bytes = Vec::new(); + out.put(&mut bytes); + if u64::try_from(bytes.len()).ok() != fixed.checked_add(result.variable_len) { + return Err(internal("tiered output length differs from its accounting")); + } + Ok((out, result)) +} + +/// Byte-level tiered normalization of exactly one serialized Constant. +pub fn normalize_constant_bytes_tiered( + layout: ShareLayout, + bytes: &[u8], + limits: &ExactSharingLimits, +) -> Result, NormalizeBytesError> { + let mut input = bytes; + let c = Constant::get(&mut input).map_err(NormalizeBytesError::Decode)?; + if !input.is_empty() { + return Err(NormalizeBytesError::Decode(format!( + "{} trailing bytes after the Constant", + input.len() + ))); + } + let (out, _) = normalize_constant_sharing_tiered(layout, &c, limits) + .map_err(NormalizeBytesError::Sharing)?; + let mut buf = Vec::new(); + out.put(&mut buf); + Ok(buf) +} diff --git a/crates/ixon/src/sharing_exact/uniform.rs b/crates/ixon/src/sharing_exact/uniform.rs new file mode 100644 index 000000000..49f53b80b --- /dev/null +++ b/crates/ixon/src/sharing_exact/uniform.rs @@ -0,0 +1,2370 @@ +//! Exact minimum sharing under a uniform Share width. +//! +//! This is a byte-for-byte port of the Lean `Ix/Sharing/Exact/Uniform.lean`; +//! the rules below are pinned by that implementation. +//! +//! Cost model: every `Share` costs exactly `w >= 1` bytes regardless of its +//! index; the table count is an exact TagN; telescopes and every other byte +//! are as written by `put_expr`. The model length of a stored set `S` is +//! `tag0(|S|) + sum_{t in S} inl_S(t) + sum_roots C_S(r)`, where `inl_S(t)` +//! is `t`'s cost with an inline top. Order does not affect it: in any order +//! with stored descendants first each entry sees every stored term that can +//! occur inside it, and a Share's price does not depend on its index. Only +//! the set is chosen; the table order is then pinned (stored descendants +//! first, then larger in-degree, then smaller structural ID). +//! +//! # Canonical class and classification +//! +//! * `deg(t)`: compact in-degree, with edge multiplicity and root +//! occurrences; head positions are the root occurrences and the edges +//! that do not continue a telescope (an App as the function of +//! an App, a Lam as the body of a Lam, an All as the body of an All); +//! `occ(t)`: expanded occurrences; `size(t)`: unshared standalone length. +//! * The canonical result is the minimum over tables whose entries all have +//! in-degree >= 2. In-degree-1 terms are left out by an exchange that never +//! increases the length (store the single parent instead, or turn extra +//! writes of a stored parent into Shares), so this class contains a +//! global minimum; ties can also store an in-degree-1 term, which this +//! definition excludes. +//! * CERTAIN-EXCLUDED when `(occ-1)*size < occ*w` (in no minimum). +//! * Candidates: in-degree >= 2 and not certain-excluded. +//! * CERTAIN-STORED (in every minimum of the restricted class) when the gain +//! bound `g >= theta`, with `d`, `h` the visible counts and lower bounds +//! computed bottom-up pricing every candidate child at `min(w, .)`, every +//! other child at its inline bound and a header of at least 1 byte: +//! non-telescope `g = (d-1)*inl - d*w`; telescope with `h >= 1` +//! `g = (d-1)*b + (h-1) - d*w`; telescope with `h = 0` +//! `g = (d-1)*b - tag4(spine length) - d*w`. +//! Visible counts `(d, h)` for a maybe-stored set `M` (the candidates): +//! one per root occurrence plus, per edge from `z` (head edges only for +//! `h`), 1 if `z` is in `M`, else `min(d(z), 2^20)`. +//! Threshold: with `theta_max = 1 + tag0_step_bound(#candidates)` (2 below +//! 4311826560 candidates), `theta = 1` when `tag0(#candidates) = tag0(#terms +//! with g >= theta_max)`, else `theta = theta_max`. +//! * UNCERTAIN: the other candidates; LOW-DEGREE: the other terms. +//! +//! Certain-stored terms cost exactly `w` wherever they occur (`g >= 1` +//! forces their merged payload bound `>= w`), so costs above them are +//! evaluated with them as `w`-byte leaves that end telescopes. +//! +//! # Search +//! +//! Uncertain terms joined by a DAG path avoiding certain-stored terms form +//! a component; costs are sums of per-component functions. Each component +//! search returns, per chosen count, its best change within `slack = +//! tag0(|certain-stored| + |uncertain|) - tag0(|certain-stored|)` of its +//! optimum. The table-count prefix is the only coupling: when the combined +//! choice reaches a TagN bracket of 128 or more entries, a knapsack over +//! components checks the lower brackets. +//! +//! The component search is the reclassifying branch and bound of the Lean +//! implementation. At each node it (1) recomputes the bounds and visible +//! counts over the component's area with the members decided "not stored" +//! removed from `M`, and forces +//! "stored" every undecided member with `g >= theta`; (2) bounds the node by +//! the cost with every undecided member available and its entry free, +//! pruning only when strictly above the best by more than `slack`; (3) +//! splits the undecided members into groups joined by DAG paths through +//! non-opaque terms (a decided-stored member is opaque when its `inl` (or, +//! for a telescope, merged) bound is at least `w`; groups below a stored +//! non-opaque member are joined), solving groups by memoized sub-searches +//! keyed by the group and the decisions that reach it; (4) branches on the +//! undecided member with the largest `|g|` (then the smaller ID), "stored" +//! first when `g > 0`. Per-count tables of groups combine by convolution. +//! The plain subset enumeration is kept as a test oracle +//! (`ExactSharingLimits::uniform_subset_search`); it is not on the compiler +//! path, and the Lean optimality theorems assume it is off. +//! +//! # Tie-break +//! +//! Among minimum-length sets the least in the order "the smaller structural +//! ID of the symmetric difference is not stored". It decomposes over +//! components and through the knapsack. +//! +//! # Numeric domain +//! +//! Lean uses unbounded `Nat`. Here every such quantity is a `u128`; if any +//! bound or cost saturates, the call fails with +//! [`FormatBound::LengthOverflow`] instead of guessing. The exclusion test is +//! evaluated exactly even when an occurrence count saturates. + +use std::sync::Arc; + +use rustc_hash::{FxHashMap, FxHashSet}; + +use super::cost::{Len, exprs_len_with, tag0_len, tag4_len}; +use super::dag::{Node, SharingDag, TermId, ix}; +use super::dict::{ + DependentPlan, Evaluation, PlanShares, ReadEdges, UniformIndex, all_costs, + build_dependent, decide_dependent, +}; +use super::prof::{self, Phase}; +use super::{ + ExactSharingLimits, ExactSharingStats, FormatBound, Meter, SharingError, + constant_fixed_len, constant_info_root_exprs, rebuild_constant_info, +}; +use crate::constant::Constant; +use crate::expr::Expr; +use crate::tag::TagN; + +fn internal(msg: impl Into) -> SharingError { + SharingError::Internal(msg.into()) +} + +fn overflow() -> SharingError { + SharingError::FormatBound(FormatBound::LengthOverflow) +} + +fn len64(n: usize) -> u64 { + u64::try_from(n).unwrap_or(u64::MAX) +} + +fn tid(i: usize) -> TermId { + TermId::try_from(i).unwrap_or(TermId::MAX) +} + +fn u(x: u64) -> u128 { + u128::from(x) +} + +/// Classification of a term for the uniform-width search. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum UniformClass { + /// Not certain-excluded, but in-degree below 2: never searched. + LowDegree, + CertainExcluded, + CertainStored, + Uncertain, +} + +/// Uniform-width result: the encoding, its model and real lengths, and the +/// classification and search statistics. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct UniformSharingResult { + /// Rewritten roots, in input order. + pub roots: Vec>, + /// The table, in the pinned order. + pub sharing: Vec>, + /// Term ID of each table entry, in the pinned order. + pub table_terms: Vec, + /// Exact uniform-model variable length (count, entries, roots). + pub model_len: u64, + /// Real serialized variable length of the same output. + pub variable_len: u64, + /// Unshared variable length (`None` if it exceeds `u64`). + pub unshared_len: Option, + /// The stored set, ascending. + pub stored: Vec, + pub certain_stored: Vec, + pub certain_excluded: Vec, + pub uncertain: Vec, + pub low_degree: Vec, + /// Components of the uncertain terms (each ascending, by first member). + pub components: Vec>, + /// Component subsets evaluated. + pub states_visited: u64, + /// Whether the table-count knapsack chose a lower TagN bracket. + pub lower_bracket: bool, + pub stats: ExactSharingStats, +} + +// --------------------------------------------------------------------------- +// Graph facts +// --------------------------------------------------------------------------- + +fn spine_next(node: &Node) -> TermId { + match node { + Node::App(f, _) => *f, + Node::Lam(_, _, b) | Node::All(_, _, _, b) => *b, + _ => 0, + } +} + +fn side_child(node: &Node) -> TermId { + match node { + Node::App(_, a) => *a, + Node::Lam(_, ty, _) | Node::All(_, _, ty, _) => *ty, + _ => 0, + } +} + +fn side_extra(node: &Node) -> u128 { + match node { + Node::App(..) => 0, + _ => 1, + } +} + +/// Bytes a non-telescope node writes itself, excluding its children. +fn own_bytes(node: &Node) -> Result { + match node.family() { + Some(_) => Ok(0), + None => node.own_len().exact().map(u).ok_or_else(overflow), + } +} + +/// Whether the edge from `parent` to its `i`-th child continues the +/// parent's telescope. +fn continuation_edge(parent: &Node, i: usize, child: &Node) -> bool { + match (parent, child) { + (Node::App(..), Node::App(..)) => i == 0, + (Node::Lam(..), Node::Lam(..)) | (Node::All(..), Node::All(..)) => i == 1, + _ => false, + } +} + +pub(crate) struct Facts { + pub(crate) deg: Vec, + occ: Vec, + /// Distinct parents of each term. + pub(crate) parents: Vec>, +} + +pub(crate) fn graph_facts(dag: &SharingDag) -> Facts { + let nodes = dag.nodes(); + let n = nodes.len(); + let mut deg = vec![0u64; n]; + let mut parents: Vec> = vec![Vec::new(); n]; + for &r in dag.roots() { + deg[ix(r)] += 1; + } + for (t, node) in nodes.iter().enumerate() { + let kids = node.children(); + for &c in kids.as_slice() { + deg[ix(c)] += 1; + if !parents[ix(c)].contains(&tid(t)) { + parents[ix(c)].push(tid(t)); + } + } + } + let mut occ = vec![0u128; n]; + for &r in dag.roots() { + occ[ix(r)] = occ[ix(r)].saturating_add(1); + } + for t in (0..n).rev() { + let o = occ[t]; + if o == 0 { + continue; + } + for &c in nodes[t].children().as_slice() { + occ[ix(c)] = occ[ix(c)].saturating_add(o); + } + } + Facts { deg, occ, parents } +} + +/// Spine lengths and natural tails, with spines ending at `stop` terms. +fn spine_tables(nodes: &[Node], stop: &[bool]) -> (Vec, Vec) { + let n = nodes.len(); + let mut len = vec![0u64; n]; + let mut tail: Vec = vec![0; n]; + for (t, node) in nodes.iter().enumerate() { + if node.family().is_some() { + let nxt = spine_next(node); + if nodes[ix(nxt)].family() == node.family() && !stop[ix(nxt)] { + len[t] = len[ix(nxt)] + 1; + tail[t] = tail[ix(nxt)]; + } else { + len[t] = 1; + tail[t] = nxt; + } + } + } + (len, tail) +} + +// --------------------------------------------------------------------------- +// Truncated evaluation +// --------------------------------------------------------------------------- + +#[derive(Clone, Copy, Debug, Default)] +struct UVal { + cost: u128, + inl: u128, + sides: u128, + below: Option, +} + +/// Evaluation tables with `opaq` terms as `w`-byte leaves ending spines. +struct UPrep<'d> { + nodes: &'d [Node], + w: u128, + opaq: Vec, + t_len: Vec, + t_tail: Vec, + base: Vec, +} + +impl<'d> UPrep<'d> { + fn new( + nodes: &'d [Node], + w: u128, + opaq: Vec, + ) -> Result { + let (t_len, t_tail) = spine_tables(nodes, &opaq); + let mut up = UPrep { nodes, w, opaq, t_len, t_tail, base: Vec::new() }; + let mut base: Vec = Vec::with_capacity(nodes.len()); + for t in 0..nodes.len() { + let (v, _) = up.node(&|c| base[ix(c)], &|_| false, tid(t))?; + base.push(v); + } + up.base = base; + Ok(up) + } + + /// One term's value given its children's values; also the number of + /// available spine descendants visited. + fn node( + &self, + get: &dyn Fn(TermId) -> UVal, + avail: &dyn Fn(TermId) -> bool, + t: TermId, + ) -> Result<(UVal, u64), SharingError> { + let node = &self.nodes[ix(t)]; + let mut steps = 0u64; + let mut v = UVal::default(); + if node.family().is_none() { + let mut inl = own_bytes(node)?; + for &c in node.children().as_slice() { + inl = inl.saturating_add(get(c).cost); + } + v.inl = inl; + } else { + let nxt = spine_next(node); + let same = + self.nodes[ix(nxt)].family() == node.family() && !self.opaq[ix(nxt)]; + let s = side_extra(node) + .saturating_add(get(side_child(node)).cost) + .saturating_add(if same { get(nxt).sides } else { 0 }); + let bl = if same { + if avail(nxt) { Some(nxt) } else { get(nxt).below } + } else { + None + }; + let l = self.t_len[ix(t)]; + let mut best = u(tag4_len(l)) + .saturating_add(s) + .saturating_add(get(self.t_tail[ix(t)]).cost); + let mut cur = bl; + for _ in 0..l { + let Some(x) = cur else { break }; + steps += 1; + let gx = get(x); + let cand = u(tag4_len(l - self.t_len[ix(x)])) + .saturating_add(s - gx.sides) + .saturating_add(self.w); + best = best.min(cand); + cur = gx.below; + } + v.inl = best; + v.sides = s; + v.below = bl; + } + v.cost = if self.opaq[ix(t)] { + self.w + } else if avail(t) { + self.w.min(v.inl) + } else { + v.inl + }; + if v.inl == u128::MAX || v.sides == u128::MAX || v.cost == u128::MAX { + return Err(overflow()); + } + Ok((v, steps)) + } +} + +// --------------------------------------------------------------------------- +// Classification +// --------------------------------------------------------------------------- + +/// `(occ-1)*size < occ*w`, exactly, for `occ >= 1` (a saturated `occ` +/// stands for some value at least `u128::MAX`). +fn certainly_excluded(occ: u128, size: u128, w: u128) -> bool { + if size <= w { + return true; + } + match occ.checked_mul(size - w) { + Some(x) => x < size, + None => false, + } +} + +/// Lower bounds of the certain-stored test (Lean `UBounds`): `inl`, bytes +/// of a term written inline at a head position; `merged`, bytes of a +/// telescope node inside a telescope running through it (no header); +/// `head_lb`/`cont_lb`, the same at a head/continuation position when the +/// term may be a Share. +#[derive(Clone)] +pub(crate) struct Bounds { + inl: Vec, + merged: Vec, + head_lb: Vec, + cont_lb: Vec, +} + +/// One step of the bounds (Lean `boundsStep`): `[inl, merged, head_lb, +/// cont_lb]` of `t` from its children's head/continuation bounds. +fn bound_step( + nodes: &[Node], + t: TermId, + w: u128, + maybe: bool, + head: &dyn Fn(TermId) -> u128, + cont: &dyn Fn(TermId) -> u128, +) -> Result<[u128; 4], SharingError> { + let node = &nodes[ix(t)]; + let (i, m) = if node.family().is_none() { + let mut i = own_bytes(node)?; + for &c in node.children().as_slice() { + i = i.saturating_add(head(c)); + } + (i, i) + } else { + let nxt = spine_next(node); + let rest = if nodes[ix(nxt)].family() == node.family() { + cont(nxt) + } else { + head(nxt) + }; + let m = side_extra(node) + .saturating_add(head(side_child(node))) + .saturating_add(rest); + (m.saturating_add(1), m) + }; + if i == u128::MAX { + return Err(overflow()); + } + let (hl, cl) = if maybe { (w.min(i), w.min(m)) } else { (i, m) }; + Ok([i, m, hl, cl]) +} + +fn uniform_bounds( + nodes: &[Node], + w: u128, + maybe: &[bool], +) -> Result { + let n = nodes.len(); + let mut b = Bounds { + inl: vec![0; n], + merged: vec![0; n], + head_lb: vec![0; n], + cont_lb: vec![0; n], + }; + for (t, &mb) in maybe[..n].iter().enumerate() { + let v = { + let (hl, cl) = (&b.head_lb, &b.cont_lb); + bound_step(nodes, tid(t), w, mb, &|c| hl[ix(c)], &|c| cl[ix(c)])? + }; + b.inl[t] = v[0]; + b.merged[t] = v[1]; + b.head_lb[t] = v[2]; + b.cont_lb[t] = v[3]; + } + Ok(b) +} + +/// Cap of the visible counts where they are passed on. +const VISIBLE_CAP: u64 = 1 << 20; + +/// Lean `propagateCounts`: per term, root occurrences plus, over the edges +/// from each parent `y` (descending IDs), `weight(y, count of y)`; the second +/// array counts only head (non-continuation) edges. +fn propagate_counts( + dag: &SharingDag, + weight: &dyn Fn(usize, u64) -> u64, +) -> (Vec, Vec) { + let nodes = dag.nodes(); + let n = nodes.len(); + let mut all = vec![0u64; n]; + let mut head = vec![0u64; n]; + for &r in dag.roots() { + all[ix(r)] += 1; + head[ix(r)] += 1; + } + for y in (0..n).rev() { + let wy = weight(y, all[y]); + let node = &nodes[y]; + for (i, &c) in node.children().as_slice().iter().enumerate() { + all[ix(c)] = all[ix(c)].saturating_add(wy); + if !continuation_edge(node, i, &nodes[ix(c)]) { + head[ix(c)] = head[ix(c)].saturating_add(wy); + } + } + } + (all, head) +} + +/// Visible counts: lower bounds `(d, h)` on the inline occurrences (all / +/// at head positions) of each term in every encoding of a set inside +/// `maybe` that does not store it. +fn visible_counts(dag: &SharingDag, maybe: &[bool]) -> (Vec, Vec) { + propagate_counts(dag, &|y, c| if maybe[y] { 1 } else { c.min(VISIBLE_CAP) }) +} + +fn to_i(x: u128) -> Result { + i128::try_from(x).map_err(|_e| overflow()) +} + +/// The certain-stored gain bound (Lean `storedGainC`) with `d` inline +/// occurrences in all, `h` of them at head positions, and the term's bounds +/// `inl`/`merged`. +fn stored_gain( + node: &Node, + d: u64, + h: u64, + spine_len: u64, + inl: u128, + merged: u128, + w: u128, +) -> Result { + let d = i128::from(d); + let dw = d.checked_mul(to_i(w)?); + let g = if node.family().is_none() { + (d - 1).checked_mul(to_i(inl)?).zip(dw).and_then(|(x, y)| x.checked_sub(y)) + } else if h >= 1 { + (d - 1) + .checked_mul(to_i(merged)?) + .and_then(|x| x.checked_add(i128::from(h) - 1)) + .zip(dw) + .and_then(|(x, y)| x.checked_sub(y)) + } else { + (d - 1) + .checked_mul(to_i(merged)?) + .and_then(|x| x.checked_sub(i128::from(tag4_len(spine_len)))) + .zip(dw) + .and_then(|(x, y)| x.checked_sub(y)) + }; + g.ok_or_else(overflow) +} + +// --------------------------------------------------------------------------- +// Components +// --------------------------------------------------------------------------- + +fn uf_find(parent: &[usize], x: usize) -> usize { + let mut cur = x; + while parent[cur] != cur { + cur = parent[cur]; + } + cur +} + +/// Components of the uncertain terms, joined by DAG paths that avoid +/// certain-stored terms; each sorted, sorted by their smallest term. +fn uncertain_components( + dag: &SharingDag, + cls: &[UniformClass], +) -> Vec> { + let nodes = dag.nodes(); + let n = nodes.len(); + let mut uf: Vec = (0..n).collect(); + let mut reps: Vec> = vec![Vec::new(); n]; + for t in 0..n { + if cls[t] == UniformClass::CertainStored { + continue; + } + let mut rs: Vec = Vec::new(); + for &c in nodes[t].children().as_slice() { + for &r in &reps[ix(c)] { + let fr = uf_find(&uf, r); + if !rs.contains(&fr) { + rs.push(fr); + } + } + } + if cls[t] == UniformClass::Uncertain { + for &r in &rs { + let a = uf_find(&uf, t); + let b = uf_find(&uf, r); + if a != b { + if a < b { + uf[b] = a; + } else { + uf[a] = b; + } + } + } + reps[t] = vec![t]; + } else { + reps[t] = rs; + } + } + let mut groups: std::collections::BTreeMap> = + std::collections::BTreeMap::new(); + for (t, c) in cls.iter().enumerate() { + if *c == UniformClass::Uncertain { + groups.entry(uf_find(&uf, t)).or_default().push(tid(t)); + } + } + let mut comps: Vec> = groups.into_values().collect(); + comps.sort_by_key(|c| c[0]); + comps +} + +/// Members and their ancestors, not continuing above an opaque term. +fn component_area( + up: &UPrep<'_>, + facts: &Facts, + members: &[TermId], +) -> Vec { + let mut seen: FxHashSet = members.iter().copied().collect(); + let mut stack: Vec = members.to_vec(); + while let Some(t) = stack.pop() { + if up.opaq[ix(t)] { + continue; + } + for &q in &facts.parents[ix(t)] { + if seen.insert(q) { + stack.push(q); + } + } + } + let mut out: Vec = seen.into_iter().collect(); + out.sort_unstable(); + out +} + +/// `a` precedes `b` (both ascending) when the smallest term of their +/// symmetric difference is in `b`, i.e. `a` leaves it out. +pub(crate) fn set_prec(a: &[TermId], b: &[TermId]) -> bool { + let (mut x, mut y) = (0, 0); + loop { + match (a.get(x), b.get(y)) { + (Some(p), Some(q)) => { + if p == q { + x += 1; + y += 1; + } else { + return q < p; + } + }, + (Some(_) | None, None) => return false, + (None, Some(_)) => return true, + } + } +} + +fn merge_sorted(a: &[TermId], b: &[TermId]) -> Vec { + let mut out: Vec = a.iter().chain(b).copied().collect(); + out.sort_unstable(); + out +} + +type Choice = (i128, Vec); + +fn better(delta: i128, set: &[TermId], cur: Option<&Choice>) -> bool { + match cur { + None => true, + Some((d, s)) => delta < *d || (delta == *d && set_prec(set, s)), + } +} + +struct CompCtx<'a, 'd> { + up: &'a UPrep<'d>, + members: Vec, + area: Vec, + root_mult: Vec<(TermId, u128)>, + stored_in: Vec, + phi0: u128, + slack: i128, + /// Scratch: values of area terms, valid where `stamp == epoch`. + vals: Vec, + stamp: Vec, + epoch: u32, + avail: Vec, +} + +impl CompCtx<'_, '_> { + /// Cost of the component's parts with `avail` and `chosen` (entries of + /// undecided members omitted), and the evaluation work. + fn phi(&mut self, chosen: &[TermId]) -> Result<(u128, u64), SharingError> { + if self.epoch == u32::MAX { + self.stamp.fill(0); + self.epoch = 0; + } + self.epoch += 1; + let ep = self.epoch; + let mut work = 0u64; + for k in 0..self.area.len() { + let t = self.area[k]; + let (v, s) = { + let vals = &self.vals; + let stamp = &self.stamp; + let base = &self.up.base; + let avail = &self.avail; + let get = |c: TermId| { + if stamp[ix(c)] == ep { vals[ix(c)] } else { base[ix(c)] } + }; + let av = |c: TermId| avail[ix(c)]; + self.up.node(&get, &av, t)? + }; + self.vals[ix(t)] = v; + self.stamp[ix(t)] = ep; + work = work.saturating_add(1 + s); + } + let get = |c: TermId| { + if self.stamp[ix(c)] == ep { + self.vals[ix(c)] + } else { + self.up.base[ix(c)] + } + }; + let mut total = 0u128; + for &(r, m) in &self.root_mult { + total = total.saturating_add(m.saturating_mul(get(r).cost)); + } + for &c in &self.stored_in { + total = total.saturating_add(get(c).inl); + } + for &x in chosen { + total = total.saturating_add(get(x).inl); + } + if total == u128::MAX { + return Err(overflow()); + } + Ok((total, work)) + } + + /// Depth-first branch and bound over the members (ascending), "not + /// stored" first. Returns the best choice and the best per set size. + fn search( + &mut self, + meter: &mut Meter<'_>, + ) -> Result<(Choice, Vec>), SharingError> { + let mut best: Option = None; + let mut by_size: Vec> = Vec::new(); + // Frames: (next member index, chosen so far). + let mut stack: Vec<(usize, Vec)> = vec![(0, Vec::new())]; + while let Some((i, chosen)) = stack.pop() { + meter.state()?; + for (k, &m) in self.members.iter().enumerate() { + self.avail[ix(m)] = k >= i || chosen.contains(&m); + } + let (phi, work) = self.phi(&chosen)?; + meter.work(work)?; + let delta = to_i(phi)? - to_i(self.phi0)?; + if i >= self.members.len() { + if better(delta, &chosen, best.as_ref()) { + best = Some((delta, chosen.clone())); + } + let k = chosen.len(); + if by_size.len() <= k { + by_size.resize(k + 1, None); + } + if better(delta, &chosen, by_size[k].as_ref()) { + by_size[k] = Some((delta, chosen)); + } + continue; + } + if let Some((b, _)) = &best + && delta > b + self.slack + { + continue; + } + let t = self.members[i]; + let mut with = chosen.clone(); + with.push(t); + stack.push((i + 1, with)); + stack.push((i + 1, chosen)); + } + for &m in &self.members { + self.avail[ix(m)] = false; + } + let best = + best.ok_or_else(|| internal("component search found no choice"))?; + Ok((best, by_size)) + } +} + +// --------------------------------------------------------------------------- +// Reclassifying branch and bound with splitting (Lean `SCtx`) +// --------------------------------------------------------------------------- + +/// Best `(delta, set)` per chosen count (index = set size). +type CTable = Vec>; + +fn table_best(tb: &CTable) -> Option { + tb.iter().flatten().map(|(d, _)| *d).min() +} + +fn table_add(tb: &mut CTable, e: Choice) { + let k = e.1.len(); + if tb.len() <= k { + tb.resize(k + 1, None); + } + if better(e.0, &e.1, tb[k].as_ref()) { + tb[k] = Some(e); + } +} + +fn table_trim(tb: CTable, slack: i128) -> CTable { + match table_best(&tb) { + None => tb, + Some(b) => { + tb.into_iter().map(|o| o.filter(|(d, _)| *d <= b + slack)).collect() + }, + } +} + +fn table_conv(a: &CTable, b: &CTable) -> CTable { + let mut out: CTable = Vec::new(); + for (da, sa) in a.iter().flatten() { + for (db, sb) in b.iter().flatten() { + table_add(&mut out, (da + db, merge_sorted(sa, sb))); + } + } + out +} + +// --------------------------------------------------------------------------- +// Table-count knapsack +// --------------------------------------------------------------------------- + +/// "No element": the first difference of two equal sets. +const NO_DIFF: u32 = u32::MAX; + +/// The least element of the symmetric difference of two ascending sets +/// (`NO_DIFF` if they are equal): at the first position where the lists +/// differ, the smaller element is in one set only. +fn first_diff(a: &[TermId], b: &[TermId]) -> u32 { + let (mut i, mut j) = (0, 0); + loop { + match (a.get(i), b.get(j)) { + (Some(x), Some(y)) if x == y => { + i += 1; + j += 1; + }, + (Some(x), Some(y)) => return (*x).min(*y), + (Some(x), None) => return *x, + (None, Some(y)) => return *y, + (None, None) => return NO_DIFF, + } + } +} + +/// One layer of [`Knapsack`]: per cell (total count) the least delta, the +/// rank of the cell's set among the layer's sets (`set_prec` order), and a +/// sparse table over the first differences of rank-adjacent sets. +struct KnapsackLayer { + delta: Vec>, + rank: Vec, + /// `sparse[i][r]`: the least first difference among the rank-adjacent + /// pairs `r .. r + 2^i`. + sparse: Vec>, +} + +impl KnapsackLayer { + /// The least element of the symmetric difference of the sets of two + /// distinct cells. For sets in ascending `set_prec` order (lexicographic + /// on their indicator vectors), it is the least first difference of the + /// rank-adjacent pairs between them, as for sorted strings. + fn first_diff(&self, a: usize, b: usize) -> u32 { + let (ra, rb) = (self.rank[a] as usize, self.rank[b] as usize); + let (lo, hi) = if ra < rb { (ra, rb) } else { (rb, ra) }; + let level = (hi - lo).ilog2() as usize; + self.sparse[level][lo].min(self.sparse[level][hi - (1 << level)]) + } +} + +/// The table-count knapsack of [`optimize_uniform`] for total counts +/// `<= cap`: after the components `0..j`, every cell `c` holds the least +/// `(delta, set)` under [`better`] (delta, then `set_prec`) over the choices +/// of one entry per component table with counts summing to `c`. The sets of +/// distinct choices differ (the components are disjoint), so `better` is a +/// strict total order on them, and adding the same entry of a later +/// component preserves it; each cell is therefore the least combination of +/// the cells of the previous layer with the entries of the next table. +/// +/// The sets themselves are not built. Comparing `S_a + X` with `S_b + Y` +/// (`S` from earlier components, `X`, `Y` entries of the next one) needs the +/// least element of the symmetric difference: the smaller of that of `S_a, +/// S_b` (from the previous layer's ranks) and that of `X, Y`; the set +/// without it precedes. `back` keeps the entry each cell took, to rebuild +/// the chosen set. +struct Knapsack { + last: KnapsackLayer, + /// Per component, per cell: the count of the entry taken (`u32::MAX` + /// where the cell is empty). + back: Vec>, +} + +impl Knapsack { + fn run(tables: &[&CTable], cap: usize) -> Knapsack { + let mut layer = KnapsackLayer { + delta: vec![None; cap + 1], + rank: vec![0; cap + 1], + sparse: Vec::new(), + }; + layer.delta[0] = Some(0); + let mut back: Vec> = Vec::with_capacity(tables.len()); + for tab in tables { + let prev = &layer; + // Whether choice `(a, ka)` precedes `(b, kb)` (distinct choices). + let prec = |(a, ka): (usize, usize), (b, kb): (usize, usize)| { + let old = if a == b { NO_DIFF } else { prev.first_diff(a, b) }; + let (xa, xb) = (&tab[ka], &tab[kb]); + let new = match (xa, xb) { + (Some((_, xa)), Some((_, xb))) if ka != kb => first_diff(xa, xb), + _ => NO_DIFF, + }; + if old < new { + prev.rank[a] < prev.rank[b] + } else { + xa.as_ref().is_none_or(|(_, xa)| xa.binary_search(&new).is_err()) + } + }; + let mut delta: Vec> = vec![None; cap + 1]; + let mut choice: Vec<(usize, usize)> = vec![(0, 0); cap + 1]; + let mut took: Vec = vec![u32::MAX; cap + 1]; + for c in 0..=cap { + let mut best: Option<(i128, usize, usize)> = None; + for (k, entry) in tab.iter().enumerate().take(c + 1) { + let Some((dk, _)) = entry else { continue }; + let a = c - k; + let Some(da) = prev.delta[a] else { continue }; + let d = da + dk; + if best.is_none_or(|(bd, ba, bk)| { + d < bd || (d == bd && prec((a, k), (ba, bk))) + }) { + best = Some((d, a, k)); + } + } + if let Some((d, a, k)) = best { + delta[c] = Some(d); + choice[c] = (a, k); + took[c] = u32::try_from(k).unwrap_or(u32::MAX); + } + } + // Rank the new sets and record the first differences of neighbours. + let mut order: Vec = + (0..=cap).filter(|&c| delta[c].is_some()).collect(); + order.sort_by(|&u, &v| { + if u == v { + std::cmp::Ordering::Equal + } else if prec(choice[u], choice[v]) { + std::cmp::Ordering::Less + } else { + std::cmp::Ordering::Greater + } + }); + let mut rank = vec![0u32; cap + 1]; + for (r, &c) in order.iter().enumerate() { + rank[c] = u32::try_from(r).unwrap_or(u32::MAX); + } + let adjacent: Vec = order + .windows(2) + .map(|w| { + let ((a, ka), (b, kb)) = (choice[w[0]], choice[w[1]]); + let old = if a == b { NO_DIFF } else { prev.first_diff(a, b) }; + let new = match (&tab[ka], &tab[kb]) { + (Some((_, xa)), Some((_, xb))) if ka != kb => first_diff(xa, xb), + _ => NO_DIFF, + }; + old.min(new) + }) + .collect(); + let mut sparse = vec![adjacent]; + let mut width = 1; + loop { + let below = &sparse[sparse.len() - 1]; + if below.len() <= width { + break; + } + let next: Vec = (0..below.len() - width) + .map(|r| below[r].min(below[r + width])) + .collect(); + sparse.push(next); + width *= 2; + } + layer = KnapsackLayer { delta, rank, sparse }; + back.push(took); + } + Knapsack { last: layer, back } + } + + /// The set of cell `c` of the last layer, ascending. + fn set(&self, tables: &[&CTable], mut c: usize) -> Vec { + let mut out: Vec = Vec::new(); + for (tab, took) in tables.iter().zip(&self.back).rev() { + let k = usize::try_from(took[c]).unwrap_or(0); + if let Some(Some((_, s))) = tab.get(k) { + out.extend_from_slice(s); + } + c -= k; + } + out.sort_unstable(); + out + } +} + +/// The knapsack as a plain dynamic program over explicit sets (the +/// reference of [`Knapsack`]). +#[cfg(test)] +fn knapsack_reference(tables: &[&CTable], cap: usize) -> Vec> { + let mut dp: Vec> = vec![None; cap + 1]; + dp[0] = Some((0, Vec::new())); + for by_size in tables { + let mut ndp: Vec> = vec![None; cap + 1]; + for c in 0..dp.len() { + let Some((d, s)) = &dp[c] else { continue }; + for (k, opt) in by_size.iter().enumerate() { + let Some((dk, sk)) = opt else { continue }; + if c + k > cap { + continue; + } + let cand = (d + dk, merge_sorted(s, sk)); + if better(cand.0, &cand.1, ndp[c + k].as_ref()) { + ndp[c + k] = Some(cand); + } + } + } + dp = ndp; + } + dp +} + +/// The undecided member to branch on: the largest `|gain|`, then the +/// smaller ID. +fn pick_branch(gains: &[(TermId, i128)]) -> Option<(TermId, i128)> { + let mut acc: Option<(TermId, i128)> = None; + for &(t, g) in gains { + acc = match acc { + None => Some((t, g)), + Some((a, ga)) => { + if g.unsigned_abs() > ga.unsigned_abs() + || (g.unsigned_abs() == ga.unsigned_abs() && t < a) + { + Some((t, g)) + } else { + acc + } + }, + }; + } + acc +} + +/// Area position of no term (`SCtx::pos`). +const NO_POS: u32 = u32::MAX; + +/// Bounds of the area under a maybe-stored predicate, over the root-level +/// bounds (Lean `SCtx.rebound`): `vals[j]` for the area term at position +/// `j`, the root-level bounds elsewhere. +struct Overlay<'b> { + base: &'b Bounds, + pos: &'b [u32], + vals: Vec<[u128; 4]>, +} + +impl Overlay<'_> { + fn get(&self, t: TermId) -> [u128; 4] { + match self.pos[ix(t)] { + NO_POS => { + let k = ix(t); + [ + self.base.inl[k], + self.base.merged[k], + self.base.head_lb[k], + self.base.cont_lb[k], + ] + }, + j => self.vals[j as usize], + } + } +} + +/// The search of one component (Lean `SCtx`). Sets of decided members are +/// passed as sorted term lists and, inside one call, as flags over the area +/// positions (every member is in the area; a term outside the area is in +/// none of them). +struct SCtx<'a, 'd> { + up: &'a UPrep<'d>, + facts: &'a Facts, + cand: &'a [bool], + b0: &'a Bounds, + vis0: &'a (Vec, Vec), + spine_len: &'a [u64], + dag_size: u64, + members: Vec, + /// Member index of each area position (`NO_POS` for other terms). + member_of: Vec, + area: Vec, + /// Area position of every term of the DAG (`NO_POS` outside the area). + pos: &'a [u32], + /// Per area node: `(parent, its area position, edges, head edges)` per + /// distinct parent. + in_edges: Vec>, + root_occ: Vec, + root_mult: Vec<(TermId, u128)>, + stored_in: Vec, + slack: i128, + theta: i128, + memo: FxHashMap, CTable>, + memo_hits: u64, + /// Scratch of `phi`: the value of each area term. + vals: Vec, +} + +impl SCtx<'_, '_> { + fn at(&self, t: TermId) -> Option { + match self.pos[ix(t)] { + NO_POS => None, + j => Some(j as usize), + } + } + + /// Flags over the area positions of the terms `ts`. + fn flags(&self, ts: &[TermId]) -> Vec { + let mut f = vec![false; self.area.len()]; + for &t in ts { + if let Some(j) = self.at(t) { + f[j] = true; + } + } + f + } + + /// The component cost with the area terms flagged in `avail` available + /// and the entries of `stored`, and the evaluation work (Lean + /// `SCtx.phi`). Every area term is evaluated, children first; other terms + /// keep their root-level values. + fn phi( + &mut self, + avail: &[bool], + stored: &[TermId], + ) -> Result<(u128, u64), SharingError> { + let mut work = 0u64; + for k in 0..self.area.len() { + let t = self.area[k]; + let (v, s) = { + let (vals, base, pos) = (&self.vals, &self.up.base, self.pos); + let get = |c: TermId| match pos[ix(c)] { + NO_POS => base[ix(c)], + j => vals[j as usize], + }; + let av = |c: TermId| match pos[ix(c)] { + NO_POS => false, + j => avail[j as usize], + }; + self.up.node(&get, &av, t)? + }; + self.vals[k] = v; + work = work.saturating_add(1 + s); + } + let get = |c: TermId| match self.pos[ix(c)] { + NO_POS => self.up.base[ix(c)], + j => self.vals[j as usize], + }; + let mut total = 0u128; + for &(r, m) in &self.root_mult { + total = total.saturating_add(m.saturating_mul(get(r).cost)); + } + for &c in self.stored_in.iter().chain(stored) { + total = total.saturating_add(get(c).inl); + } + if total == u128::MAX { + return Err(overflow()); + } + Ok((total, work)) + } + + fn charge(meter: &mut Meter<'_>, work: u64) -> Result<(), SharingError> { + meter.state()?; + meter.work(work) + } + + /// Whether `t` may be stored: a candidate not decided "not stored". + fn maybe(&self, out: &[bool], t: TermId) -> bool { + self.cand[ix(t)] && self.at(t).is_none_or(|j| !out[j]) + } + + fn rebound(&self, out: &[bool]) -> Result, SharingError> { + let mut ov = Overlay { + base: self.b0, + pos: self.pos, + vals: Vec::with_capacity(self.area.len()), + }; + for (j, &t) in self.area.iter().enumerate() { + let v = { + let ovr = &ov; + bound_step( + self.up.nodes, + t, + self.up.w, + self.cand[ix(t)] && !out[j], + &|c| ovr.get(c)[2], + &|c| ovr.get(c)[3], + )? + }; + ov.vals.push(v); + } + Ok(ov) + } + + /// Visible counts of the area terms (by area position). + fn revisible(&self, out: &[bool]) -> Vec<(u64, u64)> { + let mut vis: Vec<(u64, u64)> = vec![(0, 0); self.area.len()]; + for j in (0..self.area.len()).rev() { + let r = self.root_occ[j]; + let (mut d, mut h) = (r, r); + for &(q, qj, ma, mh) in &self.in_edges[j] { + let wq = if self.maybe(out, q) { + 1 + } else { + match qj { + NO_POS => self.vis0.0[ix(q)], + qj => vis[qj as usize].0, + } + .min(VISIBLE_CAP) + }; + d = d.saturating_add(ma.saturating_mul(wq)); + h = h.saturating_add(mh.saturating_mul(wq)); + } + vis[j] = (d, h); + } + vis + } + + fn opaque_under(&self, b: &Overlay<'_>, t: TermId) -> bool { + let v = b.get(t); + if self.up.nodes[ix(t)].family().is_none() { + v[0] >= self.up.w + } else { + v[1] >= self.up.w + } + } + + /// Groups of the undecided members (Lean `SCtx.groups`); `opq` and + /// `avail_fixed` are flags over the area positions. + fn groups( + &self, + opq: &[bool], + avail_fixed: &[bool], + und: &[TermId], + ) -> Vec> { + let und_f = self.flags(und); + let mut uf: Vec = (0..self.members.len()).collect(); + let mut reps: Vec> = vec![Vec::new(); self.area.len()]; + let union = |uf: &mut Vec, x: usize, y: usize| { + let a = uf_find(uf, x); + let b = uf_find(uf, y); + if a != b { + if a < b { + uf[b] = a; + } else { + uf[a] = b; + } + } + }; + let member = |j: usize| match self.member_of[j] { + NO_POS => 0, + m => m as usize, + }; + for j in 0..self.area.len() { + let y = self.area[j]; + if opq[j] { + continue; + } + let mut rs: Vec = Vec::new(); + for &c in self.up.nodes[ix(y)].children().as_slice() { + if let Some(jc) = self.at(c) { + for &r in &reps[jc] { + let fr = uf_find(&uf, r); + if !rs.contains(&fr) { + rs.push(fr); + } + } + } + } + if und_f[j] { + let iy = member(j); + for &r in &rs { + union(&mut uf, iy, r); + } + reps[j] = vec![uf_find(&uf, iy)]; + } else if avail_fixed[j] && rs.len() > 1 { + let r0 = rs[0]; + for &r in &rs { + union(&mut uf, r0, r); + } + reps[j] = vec![uf_find(&uf, r0)]; + } else { + reps[j] = rs; + } + } + let mut groups: FxHashMap> = FxHashMap::default(); + for &t in und { + let r = uf_find(&uf, self.at(t).map_or(0, member)); + groups.entry(r).or_default().push(t); + } + let mut gs: Vec> = groups + .into_values() + .map(|mut g| { + g.sort_unstable(); + g + }) + .collect(); + gs.sort_by_key(|g| g[0]); + gs + } + + /// Memo key of a group and the decided members that reach it (Lean + /// `SCtx.memoKey`), and those members as flags over the area positions. + /// `opq`, `in_f` and `out` are flags over the area positions. + fn memo_key( + &self, + opq: &[bool], + in_f: &[bool], + out: &[bool], + g: &[TermId], + ) -> (Vec, Vec) { + let code = + |q: TermId, j: usize| u64::from(q) * 3 + if opq[j] { 2 } else { 1 }; + let mut entries: Vec = Vec::new(); + let mut rel = vec![false; self.area.len()]; + let mut down_start: Vec = g.to_vec(); + let mut seen = self.flags(g); + let mut stack: Vec = g.to_vec(); + while let Some(y) = stack.pop() { + for &q in &self.facts.parents[ix(y)] { + let Some(j) = self.at(q) else { continue }; + if seen[j] { + continue; + } + seen[j] = true; + if out[j] { + entries.push(u64::from(q) * 3); + rel[j] = true; + } else if in_f[j] { + entries.push(code(q, j)); + rel[j] = true; + if !opq[j] { + down_start.push(q); + } + } + if !opq[j] { + stack.push(q); + } + } + } + let mut seen = self.flags(&down_start); + let mut stack = down_start; + while let Some(y) = stack.pop() { + for &c in self.up.nodes[ix(y)].children().as_slice() { + let Some(j) = self.at(c) else { continue }; + if seen[j] { + continue; + } + seen[j] = true; + if !rel[j] { + if out[j] { + entries.push(u64::from(c) * 3); + rel[j] = true; + } else if in_f[j] { + entries.push(code(c, j)); + rel[j] = true; + } + } + if !opq[j] { + stack.push(c); + } + } + } + entries.sort_unstable(); + let mut key: Vec = g.iter().map(|&t| u64::from(t)).collect(); + key.push(3 * self.dag_size + 3); + key.extend(entries); + (key, rel) + } + + /// Exact table of a group under the decided members outside it (Lean + /// `SCtx.solve`). + fn solve( + &mut self, + meter: &mut Meter<'_>, + g: &[TermId], + in_all: &[TermId], + out_all: &[TermId], + ) -> Result { + let out = self.flags(out_all); + let in_f = self.flags(in_all); + let key = { + let b = self.rebound(&out)?; + let opq: Vec = self + .area + .iter() + .enumerate() + .map(|(j, &t)| { + self.up.opaq[ix(t)] || (in_f[j] && self.opaque_under(&b, t)) + }) + .collect(); + self.memo_key(&opq, &in_f, &out, g).0 + }; + if let Some(tb) = self.memo.get(&key) { + self.memo_hits += 1; + return Ok(tb.clone()); + } + let (phi0, work) = self.phi(&in_f, in_all)?; + Self::charge(meter, work.saturating_add(len64(self.area.len())))?; + let tb = self.node( + meter, + phi0, + in_all, + out_all.to_vec(), + out_all.len(), + Vec::new(), + g, + Vec::new(), + )?; + let tb = table_trim(tb, self.slack); + self.memo.insert(key, tb.clone()); + Ok(tb) + } + + /// Branch-and-bound node of a group (Lean `SCtx.node`). + #[allow(clippy::too_many_arguments)] + fn node( + &mut self, + meter: &mut Meter<'_>, + phi0: u128, + in_ctx: &[TermId], + out_all: Vec, + n_out_ctx: usize, + local_in: Vec, + und: &[TermId], + mut tb: CTable, + ) -> Result { + let out = self.flags(&out_all); + // Reclassify. + let (gains, opaque_in) = { + let b = self.rebound(&out)?; + let vis = self.revisible(&out); + let mut gains: Vec<(TermId, i128)> = Vec::with_capacity(und.len()); + for &t in und { + let (d, h) = self + .at(t) + .map_or((self.vis0.0[ix(t)], self.vis0.1[ix(t)]), |j| vis[j]); + let v = b.get(t); + let gt = stored_gain( + &self.up.nodes[ix(t)], + d, + h, + self.spine_len[ix(t)], + v[0], + v[1], + self.up.w, + )?; + gains.push((t, gt)); + } + // Opacity of every decided-stored member under these bounds (the + // forced members included), for the split below. + let mut opaque_in = vec![false; self.area.len()]; + for &t in in_ctx + .iter() + .chain(&local_in) + .chain(gains.iter().filter(|(_, g)| *g >= self.theta).map(|(t, _)| t)) + { + if self.opaque_under(&b, t) + && let Some(j) = self.at(t) + { + opaque_in[j] = true; + } + } + (gains, opaque_in) + }; + let forced: Vec = + gains.iter().filter(|(_, g)| *g >= self.theta).map(|(t, _)| *t).collect(); + let local_in = if forced.is_empty() { + local_in + } else { + merge_sorted(&local_in, &forced) + }; + let open: Vec<(TermId, i128)> = + gains.into_iter().filter(|(_, g)| *g < self.theta).collect(); + let und: Vec = open.iter().map(|(t, _)| *t).collect(); + let in_all: Vec = in_ctx.iter().chain(&local_in).copied().collect(); + let in_f = self.flags(&in_all); + // Lower bound: every undecided member available, its entry free. + let mut in_und = self.flags(&und); + for (a, &b) in in_und.iter_mut().zip(&in_f) { + *a |= b; + } + let (phi, work) = self.phi(&in_und, &in_all)?; + Self::charge(meter, work.saturating_add(2 * len64(self.area.len())))?; + let delta = to_i(phi)? - to_i(phi0)?; + if und.is_empty() { + table_add(&mut tb, (delta, local_in)); + return Ok(tb); + } + if let Some(bd) = table_best(&tb) + && delta > bd + self.slack + { + return Ok(tb); + } + // Split into independent groups. + let opq: Vec = self + .area + .iter() + .enumerate() + .map(|(j, &t)| self.up.opaq[ix(t)] || (in_f[j] && opaque_in[j])) + .collect(); + let avail_fixed: Vec = + in_f.iter().zip(&opq).map(|(&i, &o)| i && !o).collect(); + let groups = self.groups(&opq, &avail_fixed, &und); + let route = if groups.len() > 1 { + true + } else if groups.len() == 1 { + let (_, rel) = self.memo_key(&opq, &in_f, &out, &groups[0]); + let related = |t: &TermId| self.at(*t).is_some_and(|j| rel[j]); + local_in.iter().any(|t| !related(t)) + || out_all[n_out_ctx..].iter().any(|t| !related(t)) + } else { + false + }; + if route { + let (phi_none, work) = self.phi(&in_f, &in_all)?; + Self::charge(meter, work)?; + let base = to_i(phi_none)? - to_i(phi0)?; + let mut comb: CTable = vec![Some((base, local_in.clone()))]; + for grp in &groups { + let sub = self.solve(meter, grp, &in_all, &out_all)?; + comb = table_trim(table_conv(&comb, &sub), self.slack); + } + for e in comb.into_iter().flatten() { + table_add(&mut tb, e); + } + return Ok(tb); + } + // Branch on the largest |gain|, "stored" first when it is positive. + let Some((t, gt)) = pick_branch(&open) else { + return Ok(tb); + }; + let mut und2 = und.clone(); + if let Some(p) = und2.iter().position(|&x| x == t) { + und2.remove(p); + } + let with_t = merge_sorted(&local_in, &[t]); + let mut out_t = out_all.clone(); + out_t.push(t); + if gt > 0 { + let tb = self + .node(meter, phi0, in_ctx, out_all, n_out_ctx, with_t, &und2, tb)?; + self.node(meter, phi0, in_ctx, out_t, n_out_ctx, local_in, &und2, tb) + } else { + let tb = self.node( + meter, + phi0, + in_ctx, + out_t, + n_out_ctx, + local_in.clone(), + &und2, + tb, + )?; + self.node(meter, phi0, in_ctx, out_all, n_out_ctx, with_t, &und2, tb) + } + } +} + +// --------------------------------------------------------------------------- +// Order and driver +// --------------------------------------------------------------------------- + +/// Bound on telescope spine lengths (Lean `teleSubaddEnd = Ixon.tagNEnd5 4`, +/// 4,311,811,080): below it the TagN Share-flag width is subadditive +/// (`tag4_len(a + b) <= tag4_len(a) + tag4_len(b)`), which the certain-excluded +/// class relies on when two telescopes merge. +pub(crate) const TELE_SUBADD_END: u64 = TagN::end5(4); + +/// Whether every telescope spine length is below [`TELE_SUBADD_END`]. +pub(crate) fn spines_within_bound(spine_len: &[u64]) -> bool { + spine_len.iter().all(|&l| l < TELE_SUBADD_END) +} + +/// First count with the same TagN (f = 0) width as `k` (`tag0_len`): the +/// start of `k`'s rung. Mirrors Lean `tag0BracketStart`. +fn tag0_bracket_start(k: u64) -> u64 { + if k < TagN::end1(0) { + 0 + } else if k < TagN::end2(0) { + TagN::end1(0) + } else if k < TagN::end3(0) { + TagN::end2(0) + } else if k < TagN::end4(0) { + TagN::end3(0) + } else if k < TagN::end5(0) { + TagN::end4(0) + } else { + TagN::end5(0) + } +} + +/// An upper bound on `tag0_len(k + 1) - tag0_len(k)` for every `k < n`: the +/// TagN (f = 0) width grows by one byte at 128, 16512, 82048 and 16859264, +/// and by four at 4311826560. Mirrors Lean `tag0StepBound`. +fn tag0_step_bound(n: u64) -> u64 { + if n < TagN::end5(0) { 1 } else { 4 } +} + +/// Pinned table order of a stored set: stored descendants first; among +/// ready terms the larger in-degree first, then the smaller ID. +pub(crate) fn pinned_order( + dag: &SharingDag, + deg: &[u64], + stored: &[TermId], +) -> Vec { + let nodes = dag.nodes(); + let mut is_stored = vec![false; nodes.len()]; + for &t in stored { + is_stored[ix(t)] = true; + } + // Nearest stored descendants of each stored term (`seen[x] == k + 1`: + // visited from the `k`-th stored term). + let mut pending: Vec = Vec::with_capacity(stored.len()); + let mut dependents: FxHashMap> = FxHashMap::default(); + let mut seen: Vec = vec![0; nodes.len()]; + let mut stack: Vec = Vec::new(); + for (k, &t) in stored.iter().enumerate() { + stack.clear(); + stack.extend_from_slice(nodes[ix(t)].children().as_slice()); + let mut deps = 0usize; + while let Some(x) = stack.pop() { + if seen[ix(x)] == k + 1 { + continue; + } + seen[ix(x)] = k + 1; + if is_stored[ix(x)] { + deps += 1; + dependents.entry(x).or_default().push(t); + } else { + stack.extend_from_slice(nodes[ix(x)].children().as_slice()); + } + } + pending.push(deps); + } + let pos: FxHashMap = + stored.iter().enumerate().map(|(k, &t)| (t, k)).collect(); + let mut heap: std::collections::BinaryHeap<(u64, std::cmp::Reverse)> = + std::collections::BinaryHeap::new(); + for (k, &t) in stored.iter().enumerate() { + if pending[k] == 0 { + heap.push((deg[ix(t)], std::cmp::Reverse(t))); + } + } + let mut order = Vec::with_capacity(stored.len()); + while let Some((_, std::cmp::Reverse(t))) = heap.pop() { + order.push(t); + if let Some(ds) = dependents.get(&t) { + for &d in ds { + let k = pos[&d]; + pending[k] -= 1; + if pending[k] == 0 { + heap.push((deg[ix(d)], std::cmp::Reverse(d))); + } + } + } + } + order +} + +/// Exact uniform-width optimization of a DAG. +pub(crate) fn optimize_uniform( + w: u64, + dag: &SharingDag, + meter: &mut Meter<'_>, +) -> Result { + if w == 0 { + return Err(SharingError::FormatBound(FormatBound::UniformWidth { w })); + } + let (mut result, plan) = + optimize_uniform_with(w, dag, &DagPrep::new(dag), meter)?; + let built = plan.build(dag, &result.table_terms, meter.limits())?; + result.roots = built.roots; + result.sharing = built.entries; + result.variable_len = built.measured; + Ok(result) +} + +/// The tables of one DAG that do not depend on the uniform width, computed +/// once and shared by the candidates of the tiered construction. Each is +/// exactly what `optimize_uniform` and `tiered_at` computed for themselves. +pub(crate) struct DagPrep { + /// `Node::own_len` of every term. + pub(crate) own: Vec, + /// `C_0` (`all_costs` with no dictionary), with each term's work. + pub(crate) base: Evaluation, + /// The parent edges and what each parent reads (phase 3). + pub(crate) edges: ReadEdges, + pub(crate) facts: Facts, + /// Spine lengths with no stop terms. + spine_len: Vec, + /// Unshared sizes of the uniform model (the empty evaluation; it does not + /// read the width), or its overflow error. + size: Result, SharingError>, +} + +impl DagPrep { + pub(crate) fn new(dag: &SharingDag) -> Self { + let nodes = dag.nodes(); + let n = nodes.len(); + let own: Vec = nodes.iter().map(Node::own_len).collect(); + let base = Evaluation::new(nodes, &own, &super::dict::NoWidths); + let edges = ReadEdges::new(nodes); + let facts = graph_facts(dag); + let (spine_len, _) = spine_tables(nodes, &vec![false; n]); + // With no opaque and no available term, `UPrep::node` reads the width + // nowhere (no cut is available and every cost is the inline bound), so + // any width gives these sizes. + let size = UPrep::new(nodes, 1, vec![false; n]) + .map(|empty| empty.base.iter().map(|v| v.cost).collect()); + DagPrep { own, base, edges, facts, spine_len, size } + } +} + +/// [`optimize_uniform`] (`w >= 1`) with the width-independent tables of +/// `prep`, up to the decisions: the result has empty `roots` and `sharing` +/// and `variable_len` 0, and the [`UniformPlan`] builds the expressions +/// ([`UniformPlan::build`], which [`optimize_uniform`] does) or describes +/// them ([`UniformPlan::shares`], the dry run of phase 1 of the tiered +/// construction). +pub(crate) fn optimize_uniform_with( + w: u64, + dag: &SharingDag, + prep: &DagPrep, + meter: &mut Meter<'_>, +) -> Result<(UniformSharingResult, UniformPlan), SharingError> { + if w == 0 { + return Err(SharingError::FormatBound(FormatBound::UniformWidth { w })); + } + let wu = u(w); + let nodes = dag.nodes(); + let n = nodes.len(); + let p = prof::scope(Phase::Classify); + let facts = &prep.facts; + // Fail closed on a telescope spine of `TELE_SUBADD_END` or more steps, + // before the search (Lean's `optimizeUniformExpanded`). + let spine_len = &prep.spine_len; + if !spines_within_bound(spine_len) { + return Err(SharingError::FormatBound(FormatBound::TelescopeSpine { + bound: TELE_SUBADD_END, + })); + } + // Unshared sizes C_0 (no stop terms, nothing available). + let size: &[u128] = prep.size.as_ref().map_err(Clone::clone)?; + // Classes: certain-excluded, low degree, and the gain test on visible + // counts with threshold theta. + let ce: Vec = + (0..n).map(|t| certainly_excluded(facts.occ[t], size[t], wu)).collect(); + let cand: Vec = (0..n).map(|t| !ce[t] && facts.deg[t] >= 2).collect(); + let bounds = uniform_bounds(nodes, wu, &cand)?; + let vis0 = visible_counts(dag, &cand); + let classify = |theta: i128| -> Result, SharingError> { + let mut cls = Vec::with_capacity(n); + for t in 0..n { + cls.push(if ce[t] { + UniformClass::CertainExcluded + } else if facts.deg[t] < 2 { + UniformClass::LowDegree + } else if stored_gain( + &nodes[t], + vis0.0[t], + vis0.1[t], + spine_len[t], + bounds.inl[t], + bounds.merged[t], + wu, + )? >= theta + { + UniformClass::CertainStored + } else { + UniformClass::Uncertain + }); + } + Ok(cls) + }; + // theta = 1 + tag0_step_bound(#candidates) always holds (one more entry + // grows the table count by at most that many bytes; 2 below 4311826560 + // candidates); 1 when every minimum lies in one count bracket. + let n_cand = len64(cand.iter().filter(|&&c| c).count()); + let theta_max = i128::from(tag0_step_bound(n_cand)) + 1; + let cls_max = classify(theta_max)?; + let n_cs_max = len64( + cls_max.iter().filter(|&&c| c == UniformClass::CertainStored).count(), + ); + let theta: i128 = + if tag0_len(n_cand) == tag0_len(n_cs_max) { 1 } else { theta_max }; + let cls = if theta == 1 { classify(1)? } else { cls_max }; + let pick = |c: UniformClass| -> Vec { + (0..n).filter(|&t| cls[t] == c).map(tid).collect() + }; + let cs = pick(UniformClass::CertainStored); + let ce_terms = pick(UniformClass::CertainExcluded); + let unc = pick(UniformClass::Uncertain); + let low = pick(UniformClass::LowDegree); + // The candidate count is a statistic here (Lean `Stats.candidates`), not + // a limit: `max_candidates` bounds only the width-state search (`search`), + // and Lean's uniform optimizer has no such limit. + meter.stats.candidates = len64(cs.len() + unc.len()); + let mut opaq = vec![false; n]; + for &t in &cs { + opaq[ix(t)] = true; + } + let up = UPrep::new(nodes, wu, opaq)?; + let comps = uncertain_components(dag, &cls); + let k_cs = u64::try_from(cs.len()).unwrap_or(u64::MAX); + let k_unc = u64::try_from(unc.len()).unwrap_or(u64::MAX); + // Largest table-count difference between two candidate-only sets that + // contain the certain-stored terms. + let slack = i128::from(tag0_len(k_cs.saturating_add(k_unc))) + - i128::from(tag0_len(k_cs)); + // Search each component (independent searches; see `Parallelism`). + let search_area = |members: &Vec, + area: Vec, + meter: &mut Meter<'_>, + pos: &[u32]| + -> Result<(Choice, CTable), SharingError> { + let mut mult: std::collections::BTreeMap = + std::collections::BTreeMap::new(); + for &r in dag.roots() { + if pos[ix(r)] != NO_POS { + *mult.entry(r).or_default() += 1; + } + } + let root_mult: Vec<(TermId, u128)> = mult.into_iter().collect(); + let stored_in: Vec = + area.iter().copied().filter(|&t| up.opaq[ix(t)]).collect(); + if meter.limits().uniform_subset_search { + // The reference: plain subset enumeration. + let mut cx = CompCtx { + up: &up, + members: members.clone(), + area, + root_mult, + stored_in, + phi0: 0, + slack, + vals: vec![UVal::default(); n], + stamp: vec![0; n], + epoch: 0, + avail: vec![false; n], + }; + let (phi0, _) = cx.phi(&[])?; + cx.phi0 = phi0; + return cx.search(meter); + } + let mut member_of: Vec = vec![NO_POS; area.len()]; + for (m, &t) in members.iter().enumerate() { + if let Some(j) = + usize::try_from(pos[ix(t)]).ok().filter(|&j| j < area.len()) + { + member_of[j] = u32::try_from(m).unwrap_or(NO_POS); + } + } + let in_edges: Vec> = area + .iter() + .map(|&y| { + facts.parents[ix(y)] + .iter() + .map(|&q| { + let node = &nodes[ix(q)]; + let (mut ma, mut mh) = (0u64, 0u64); + for (i, &c) in node.children().as_slice().iter().enumerate() { + if c == y { + ma += 1; + if !continuation_edge(node, i, &nodes[ix(y)]) { + mh += 1; + } + } + } + (q, pos[ix(q)], ma, mh) + }) + .collect() + }) + .collect(); + let root_occ: Vec = area + .iter() + .map(|y| { + root_mult + .iter() + .find(|(r, _)| r == y) + .map_or(0, |(_, m)| u64::try_from(*m).unwrap_or(u64::MAX)) + }) + .collect(); + let area_len = area.len(); + let mut cx = SCtx { + up: &up, + facts, + cand: &cand, + b0: &bounds, + vis0: &vis0, + spine_len, + dag_size: len64(n), + members: members.clone(), + member_of, + area, + pos, + in_edges, + root_occ, + root_mult, + stored_in, + slack, + theta, + memo: FxHashMap::default(), + memo_hits: 0, + vals: vec![UVal::default(); area_len], + }; + let tb = cx.solve(meter, members, &[], &[])?; + let bd = table_best(&tb) + .ok_or_else(|| internal("component search found no choice"))?; + let mut best_set: Option<&Vec> = None; + for (d, s) in tb.iter().flatten() { + if *d == bd && best_set.is_none_or(|a| set_prec(s, a)) { + best_set = Some(s); + } + } + let bs = best_set + .cloned() + .ok_or_else(|| internal("component search found no choice"))?; + Ok(((bd, bs), tb)) + }; + // `pos` maps every term to its position in the component's area + // (`NO_POS` outside it); it is set for the area of each component and + // cleared afterwards, so one buffer serves every component. + let search_one = |members: &Vec, + meter: &mut Meter<'_>, + pos: &mut [u32]| + -> Result<(Choice, CTable), SharingError> { + let area = component_area(&up, facts, members); + for (j, &t) in area.iter().enumerate() { + pos[ix(t)] = u32::try_from(j).unwrap_or(NO_POS); + } + let res = search_area(members, area.clone(), meter, pos); + for &t in &area { + pos[ix(t)] = NO_POS; + } + res + }; + drop(p); + let p = prof::scope(Phase::Search); + let budget = meter.parallel.components; + let mut results: Vec<(Choice, CTable)> = Vec::with_capacity(comps.len()); + if budget <= 1 { + let mut pos = vec![NO_POS; n]; + for members in &comps { + results.push(search_one(members, meter, &mut pos)?); + } + } else { + // Each component on its own meter; the counts are added in component + // order afterwards (`Meter::absorb`), then the results are used in the + // same order as sequentially. + let limits = meter.limits(); + let outs = super::par::map_ranges(comps.len(), budget, |r| { + let mut pos = vec![NO_POS; n]; + r.map(|j| { + let mut m = Meter::new(limits); + let res = search_one(&comps[j], &mut m, &mut pos); + (res, m.stats) + }) + .collect() + }); + for (res, stats) in outs { + meter.absorb(&stats)?; + results.push(res?); + } + } + drop(p); + let p = prof::scope(Phase::Knapsack); + let states_visited = meter.stats.states_created; + // Combine: per-component optima, unless a lower count bracket is shorter. + // The components are disjoint, so the union of their sets is their + // concatenation, sorted once. + let mut chosen_x: Vec = Vec::new(); + let mut chosen_delta: i128 = 0; + for ((d, s), _) in &results { + chosen_x.extend_from_slice(s); + chosen_delta += d; + } + chosen_x.sort_unstable(); + let len_u64 = |v: usize| u64::try_from(v).unwrap_or(u64::MAX); + let k0 = k_cs.saturating_add(len_u64(chosen_x.len())); + let start = tag0_bracket_start(k0); + let mut lower_bracket = false; + if start > k_cs { + let cap = usize::try_from(start - 1 - k_cs).map_err(|_e| overflow())?; + let cells = (results.len() + 1).saturating_mul(cap + 1); + if u64::try_from(cells).unwrap_or(u64::MAX) + > meter.limits().max_knapsack_cells + { + return Err(SharingError::ResourceExhausted(super::ResourceExhausted { + resource: super::Resource::KnapsackCells, + limit: meter.limits().max_knapsack_cells, + })); + } + let tables: Vec<&CTable> = results.iter().map(|(_, t)| t).collect(); + let ks = Knapsack::run(&tables, cap); + // The per-component optimum is replaced by the least cell under + // (length, set_prec) when that cell precedes it: the least of the + // optimum and every cell, as a scan of the cells in count order with + // `set_prec` on ties keeps. The cells' ranks are their `set_prec` order. + let l0 = + chosen_delta + i128::from(tag0_len(k_cs + len_u64(chosen_x.len()))); + let mut best: Option<(i128, u32, usize, i128)> = None; + for c in 0..=cap { + let Some(d) = ks.last.delta[c] else { continue }; + let l = d + i128::from(tag0_len(k_cs + len_u64(c))); + let r = ks.last.rank[c]; + if best.is_none_or(|(bl, br, _, _)| l < bl || (l == bl && r < br)) { + best = Some((l, r, c, d)); + } + } + if let Some((l, _, c, d)) = best { + let s = ks.set(&tables, c); + if l < l0 || (l == l0 && set_prec(&s, &chosen_x)) { + chosen_x = s; + chosen_delta = d; + lower_bracket = true; + } + } + } + drop(p); + let p = prof::scope(Phase::UniformMaterialize); + // Model length from the truncated evaluation. + let mut base_total = 0u128; + for &r in dag.roots() { + base_total = base_total.saturating_add(up.base[ix(r)].cost); + } + for &c in &cs { + base_total = base_total.saturating_add(up.base[ix(c)].inl); + } + if base_total == u128::MAX { + return Err(overflow()); + } + let k = k_cs + len_u64(chosen_x.len()); + let model = to_i(base_total)? + chosen_delta + i128::from(tag0_len(k)); + let model = u64::try_from(model).map_err(|_e| overflow())?; + if model == u64::MAX { + return Err(overflow()); + } + meter.output(model)?; + // Materialize in the pinned order with the full evaluation and check. + let stored = merge_sorted(&cs, &chosen_x); + let order = pinned_order(dag, &facts.deg, &stored); + if order.len() != stored.len() { + return Err(internal("pinned order dropped a stored term")); + } + let mut index: Vec> = vec![None; n]; + for (pos, &t) in order.iter().enumerate() { + index[ix(t)] = Some(len_u64(pos)); + } + let dict = UniformIndex { index, width: w }; + let own = &prep.own; + let mut work = 0u64; + let costs = all_costs(nodes, own, &dict, &mut work); + let plan = decide_dependent( + nodes, + own, + &dict, + &costs, + &order, + dag.roots(), + &mut work, + )?; + meter.work(work)?; + let predicted = plan.predicted.plus_u64(tag0_len(k)); + if predicted != Len::new(model) { + return Err(internal(format!( + "uniform model length {model} differs from the full evaluation {predicted:?}" + ))); + } + let mut unshared = Len::new(tag0_len(0)); + for &r in dag.roots() { + unshared = unshared.plus(prep.base.costs[ix(r)]); + } + let result = UniformSharingResult { + roots: Vec::new(), + sharing: Vec::new(), + table_terms: order, + model_len: model, + variable_len: 0, + unshared_len: unshared.exact(), + stored, + certain_stored: cs, + certain_excluded: ce_terms, + uncertain: unc, + low_degree: low, + components: comps, + states_visited, + lower_bracket, + stats: meter.stats.clone(), + }; + drop(p); + Ok((result, UniformPlan { dict, plan, model, k })) +} + +/// The decisions of one uniform-width optimum ([`optimize_uniform_with`]): +/// the table indices of the stored terms and the materialization choice of +/// every entry top and needed term. The expressions are either built and +/// checked ([`UniformPlan::build`]) or only described +/// ([`UniformPlan::shares`]); both read the same decisions. +pub(crate) struct UniformPlan { + dict: UniformIndex, + plan: DependentPlan, + /// The uniform-model variable length. + model: u64, + /// The table length. + k: u64, +} + +/// The phase-1 expressions of a [`UniformPlan`], checked by re-expansion. +pub(crate) struct UniformExprs { + pub(crate) entries: Vec>, + pub(crate) roots: Vec>, + /// Real variable length (Shares at their TagN width, as `put_expr` + /// writes them). + pub(crate) measured: u64, + /// Pointer-distinct expression nodes, as the re-expansion check counted + /// them (`None` when the check without interning reported a mismatch and + /// the interning build accepted the encoding, which it never should). + pub(crate) visited: Option, +} + +impl UniformPlan { + /// What the expressions contain, from the decisions alone (the phase-1 + /// dry run of the tiered construction): [`PlanShares`], and the real + /// variable length, which is the model with every Share priced at its + /// TagN width instead of `w`, Share by Share. Charges `max_input_nodes` + /// with the expression nodes the build allocates, which are the input + /// nodes the re-expansion check of the built expressions charges. + pub(crate) fn shares( + &self, + dag: &SharingDag, + table: &[TermId], + limits: &ExactSharingLimits, + ) -> Result<(PlanShares, u64), SharingError> { + let _p = prof::scope(Phase::UniformCheck); + let position = + |t: TermId| self.dict.index[ix(t)].and_then(|i| usize::try_from(i).ok()); + let shares = + self.plan.shares(dag.nodes(), table, dag.roots(), &position)?; + dag.check_input_nodes(shares.nodes, limits)?; + let mut real = i128::from(self.model); + for (i, &r) in shares.refs.iter().enumerate() { + let delta = i128::from(tag4_len(len64(i))) - i128::from(self.dict.width); + real = real + .checked_add(i128::from(r).checked_mul(delta).ok_or_else(overflow)?) + .ok_or_else(overflow)?; + } + let real = u64::try_from(real) + .ok() + .filter(|&l| l < u64::MAX) + .ok_or_else(overflow)?; + Ok((shares, real)) + } + + /// Build the table `table` and the roots, check them by re-expansion + /// (charging `max_input_nodes` with their nodes) and measure their real + /// length. + pub(crate) fn build( + &self, + dag: &SharingDag, + table: &[TermId], + limits: &ExactSharingLimits, + ) -> Result { + let p = prof::scope(Phase::UniformMaterialize); + let (entries, roots) = + build_dependent(dag.nodes(), &self.dict, &self.plan, table, dag.roots())?; + drop(p); + let _p = prof::scope(Phase::UniformCheck); + // The re-expansion check, then the real length (Shares at their TagN + // width, `expr_len`); both in one walk when the check passes. + let (visited, measured) = + match dag.check_and_measure(table, &entries, &roots, &tag4_len) { + Some((visited, len)) => { + dag.check_input_nodes(visited, limits)?; + (Some(visited), len) + }, + None => { + dag.check_reexpansion( + table, + &entries, + &roots, + limits, + "materialized encoding changes the expanded AST", + "materialized entries do not expand to the stored terms", + )?; + let len = + exprs_len_with(self.k, entries.iter().chain(&roots), &tag4_len) + .ok_or_else(overflow)?; + (None, len) + }, + }; + Ok(UniformExprs { entries, roots, measured, visited }) + } +} + +/// Exact uniform-width sharing of ordered, fully expanded roots. +pub fn optimize_sharing_uniform( + w: u64, + roots: &[Arc], + limits: &ExactSharingLimits, +) -> Result { + let mut meter = Meter::new(limits); + let dag = SharingDag::build(roots, None, &mut meter)?; + optimize_uniform(w, &dag, &mut meter) +} + +/// Expand `c`'s table and re-share it with the uniform-width optimum. +pub fn normalize_constant_sharing_uniform( + w: u64, + c: &Constant, + limits: &ExactSharingLimits, +) -> Result<(Constant, UniformSharingResult), SharingError> { + let mut meter = Meter::new(limits); + let roots = constant_info_root_exprs(&c.info); + let dag = SharingDag::build(&roots, Some(&c.sharing), &mut meter)?; + let fixed = constant_fixed_len(c).ok_or_else(overflow)?; + let result = optimize_uniform(w, &dag, &mut meter)?; + let info = rebuild_constant_info(&c.info, &result.roots)?; + let out = Constant { + info, + sharing: result.sharing.clone(), + refs: c.refs.clone(), + univs: c.univs.clone(), + }; + let mut bytes = Vec::new(); + out.put(&mut bytes); + if u64::try_from(bytes.len()).ok() != fixed.checked_add(result.variable_len) { + return Err(internal("uniform output length differs from its accounting")); + } + Ok((out, result)) +} + +#[cfg(test)] +mod count_bracket_tests { + use super::{tag0_bracket_start, tag0_len, tag0_step_bound}; + use crate::tag::TagN; + + fn counts() -> Vec { + let mut v = vec![0u64, 1, 2, 255, 256, u64::MAX - 1, u64::MAX]; + for e in [ + TagN::end1(0), + TagN::end2(0), + TagN::end3(0), + TagN::end4(0), + TagN::end5(0), + ] { + v.extend([e - 1, e, e + 1]); + } + v + } + + /// Same checks as the Lean `widthTests` for `tag0BracketStart` and + /// `tag0StepBound`. + #[test] + fn bracket_start_and_step_bound() { + for k in counts() { + let s = tag0_bracket_start(k); + assert_eq!(tag0_len(s), tag0_len(k), "bracket start of {k}"); + assert!(s == 0 || tag0_len(s - 1) < tag0_len(k), "least start of {k}"); + if k > 0 { + assert!(tag0_len(k) - tag0_len(k - 1) <= tag0_step_bound(k), "{k}"); + } + } + assert_eq!(tag0_step_bound(82048), 1); + assert_eq!(tag0_step_bound(TagN::end5(0) - 1), 1); + assert_eq!(tag0_step_bound(TagN::end5(0)), 4); + } +} + +#[cfg(test)] +#[allow(clippy::cast_possible_truncation, clippy::needless_range_loop)] +mod knapsack_tests { + use super::{CTable, Knapsack, TermId, knapsack_reference, set_prec}; + + struct Rng(u64); + + impl Rng { + fn below(&mut self, n: u64) -> u64 { + self.0 ^= self.0 << 13; + self.0 ^= self.0 >> 7; + self.0 ^= self.0 << 17; + self.0 % n.max(1) + } + } + + /// The rank-based knapsack returns the reference's least `(delta, set)` + /// in every cell, and its ranks order the cells' sets by `set_prec`. + #[test] + fn knapsack_matches_explicit_sets() { + let mut rng = Rng(0x9E37_79B9_7F4A_7C15); + let mut cells_checked = 0usize; + for case in 0..400 { + // Disjoint components over a shuffled domain of term IDs. + let mut domain: Vec = (0..300).collect(); + for i in (1..domain.len()).rev() { + let j = rng.below(i as u64 + 1) as usize; + domain.swap(i, j); + } + let comps = rng.below(30) as usize; + let mut next = 0usize; + let mut tables: Vec = Vec::new(); + for _ in 0..comps { + let size = 1 + rng.below(6) as usize; + let mut members: Vec = domain[next..next + size].to_vec(); + next += size; + members.sort_unstable(); + let mut tb: CTable = Vec::new(); + for k in 0..=size { + if rng.below(10) < 7 || k == 0 { + // A random `k`-subset; small deltas make ties common. + let mut pool = members.clone(); + let mut set = Vec::new(); + for _ in 0..k { + let i = rng.below(pool.len() as u64) as usize; + set.push(pool.swap_remove(i)); + } + set.sort_unstable(); + let d = i128::from(rng.below(4) as u8) - 1; + tb.push(Some((d, set))); + } else { + tb.push(None); + } + } + tables.push(tb); + } + let total: usize = tables.iter().map(|t| t.len() - 1).sum(); + let cap = rng.below(total as u64 + 4) as usize; + let refs: Vec<&CTable> = tables.iter().collect(); + let want = knapsack_reference(&refs, cap); + let got = Knapsack::run(&refs, cap); + let mut some: Vec = Vec::new(); + for c in 0..=cap { + assert_eq!( + got.last.delta[c], + want[c].as_ref().map(|x| x.0), + "case {case} cell {c}" + ); + if let Some((_, s)) = &want[c] { + assert_eq!(&got.set(&refs, c), s, "case {case} cell {c}"); + some.push(c); + cells_checked += 1; + } + } + for &a in &some { + for &b in &some { + if a != b { + let (sa, sb) = + (&want[a].as_ref().unwrap().1, &want[b].as_ref().unwrap().1); + assert_eq!( + got.last.rank[a] < got.last.rank[b], + set_prec(sa, sb), + "case {case} cells {a} {b}" + ); + } + } + } + } + assert!(cells_checked > 2000); + } +} diff --git a/crates/ixon/src/syntax/mod.rs b/crates/ixon/src/syntax/mod.rs index 315252405..5fe55d6ea 100644 --- a/crates/ixon/src/syntax/mod.rs +++ b/crates/ixon/src/syntax/mod.rs @@ -92,7 +92,7 @@ mod tests { fn all_contracts_match_shared_text_fixtures() { let mut count = 0; for line in - include_str!("../../../../Tests/Fixtures/ixon-v3/text.tsv").lines() + include_str!("../../../../Tests/Fixtures/ixon-v4/text.tsv").lines() { let columns: Vec<_> = line.split('\t').collect(); assert_eq!(columns.len(), 4); diff --git a/crates/ixon/src/tag.rs b/crates/ixon/src/tag.rs index a303d5d08..3d70091e8 100644 --- a/crates/ixon/src/tag.rs +++ b/crates/ixon/src/tag.rs @@ -1,13 +1,16 @@ -//! Tag encodings for compact serialization. +//! The Ixon integer code: TagN. //! -//! - Tag4: 4-bit flag for expressions (16 variants) -//! - Tag2: 2-bit flag for universes (4 variants) -//! - Tag0: No flag, just variable-length u64 +//! Every integer field of the wire format is a TagN integer with a 4-bit flag +//! (expression, constant, environment, commitment, claim and proof headers), +//! a 2-bit flag (universe terms) or no flag (counts, indices and every other +//! unsigned integer). #![allow(clippy::needless_pass_by_value)] -/// Count how many bytes needed to represent a u64. -pub fn u64_byte_count(x: u64) -> u8 { +/// Count how many bytes needed to represent a u64 (test oracle for the +/// minimal little-endian width). +#[cfg(test)] +pub(crate) fn u64_byte_count(x: u64) -> u8 { match x { 0 => 0, x if x < 0x0000_0000_0000_0100 => 1, @@ -21,8 +24,10 @@ pub fn u64_byte_count(x: u64) -> u8 { } } -/// Write a u64 in minimal little-endian bytes. -pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec) { +/// Write a u64 in minimal little-endian bytes (test inverse of +/// [`u64_get_trimmed_le`]). +#[cfg(test)] +pub(crate) fn u64_put_trimmed_le(x: u64, buf: &mut Vec) { let n = u64_byte_count(x) as usize; buf.extend_from_slice(&x.to_le_bytes()[..n]) } @@ -43,278 +48,177 @@ pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result { } } -/// Tag4: 4-bit flag for expressions. +/// TagN: the Ixon integer code. A rule-for-rule port of `Ixon.putTagN` / +/// `Ixon.getTagN` (`Ix/Ixon.lean`). +/// +/// One header byte `[flag : f bits][payload : r = 8 - f bits]` +/// (`f` in `{0, 2, 4}`) followed by 0, 1, 2, 3, 4 or 8 little-endian bytes. +/// With `L` the top payload bit and `M` the next one: +/// +/// * `L = 0`: the low `r - 1` payload bits are the value (rung 1, +/// `[0, R1)`, `R1 = 2^(r-1)`); +/// * `L = 1, M = 0`: the low `r - 2` bits followed by one byte hold +/// `value - R1` (rung 2, `[R1, R2)`, `R2 = R1 + 2^(r-2+8)`); +/// * `L = 1, M = 1`: the low `r - 2` bits are a code `c`; `c = 0, 1, 2, 3` +/// select 2, 3, 4, 8 following bytes holding `value - R2`, `value - R3`, +/// `value - R4`, `value - R5` (`R3 = R2 + 2^16`, `R4 = R3 + 2^24`, +/// `R5 = R4 + 2^32`); every other code is invalid (none for `f = 4`). +/// +/// Each rung starts where the previous one ends, so a value has exactly one +/// encoding (the code is bijective and needs no canonicality check). Widths +/// 1, 2, 3, 4, 5, 9; rung ends: /// -/// Header byte: `[flag:4][large:1][size:3]` -/// - If large=0: size is in low 3 bits (0-7) -/// - If large=1: (size+1) bytes follow containing the actual size -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Tag4 { +/// | f | R1 | R2 | R3 | R4 | R5 | +/// |---|---|---|---|---|---| +/// | 0 | 128 | 16512 | 82048 | 16859264 | 4311826560 | +/// | 2 | 32 | 4128 | 69664 | 16846880 | 4311814176 | +/// | 4 | 8 | 1032 | 66568 | 16843784 | 4311811080 | +/// +/// Every `u64` is representable for each `f`; the decoder rejects 8-byte +/// payloads whose value would reach `2^64`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct TagN { pub flag: u8, - pub size: u64, + pub value: u64, } -impl Tag4 { - pub fn new(flag: u8, size: u64) -> Self { - debug_assert!(flag < 16, "Tag4 flag must be < 16"); - Tag4 { flag, size } - } - - #[allow(clippy::cast_possible_truncation)] - pub fn encode_head(&self) -> u8 { - if self.size < 8 { - (self.flag << 4) + (self.size as u8) - } else { - (self.flag << 4) + 0b1000 + (u64_byte_count(self.size) - 1) - } - } - - pub fn decode_head(head: u8) -> (u8, bool, u8) { - (head >> 4, head & 0b1000 != 0, head % 0b1000) - } - - pub fn put(&self, buf: &mut Vec) { - buf.push(self.encode_head()); - if self.size >= 8 { - u64_put_trimmed_le(self.size, buf) - } - } - - pub fn get(buf: &mut &[u8]) -> Result { - let head = match buf.split_first() { - Some((&h, rest)) => { - *buf = rest; - h - }, - None => return Err("Tag4::get: EOF".to_string()), - }; - let (flag, large, small) = Self::decode_head(head); - let size = if large { - u64_get_trimmed_le((small + 1) as usize, buf)? - } else { - u64::from(small) - }; - if large && (size < 8 || u64_byte_count(size) != small + 1) { - return Err("Tag4::get: noncanonical integer".into()); - } - Ok(Tag4 { flag, size }) - } - - /// Calculate the encoded size of this tag in bytes. - pub fn encoded_size(&self) -> usize { - if self.size < 8 { 1 } else { 1 + u64_byte_count(self.size) as usize } +impl TagN { + /// End (exclusive) of rung 1 for an `f`-bit flag (`Ixon.tagNEnd1`). + pub const fn end1(f: u32) -> u64 { + 1 << (8 - f - 1) } -} -/// Tag2: 2-bit flag for universes. -/// -/// Header byte: `[flag:2][large:1][size:5]` -/// - If large=0: size is in low 5 bits (0-31) -/// - If large=1: (size+1) bytes follow containing the actual size -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Tag2 { - pub flag: u8, - pub size: u64, -} - -impl Tag2 { - pub fn new(flag: u8, size: u64) -> Self { - debug_assert!(flag < 4, "Tag2 flag must be < 4"); - Tag2 { flag, size } + /// End of rung 2 (`Ixon.tagNEnd2`). + pub const fn end2(f: u32) -> u64 { + Self::end1(f) + (1 << (8 - f - 2 + 8)) } - #[allow(clippy::cast_possible_truncation)] - pub fn encode_head(&self) -> u8 { - if self.size < 32 { - (self.flag << 6) + (self.size as u8) - } else { - (self.flag << 6) + 0b10_0000 + (u64_byte_count(self.size) - 1) - } + /// End of rung 3 (`Ixon.tagNEnd3`). + pub const fn end3(f: u32) -> u64 { + Self::end2(f) + (1 << 16) } - pub fn decode_head(head: u8) -> (u8, bool, u8) { - (head >> 6, head & 0b10_0000 != 0, head % 0b10_0000) + /// End of rung 4 (`Ixon.tagNEnd4`). + pub const fn end4(f: u32) -> u64 { + Self::end3(f) + (1 << 24) } - pub fn put(&self, buf: &mut Vec) { - buf.push(self.encode_head()); - if self.size >= 32 { - u64_put_trimmed_le(self.size, buf) - } + /// End of rung 5 (`Ixon.tagNEnd5`). Rung 6 ends at `end5 + 2^64`, beyond + /// every `u64`. + pub const fn end5(f: u32) -> u64 { + Self::end4(f) + (1 << 32) } - pub fn get(buf: &mut &[u8]) -> Result { - let head = match buf.split_first() { - Some((&h, rest)) => { - *buf = rest; - h - }, - None => return Err("Tag2::get: EOF".to_string()), - }; - let (flag, large, small) = Self::decode_head(head); - let size = if large { - u64_get_trimmed_le((small + 1) as usize, buf)? + /// Byte width of the encoding of `value` (`Ixon.tagNByteWidth`): + /// 1, 2, 3, 4, 5 or 9. + pub const fn byte_width(f: u32, value: u64) -> usize { + if value < Self::end1(f) { + 1 + } else if value < Self::end2(f) { + 2 + } else if value < Self::end3(f) { + 3 + } else if value < Self::end4(f) { + 4 + } else if value < Self::end5(f) { + 5 } else { - u64::from(small) - }; - if large && (size < 32 || u64_byte_count(size) != small + 1) { - return Err("Tag2::get: noncanonical integer".into()); + 9 } - Ok(Tag2 { flag, size }) - } - - /// Calculate the encoded size of this tag in bytes. - pub fn encoded_size(&self) -> usize { - if self.size < 32 { 1 } else { 1 + u64_byte_count(self.size) as usize } - } -} - -/// Tag0: No flag, just variable-length u64. -/// -/// Header byte: `[large:1][size:7]` -/// - If large=0: size is in low 7 bits (0-127) -/// - If large=1: (size+1) bytes follow containing the actual size -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Tag0 { - pub size: u64, -} - -impl Tag0 { - pub fn new(size: u64) -> Self { - Tag0 { size } } + /// Header byte: `flag` in the high `f` bits, `payload` in the low `8 - f` + /// (`Ixon.tagNHeader`, truncated to a byte like `Nat.toUInt8`). #[allow(clippy::cast_possible_truncation)] - pub fn encode_head(&self) -> u8 { - if self.size < 128 { - self.size as u8 + const fn header(f: u32, flag: u8, payload: u64) -> u8 { + (((flag as u64) << (8 - f)) + payload) as u8 + } + + /// Write `value` with an `f`-bit `flag` (`Ixon.putTagN`). + pub fn put(f: u32, flag: u8, value: u64, buf: &mut Vec) { + debug_assert!( + f == 0 || f == 2 || f == 4, + "TagN flag width must be 0, 2 or 4" + ); + debug_assert!(u64::from(flag) < (1u64 << f), "TagN flag out of range"); + let lead = 1u64 << (8 - f - 1); + let mbit = 1u64 << (8 - f - 2); + if value < Self::end1(f) { + buf.push(Self::header(f, flag, value)); + } else if value < Self::end2(f) { + let v = value - Self::end1(f); + buf.push(Self::header(f, flag, lead + v / 256)); + buf.push(v.to_le_bytes()[0]); + } else if value < Self::end3(f) { + buf.push(Self::header(f, flag, lead + mbit)); + buf.extend_from_slice(&(value - Self::end2(f)).to_le_bytes()[..2]); + } else if value < Self::end4(f) { + buf.push(Self::header(f, flag, lead + mbit + 1)); + buf.extend_from_slice(&(value - Self::end3(f)).to_le_bytes()[..3]); + } else if value < Self::end5(f) { + buf.push(Self::header(f, flag, lead + mbit + 2)); + buf.extend_from_slice(&(value - Self::end4(f)).to_le_bytes()[..4]); } else { - 0b1000_0000 + (u64_byte_count(self.size) - 1) - } - } - - pub fn decode_head(head: u8) -> (bool, u8) { - (head & 0b1000_0000 != 0, head % 0b1000_0000) - } - - pub fn put(&self, buf: &mut Vec) { - buf.push(self.encode_head()); - if self.size >= 128 { - u64_put_trimmed_le(self.size, buf) + buf.push(Self::header(f, flag, lead + mbit + 3)); + buf.extend_from_slice(&(value - Self::end5(f)).to_le_bytes()); } } - pub fn get(buf: &mut &[u8]) -> Result { + /// Read a TagN integer with an `f`-bit flag (`Ixon.getTagN`). Invalid codes + /// and values reaching `2^64` are rejected. + pub fn get(f: u32, buf: &mut &[u8]) -> Result { + debug_assert!( + f == 0 || f == 2 || f == 4, + "TagN flag width must be 0, 2 or 4" + ); let head = match buf.split_first() { Some((&h, rest)) => { *buf = rest; h }, - None => return Err("Tag0::get: EOF".to_string()), - }; - let (large, small) = Self::decode_head(head); - let size = if large { - u64_get_trimmed_le((small + 1) as usize, buf)? - } else { - u64::from(small) + None => return Err("TagN::get: EOF".to_string()), }; - if large && (size < 128 || u64_byte_count(size) != small + 1) { - return Err("Tag0::get: noncanonical integer".into()); + let r = 8 - f; + let flag = if f == 0 { 0 } else { head >> r }; + let p = u64::from(head) & ((1u64 << r) - 1); + let lead = 1u64 << (r - 1); + let mbit = 1u64 << (r - 2); + if p < lead { + return Ok(TagN { flag, value: p }); } - Ok(Tag0 { size }) - } - - /// Calculate the encoded size of this tag in bytes. - pub fn encoded_size(&self) -> usize { - if self.size < 128 { 1 } else { 1 + u64_byte_count(self.size) as usize } + if p - lead < mbit { + let lo = match buf.split_first() { + Some((&b, rest)) => { + *buf = rest; + b + }, + None => return Err("TagN::get: EOF, need 1 byte".to_string()), + }; + return Ok(TagN { + flag, + value: Self::end1(f) + (p - lead) * 256 + u64::from(lo), + }); + } + let (len, base) = match p - lead - mbit { + 0 => (2, Self::end2(f)), + 1 => (3, Self::end3(f)), + 2 => (4, Self::end4(f)), + 3 => (8, Self::end5(f)), + c => return Err(format!("TagN::get: invalid TagN code {c}")), + }; + let x = u64_get_trimmed_le(len, buf)?; + let value = base + .checked_add(x) + .ok_or_else(|| "TagN::get: TagN value exceeds UInt64".to_string())?; + Ok(TagN { flag, value }) } } #[cfg(test)] mod tests { use super::*; - use quickcheck::{Arbitrary, Gen}; use quickcheck_macros::quickcheck; - // ============================================================================ - // Arbitrary implementations - // ============================================================================ - - impl Arbitrary for Tag4 { - fn arbitrary(g: &mut Gen) -> Self { - let flag = u8::arbitrary(g) % 16; - Tag4::new(flag, u64::arbitrary(g)) - } - } - - impl Arbitrary for Tag2 { - fn arbitrary(g: &mut Gen) -> Self { - let flag = u8::arbitrary(g) % 4; - Tag2::new(flag, u64::arbitrary(g)) - } - } - - impl Arbitrary for Tag0 { - fn arbitrary(g: &mut Gen) -> Self { - Tag0::new(u64::arbitrary(g)) - } - } - - // ============================================================================ - // Property-based tests - // ============================================================================ - - #[quickcheck] - fn prop_tag4_roundtrip(t: Tag4) -> bool { - let mut buf = Vec::new(); - t.put(&mut buf); - match Tag4::get(&mut buf.as_slice()) { - Ok(t2) => t == t2, - Err(_) => false, - } - } - - #[quickcheck] - fn prop_tag4_encoded_size(t: Tag4) -> bool { - let mut buf = Vec::new(); - t.put(&mut buf); - buf.len() == t.encoded_size() - } - - #[quickcheck] - fn prop_tag2_roundtrip(t: Tag2) -> bool { - let mut buf = Vec::new(); - t.put(&mut buf); - match Tag2::get(&mut buf.as_slice()) { - Ok(t2) => t == t2, - Err(_) => false, - } - } - - #[quickcheck] - fn prop_tag2_encoded_size(t: Tag2) -> bool { - let mut buf = Vec::new(); - t.put(&mut buf); - buf.len() == t.encoded_size() - } - - #[quickcheck] - fn prop_tag0_roundtrip(t: Tag0) -> bool { - let mut buf = Vec::new(); - t.put(&mut buf); - match Tag0::get(&mut buf.as_slice()) { - Ok(t2) => t == t2, - Err(_) => false, - } - } - - #[quickcheck] - fn prop_tag0_encoded_size(t: Tag0) -> bool { - let mut buf = Vec::new(); - t.put(&mut buf); - buf.len() == t.encoded_size() - } - // ============================================================================ // Unit tests // ============================================================================ @@ -339,274 +243,168 @@ mod tests { assert!(roundtrip(0xFFFF_FFFF_FFFF_FFFF)); } - #[test] - fn tag4_small_values() { - for size in 0..8u64 { - for flag in 0..16u8 { - let tag = Tag4::new(flag, size); - let mut buf = Vec::new(); - tag.put(&mut buf); - assert_eq!(buf.len(), 1, "Tag4({flag}, {size}) should be 1 byte"); - - let mut slice: &[u8] = &buf; - let recovered = Tag4::get(&mut slice).unwrap(); - assert_eq!(recovered, tag, "Tag4({flag}, {size}) roundtrip failed"); - assert!(slice.is_empty(), "Tag4({flag}, {size}) had trailing bytes"); - } - } - } - - #[test] - fn tag4_large_values() { - let sizes = [8u64, 255, 256, 65535, 65536, u64::from(u32::MAX), u64::MAX]; - for size in sizes { - for flag in 0..16u8 { - let tag = Tag4::new(flag, size); - let mut buf = Vec::new(); - tag.put(&mut buf); - - let mut slice: &[u8] = &buf; - let recovered = Tag4::get(&mut slice).unwrap(); - assert_eq!(recovered, tag, "Tag4({flag}, {size}) roundtrip failed"); - assert!(slice.is_empty(), "Tag4({flag}, {size}) had trailing bytes"); - } - } - } + // ============================================================================ + // TagN: the vectors of `Tests/Ix/Ixon.lean` (`tagNUnits`), byte for byte + // ============================================================================ - #[test] - fn tag4_encoded_size_test() { - assert_eq!(Tag4::new(0, 0).encoded_size(), 1); - assert_eq!(Tag4::new(0, 7).encoded_size(), 1); - assert_eq!(Tag4::new(0, 8).encoded_size(), 2); - assert_eq!(Tag4::new(0, 255).encoded_size(), 2); - assert_eq!(Tag4::new(0, 256).encoded_size(), 3); - assert_eq!(Tag4::new(0, 65535).encoded_size(), 3); - assert_eq!(Tag4::new(0, 65536).encoded_size(), 4); + fn tagn_bytes(f: u32, flag: u8, v: u64) -> Vec { + let mut buf = Vec::new(); + TagN::put(f, flag, v, &mut buf); + buf } - #[test] - fn tag4_byte_boundaries() { - let test_cases: Vec<(u64, usize)> = vec![ - (0, 1), - (7, 1), - (8, 2), - (0xFF, 2), - (0x100, 3), - (0xFFFF, 3), - (0x10000, 4), - (0xFFFFFF, 4), - (0x1000000, 5), - (0xFFFFFFFF, 5), - (0x100000000, 6), - (0xFFFFFFFFFF, 6), - (0x10000000000, 7), - (0xFFFFFFFFFFFF, 7), - (0x1000000000000, 8), - (0xFFFFFFFFFFFFFF, 8), - (0x100000000000000, 9), - (u64::MAX, 9), - ]; - - for (size, expected_bytes) in &test_cases { - let tag = Tag4::new(0, *size); - let mut buf = Vec::new(); - tag.put(&mut buf); - - assert_eq!( - buf.len(), - *expected_bytes, - "Tag4 with size 0x{:X} should be {} bytes, got {}", - size, - expected_bytes, - buf.len() - ); - - let mut slice: &[u8] = &buf; - let recovered = Tag4::get(&mut slice).unwrap(); - assert_eq!(recovered, tag, "Round-trip failed for size 0x{:X}", size); - assert!(slice.is_empty()); + /// Decode all of `bytes` (trailing bytes are an error, like + /// `runGetExact`). + fn tagn_exact(f: u32, bytes: &[u8]) -> Result { + let mut cur = bytes; + let t = TagN::get(f, &mut cur)?; + if cur.is_empty() { + Ok(t) + } else { + Err(format!("trailing bytes: {}", cur.len())) } } - // ============================================================================ - // Tag2 unit tests - // ============================================================================ - - #[test] - fn tag2_small_values() { - for size in 0..32u64 { - for flag in 0..4u8 { - let tag = Tag2::new(flag, size); - let mut buf = Vec::new(); - tag.put(&mut buf); - assert_eq!(buf.len(), 1, "Tag2({flag}, {size}) should be 1 byte"); - - let mut slice: &[u8] = &buf; - let recovered = Tag2::get(&mut slice).unwrap(); - assert_eq!(recovered, tag, "Tag2({flag}, {size}) roundtrip failed"); - assert!(slice.is_empty(), "Tag2({flag}, {size}) had trailing bytes"); - } + /// `tagNBoundaries`: 0, 1, `2^64 - 1` and every rung end `e - 1, e, e + 1`. + fn tagn_boundaries(f: u32) -> Vec { + let mut v = vec![0, 1, u64::MAX]; + for e in [ + TagN::end1(f), + TagN::end2(f), + TagN::end3(f), + TagN::end4(f), + TagN::end5(f), + ] { + v.extend([e - 1, e, e + 1]); } + v } #[test] - fn tag2_large_values() { - let sizes = [32u64, 255, 256, 65535, 65536, u64::from(u32::MAX), u64::MAX]; - for size in sizes { - for flag in 0..4u8 { - let tag = Tag2::new(flag, size); - let mut buf = Vec::new(); - tag.put(&mut buf); - - let mut slice: &[u8] = &buf; - let recovered = Tag2::get(&mut slice).unwrap(); - assert_eq!(recovered, tag, "Tag2({flag}, {size}) roundtrip failed"); - assert!(slice.is_empty(), "Tag2({flag}, {size}) had trailing bytes"); + fn tagn_boundaries_roundtrip() { + for f in [0u32, 2, 4] { + let flags = [0u8, u8::try_from((1u32 << f) - 1).expect("f <= 4")]; + for flag in flags { + for v in tagn_boundaries(f) { + let bytes = tagn_bytes(f, flag, v); + assert_eq!(bytes.len(), TagN::byte_width(f, v), "f={f} v={v}"); + assert_eq!( + tagn_exact(f, &bytes), + Ok(TagN { flag, value: v }), + "f={f} flag={flag} v={v}" + ); + } } } } #[test] - fn tag2_encoded_size_test() { - assert_eq!(Tag2::new(0, 0).encoded_size(), 1); - assert_eq!(Tag2::new(0, 31).encoded_size(), 1); - assert_eq!(Tag2::new(0, 32).encoded_size(), 2); - assert_eq!(Tag2::new(0, 255).encoded_size(), 2); - assert_eq!(Tag2::new(0, 256).encoded_size(), 3); - assert_eq!(Tag2::new(0, 65535).encoded_size(), 3); - assert_eq!(Tag2::new(0, 65536).encoded_size(), 4); + fn tagn_rung_ends() { + let ends = |f: u32| { + [ + TagN::end1(f), + TagN::end2(f), + TagN::end3(f), + TagN::end4(f), + TagN::end5(f), + ] + }; + assert_eq!(ends(0), [128, 16512, 82048, 16_859_264, 4_311_826_560]); + assert_eq!(ends(2), [32, 4128, 69664, 16_846_880, 4_311_814_176]); + assert_eq!(ends(4), [8, 1032, 66568, 16_843_784, 4_311_811_080]); } #[test] - fn tag2_byte_boundaries() { - let test_cases: Vec<(u64, usize)> = vec![ - (0, 1), - (31, 1), - (32, 2), - (0xFF, 2), - (0x100, 3), - (0xFFFF, 3), - (0x10000, 4), - (0xFFFFFF, 4), - (0x1000000, 5), - (0xFFFFFFFF, 5), - (0x100000000, 6), - (0xFFFFFFFFFF, 6), - (0x10000000000, 7), - (0xFFFFFFFFFFFF, 7), - (0x1000000000000, 8), - (0xFFFFFFFFFFFFFF, 8), - (0x100000000000000, 9), - (u64::MAX, 9), + fn tagn_expected_bytes() { + let cases: &[(u32, u8, u64, &[u8])] = &[ + (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, 16_843_783, &[0x0D, 0xFF, 0xFF, 0xFF]), + (4, 0, 16_843_784, &[0x0E, 0, 0, 0, 0]), + (4, 0, 4_311_811_079, &[0x0E, 0xFF, 0xFF, 0xFF, 0xFF]), + (4, 0, 4_311_811_080, &[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, 16_859_263, &[0xC1, 0xFF, 0xFF, 0xFF]), + (0, 0, 16_859_264, &[0xC2, 0, 0, 0, 0]), + (0, 0, 4_311_826_560, &[0xC3, 0, 0, 0, 0, 0, 0, 0, 0]), + (0, 0, u64::MAX, &[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, 16_846_879, &[0xF1, 0xFF, 0xFF, 0xFF]), + (2, 3, 16_846_880, &[0xF2, 0, 0, 0, 0]), + (2, 3, 4_311_814_176, &[0xF3, 0, 0, 0, 0, 0, 0, 0, 0]), ]; - - for (size, expected_bytes) in &test_cases { - let tag = Tag2::new(0, *size); - let mut buf = Vec::new(); - tag.put(&mut buf); - - assert_eq!( - buf.len(), - *expected_bytes, - "Tag2 with size 0x{:X} should be {} bytes, got {}", - size, - expected_bytes, - buf.len() - ); - - let mut slice: &[u8] = &buf; - let recovered = Tag2::get(&mut slice).unwrap(); - assert_eq!(recovered, tag, "Round-trip failed for size 0x{:X}", size); - assert!(slice.is_empty()); + for &(f, flag, v, expected) in cases { + assert_eq!(tagn_bytes(f, flag, v), expected, "f={f} flag={flag} v={v}"); + assert_eq!(tagn_exact(f, expected), Ok(TagN { flag, value: v })); } } - // ============================================================================ - // Tag0 unit tests - // ============================================================================ - #[test] - fn tag0_small_values() { - for size in 0..128u64 { - let tag = Tag0::new(size); - let mut buf = Vec::new(); - tag.put(&mut buf); - assert_eq!(buf.len(), 1, "Tag0({size}) should be 1 byte"); - - let mut slice: &[u8] = &buf; - let recovered = Tag0::get(&mut slice).unwrap(); - assert_eq!(recovered, tag, "Tag0({size}) roundtrip failed"); - assert!(slice.is_empty(), "Tag0({size}) had trailing bytes"); + fn tagn_rejects() { + let cases: &[(u32, &[u8], &str)] = &[ + (2, &[0x34], "f=2 code 4"), + (2, &[0x3F], "f=2 code 15"), + (0, &[0xC4], "f=0 code 4"), + (0, &[0xFF], "f=0 code 63"), + ( + 4, + &[0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], + "f=4 overflow", + ), + ( + 0, + &[0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], + "f=0 overflow", + ), + (4, &[0x08], "truncated rung 2"), + (4, &[0x0D, 0x00, 0x00], "truncated rung 4"), + (4, &[0x0F, 0x00, 0x00, 0x00], "truncated rung 6"), + (4, &[0x07, 0x00], "trailing byte"), + ]; + for &(f, bytes, what) in cases { + assert!(tagn_exact(f, bytes).is_err(), "accepted {what}: {bytes:02x?}"); } } + /// `tagNShortCanonical`: every string of one or two bytes that decodes + /// exactly re-encodes to itself. #[test] - fn tag0_large_values() { - let sizes = [128u64, 255, 256, 65535, 65536, u64::from(u32::MAX), u64::MAX]; - for size in sizes { - let tag = Tag0::new(size); - let mut buf = Vec::new(); - tag.put(&mut buf); - - let mut slice: &[u8] = &buf; - let recovered = Tag0::get(&mut slice).unwrap(); - assert_eq!(recovered, tag, "Tag0({size}) roundtrip failed"); - assert!(slice.is_empty(), "Tag0({size}) had trailing bytes"); + fn tagn_short_strings_canonical() { + for f in [0u32, 2, 4] { + for a in 0..=255u8 { + if let Ok(t) = tagn_exact(f, &[a]) { + assert_eq!(tagn_bytes(f, t.flag, t.value), [a], "f={f} {a:02x}"); + } + for b in 0..=255u8 { + if let Ok(t) = tagn_exact(f, &[a, b]) { + assert_eq!( + tagn_bytes(f, t.flag, t.value), + [a, b], + "f={f} {a:02x} {b:02x}" + ); + } + } + } } } - #[test] - fn tag0_encoded_size_test() { - assert_eq!(Tag0::new(0).encoded_size(), 1); - assert_eq!(Tag0::new(127).encoded_size(), 1); - assert_eq!(Tag0::new(128).encoded_size(), 2); - assert_eq!(Tag0::new(255).encoded_size(), 2); - assert_eq!(Tag0::new(256).encoded_size(), 3); - assert_eq!(Tag0::new(65535).encoded_size(), 3); - assert_eq!(Tag0::new(65536).encoded_size(), 4); - } - - #[test] - fn tag0_byte_boundaries() { - let test_cases: Vec<(u64, usize)> = vec![ - (0, 1), - (127, 1), - (128, 2), - (0xFF, 2), - (0x100, 3), - (0xFFFF, 3), - (0x10000, 4), - (0xFFFFFF, 4), - (0x1000000, 5), - (0xFFFFFFFF, 5), - (0x100000000, 6), - (0xFFFFFFFFFF, 6), - (0x10000000000, 7), - (0xFFFFFFFFFFFF, 7), - (0x1000000000000, 8), - (0xFFFFFFFFFFFFFF, 8), - (0x100000000000000, 9), - (u64::MAX, 9), - ]; - - for (size, expected_bytes) in &test_cases { - let tag = Tag0::new(*size); - let mut buf = Vec::new(); - tag.put(&mut buf); - - assert_eq!( - buf.len(), - *expected_bytes, - "Tag0 with size 0x{:X} should be {} bytes, got {}", - size, - expected_bytes, - buf.len() - ); - - let mut slice: &[u8] = &buf; - let recovered = Tag0::get(&mut slice).unwrap(); - assert_eq!(recovered, tag, "Round-trip failed for size 0x{:X}", size); - assert!(slice.is_empty()); - } + #[quickcheck] + fn prop_tagn_roundtrip(f_sel: u8, flag: u8, v: u64) -> bool { + let f = [0u32, 2, 4][usize::from(f_sel % 3)]; + let flag = if f == 0 { 0 } else { flag % (1u8 << f) }; + let bytes = tagn_bytes(f, flag, v); + bytes.len() == TagN::byte_width(f, v) + && tagn_exact(f, &bytes) == Ok(TagN { flag, value: v }) } } diff --git a/crates/ixon/src/univ.rs b/crates/ixon/src/univ.rs index 412823320..7a5536c53 100644 --- a/crates/ixon/src/univ.rs +++ b/crates/ixon/src/univ.rs @@ -4,7 +4,7 @@ use std::sync::Arc; -use super::tag::Tag2; +use super::tag::TagN; /// Universe levels for Lean's type system. #[derive(Clone, Debug, PartialEq, Eq, Hash)] @@ -22,8 +22,8 @@ pub enum Univ { } impl Univ { - /// Tag2 flags for universe variants. - pub const FLAG_ZERO_SUCC: u8 = 0; // size=0 for Zero, size=1 for Succ + /// TagN flags for universe variants. + pub const FLAG_ZERO_SUCC: u8 = 0; // value 0 for Zero, n >= 1 for n Succs pub const FLAG_MAX: u8 = 1; pub const FLAG_IMAX: u8 = 2; pub const FLAG_VAR: u8 = 3; @@ -56,7 +56,7 @@ pub fn put_univ(u: &Univ, buf: &mut Vec) { while let Some(curr) = stack.pop() { match curr { Univ::Zero => { - Tag2::new(Univ::FLAG_ZERO_SUCC, 0).put(buf); + TagN::put(2, Univ::FLAG_ZERO_SUCC, 0, buf); }, Univ::Succ(inner) => { // Count the number of successors for telescope compression @@ -66,21 +66,21 @@ pub fn put_univ(u: &Univ, buf: &mut Vec) { count += 1; base = next.as_ref(); } - Tag2::new(Univ::FLAG_ZERO_SUCC, count).put(buf); + TagN::put(2, Univ::FLAG_ZERO_SUCC, count, buf); stack.push(base); }, Univ::Max(a, b) => { - Tag2::new(Univ::FLAG_MAX, 0).put(buf); + TagN::put(2, Univ::FLAG_MAX, 0, buf); stack.push(b); // Process b after a stack.push(a); }, Univ::IMax(a, b) => { - Tag2::new(Univ::FLAG_IMAX, 0).put(buf); + TagN::put(2, Univ::FLAG_IMAX, 0, buf); stack.push(b); // Process b after a stack.push(a); }, Univ::Var(idx) => { - Tag2::new(Univ::FLAG_VAR, *idx).put(buf); + TagN::put(2, Univ::FLAG_VAR, *idx, buf); }, } } @@ -106,14 +106,14 @@ pub fn get_univ(buf: &mut &[u8]) -> Result, String> { while let Some(frame) = work.pop() { match frame { GetUnivFrame::Parse => { - let tag = Tag2::get(buf)?; + let tag = TagN::get(2, buf)?; match tag.flag { Univ::FLAG_ZERO_SUCC => { - if tag.size == 0 { + if tag.value == 0 { results.push(Univ::zero()); } else { // Parse inner, then wrap in Succs - work.push(GetUnivFrame::WrapSuccs(tag.size)); + work.push(GetUnivFrame::WrapSuccs(tag.value)); work.push(GetUnivFrame::Parse); } }, @@ -130,7 +130,7 @@ pub fn get_univ(buf: &mut &[u8]) -> Result, String> { work.push(GetUnivFrame::Parse); // a }, Univ::FLAG_VAR => { - results.push(Univ::var(tag.size)); + results.push(Univ::var(tag.value)); }, f => return Err(format!("get_univ: invalid flag {f}")), } diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs index 8c5219d14..ce307db9b 100644 --- a/crates/ixvm-codegen/src/aiur_ix_aggr.rs +++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs @@ -1072,7 +1072,7 @@ fn aiur_fn_264(inp: [G; IN_264], input_hash: u64, rec const INPUT_SIZE_265: usize = 1; const IN_265: usize = 1; const OUT_265: usize = 3; -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 __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 = 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_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 = G::from_u64(3); 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_87] = { let __args: [G; IN_87] = [__v_5]; 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(1); if (__v_7 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: wrong validator identity".to_string()) }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: 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_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]; if (__v_15 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) }); } if (__v_16 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) }); } if (__v_17 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) }); } let __ret: [G; OUT_265] = [__v_10, __v_12, __v_13]; record.function_queries[265].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __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 = 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_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 = 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_87] = { let __args: [G; IN_87] = [__v_5]; 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(1); if (__v_7 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: wrong validator identity".to_string()) }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: 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_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]; if (__v_15 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) }); } if (__v_16 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) }); } if (__v_17 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) }); } let __ret: [G; OUT_265] = [__v_10, __v_12, __v_13]; record.function_queries[265].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_266: usize = 8; const IN_266: usize = 8; const OUT_266: usize = 1; diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index bbd4d2d96..ece07c679 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -32,3209 +32,3221 @@ fn aiur_fn_4(inp: [G; IN_4], input_hash: u64, record: 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]; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_5] = [__v_3]; record.function_queries[5].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_5(inp: [G; IN_5], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_803] = { let __args: [G; IN_803] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(803, (&__args[..]))?) { [G::ZERO; OUT_803] } else { let (__hash, __hit) = record.function_queries[803].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[803].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[803].bump_multiplicity(__i); } let __ret: [G; OUT_803] = unsafe { (*(record.function_queries[803].output_at(__i).as_ptr() as *const [G; OUT_803])) }; __ret }, _ => { aiur_fn_803::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_5] = [__v_3]; 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_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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, _ => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(3); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, _ => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, _ => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(3); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); 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(8); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }) } +fn aiur_fn_6(inp: [G; IN_6], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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 = 1; -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]; 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_7] = [__v_8]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_7] = [__v_8]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_7] = [__v_8]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_7] = [__v_8]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_7] = [__v_8]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_7] = [__v_8]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_7] = [__v_8]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_7] = [__v_8]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_7] = [__v_8]; 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_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 __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_8] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[8].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_9: usize = 12; -const IN_9: usize = 12; +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 = G::from_u64(2); let __v_20: G = (__v_16 - __v_19); let __v_21: G = (__v_18 * __v_20); let __v_22: G = (__v_16 * __v_21); let __v_23: G = G::from_u64(0); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __ret: [G; OUT_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 = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))) + u128::from(((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_12: G = G::from_u8(__u32_bytes[0]); let __v_13: G = G::from_u8(__u32_bytes[1]); let __v_14: G = G::from_u8(__u32_bytes[2]); let __v_15: G = G::from_u8(__u32_bytes[3]); let __v_16: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_14; let __vj = __v_15; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_17: G = G::from_u64(1); let __v_18: G = (__v_16 - __v_17); let __v_19: G = G::from_u64(2); let __v_20: G = (__v_16 - __v_19); let __v_21: G = (__v_18 * __v_20); let __v_22: G = (__v_16 * __v_21); let __v_23: G = G::from_u64(0); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __ret: [G; OUT_9] = [__v_12, __v_13, __v_14, __v_15]; 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; +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 __v_4: G = 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_10] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_10(inp: [G; IN_10], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_2, __v_3, __v_0, __v_1]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_12: usize = 4; -const IN_12: 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 __ret: [G; OUT_12] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_12(inp: [G; IN_12], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __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_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_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 = 8; -const IN_14: usize = 8; -const OUT_14: usize = 4; -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 __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_14] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[14].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_13(inp: [G; IN_13], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __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 = 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 = inp[8]; let __v_9: G = inp[9]; 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_15] = [__v_24]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_15] = [__v_24]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_15] = [__v_24]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_15] = [__v_24]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_15] = [__v_24]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_15] = [__v_24]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_15] = [__v_24]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_15] = [__v_24]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_15] = [__v_24]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_16: usize = 16; -const IN_16: usize = 16; -const OUT_16: usize = 9; -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 = inp[8]; let __v_9: G = inp[9]; 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_16] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; record.function_queries[16].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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() { 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_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(0); 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(0); 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(0); 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(0); 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(0); 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(0); 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(0); 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); }, } }) } +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 = 8; -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]; 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_18] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[18].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_18] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[18].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_18] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[18].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_18] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[18].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_18] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[18].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_18] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[18].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_18] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[18].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_18] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[18].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_18] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[18].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_19: usize = 8; -const IN_19: 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 = G::from_u64(65536); let __v_12: G = (__v_11 * __v_2); let __v_13: G = G::from_u64(16777216); let __v_14: G = (__v_13 * __v_3); let __v_15: G = G::from_u64(4294967296); let __v_16: G = (__v_15 * __v_4); let __v_17: G = G::from_u64(1099511627776); let __v_18: G = (__v_17 * __v_5); let __v_19: G = G::from_u64(281474976710656); let __v_20: G = (__v_19 * __v_6); let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_16 + __v_21); let __v_23: G = (__v_14 + __v_22); let __v_24: G = (__v_12 + __v_23); let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) }); } let __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_1); let __v_11: G = G::from_u64(65536); let __v_12: G = (__v_11 * __v_2); let __v_13: G = G::from_u64(16777216); let __v_14: G = (__v_13 * __v_3); let __v_15: G = G::from_u64(4294967296); let __v_16: G = (__v_15 * __v_4); let __v_17: G = G::from_u64(1099511627776); let __v_18: G = (__v_17 * __v_5); let __v_19: G = G::from_u64(281474976710656); let __v_20: G = (__v_19 * __v_6); let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_16 + __v_21); let __v_23: G = (__v_14 + __v_22); let __v_24: G = (__v_12 + __v_23); let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_19] = [__v_26]; 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 = 1; -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 = G::from_u64(256); let __v_5: G = (__v_4 * __v_1); let __v_6: G = G::from_u64(65536); let __v_7: G = (__v_6 * __v_2); let __v_8: G = G::from_u64(16777216); let __v_9: G = (__v_8 * __v_3); let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_0 + __v_11); let __ret: [G; OUT_20] = [__v_12]; record.function_queries[20].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_21: usize = 32; -const IN_21: usize = 32; -const OUT_21: usize = 8; -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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = G::from_u64(256); let __v_33: G = (__v_32 * __v_1); let __v_34: G = G::from_u64(65536); let __v_35: G = (__v_34 * __v_2); let __v_36: G = G::from_u64(16777216); let __v_37: G = (__v_36 * __v_3); let __v_38: G = (__v_35 + __v_37); let __v_39: G = (__v_33 + __v_38); let __v_40: G = (__v_0 + __v_39); let __v_41: G = (__v_32 * __v_5); let __v_42: G = (__v_34 * __v_6); let __v_43: G = (__v_36 * __v_7); let __v_44: G = (__v_42 + __v_43); let __v_45: G = (__v_41 + __v_44); let __v_46: G = (__v_4 + __v_45); let __v_47: G = (__v_32 * __v_9); let __v_48: G = (__v_34 * __v_10); let __v_49: G = (__v_36 * __v_11); let __v_50: G = (__v_48 + __v_49); let __v_51: G = (__v_47 + __v_50); let __v_52: G = (__v_8 + __v_51); let __v_53: G = (__v_32 * __v_13); let __v_54: G = (__v_34 * __v_14); let __v_55: G = (__v_36 * __v_15); let __v_56: G = (__v_54 + __v_55); let __v_57: G = (__v_53 + __v_56); let __v_58: G = (__v_12 + __v_57); let __v_59: G = (__v_32 * __v_17); let __v_60: G = (__v_34 * __v_18); let __v_61: G = (__v_36 * __v_19); let __v_62: G = (__v_60 + __v_61); let __v_63: G = (__v_59 + __v_62); let __v_64: G = (__v_16 + __v_63); let __v_65: G = (__v_32 * __v_21); let __v_66: G = (__v_34 * __v_22); let __v_67: G = (__v_36 * __v_23); let __v_68: G = (__v_66 + __v_67); let __v_69: G = (__v_65 + __v_68); let __v_70: G = (__v_20 + __v_69); let __v_71: G = (__v_32 * __v_25); let __v_72: G = (__v_34 * __v_26); let __v_73: G = (__v_36 * __v_27); let __v_74: G = (__v_72 + __v_73); let __v_75: G = (__v_71 + __v_74); let __v_76: G = (__v_24 + __v_75); let __v_77: G = (__v_32 * __v_29); let __v_78: G = (__v_34 * __v_30); let __v_79: G = (__v_36 * __v_31); let __v_80: G = (__v_78 + __v_79); let __v_81: G = (__v_77 + __v_80); let __v_82: G = (__v_28 + __v_81); let __ret: [G; OUT_21] = [__v_40, __v_46, __v_52, __v_58, __v_64, __v_70, __v_76, __v_82]; record.function_queries[21].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_22: usize = 1; -const IN_22: usize = 1; -const OUT_22: usize = 32; -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 = 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_27] = { let __args: [G; IN_27] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; 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_38: G = __r_arr[0]; 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 __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_22] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_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[22].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_23: usize = 33; -const IN_23: usize = 33; -const OUT_23: usize = 0; -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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_27] = { let __args: [G; IN_27] = [__v_0, __v_65, __v_66, __v_66, __v_67, __v_68, __v_69]; 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_70: G = __r_arr[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_70]; 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_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_23] = []; 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 = 1; -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 = 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_27] = { let __args: [G; IN_27] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; 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_38: G = __r_arr[0]; 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 __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_24] = [__v_71]; record.function_queries[24].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_25: usize = 34; -const IN_25: usize = 34; -const OUT_25: usize = 34; -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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_25] = [__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[25].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_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(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_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_25] = [__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[25].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_35] = { let __args: [G; IN_35] = [__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(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_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_25] = [__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[25].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_35] = { let __args: [G; IN_35] = [__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(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_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_25] = [__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[25].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_26: usize = 1; -const IN_26: usize = 1; -const OUT_26: usize = 32; -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; 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_26] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __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[26].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_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(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_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_26] = { let __args: [G; IN_26] = [__v_103]; 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_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_26] = [__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[26].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_26] = { let __args: [G; IN_26] = [__v_105]; 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_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_26] = [__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[26].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_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_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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_31] = { let __args: [G; IN_31] = [__v_9, __v_11, __v_3, __v_4, __v_5, __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_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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_9, __v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_15]; record.function_queries[27].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_28: usize = 1; -const IN_28: usize = 1; -const OUT_28: usize = 64; -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 __loaded: [G; 3] = { let __base = 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_28] = [__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[28].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_29: usize = 2; -const IN_29: 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 = G::from_u64(256); let __v_5: G = (__v_4 * __v_1); let __v_6: G = G::from_u64(65536); let __v_7: G = (__v_6 * __v_2); let __v_8: G = G::from_u64(16777216); let __v_9: G = (__v_8 * __v_3); let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_0 + __v_11); let __ret: [G; OUT_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 = G::from_u64(65536); let __v_35: G = (__v_34 * __v_2); let __v_36: G = G::from_u64(16777216); let __v_37: G = (__v_36 * __v_3); let __v_38: G = (__v_35 + __v_37); let __v_39: G = (__v_33 + __v_38); let __v_40: G = (__v_0 + __v_39); let __v_41: G = (__v_32 * __v_5); let __v_42: G = (__v_34 * __v_6); let __v_43: G = (__v_36 * __v_7); let __v_44: G = (__v_42 + __v_43); let __v_45: G = (__v_41 + __v_44); let __v_46: G = (__v_4 + __v_45); let __v_47: G = (__v_32 * __v_9); let __v_48: G = (__v_34 * __v_10); let __v_49: G = (__v_36 * __v_11); let __v_50: G = (__v_48 + __v_49); let __v_51: G = (__v_47 + __v_50); let __v_52: G = (__v_8 + __v_51); let __v_53: G = (__v_32 * __v_13); let __v_54: G = (__v_34 * __v_14); let __v_55: G = (__v_36 * __v_15); let __v_56: G = (__v_54 + __v_55); let __v_57: G = (__v_53 + __v_56); let __v_58: G = (__v_12 + __v_57); let __v_59: G = (__v_32 * __v_17); let __v_60: G = (__v_34 * __v_18); let __v_61: G = (__v_36 * __v_19); let __v_62: G = (__v_60 + __v_61); let __v_63: G = (__v_59 + __v_62); let __v_64: G = (__v_16 + __v_63); let __v_65: G = (__v_32 * __v_21); let __v_66: G = (__v_34 * __v_22); let __v_67: G = (__v_36 * __v_23); let __v_68: G = (__v_66 + __v_67); let __v_69: G = (__v_65 + __v_68); let __v_70: G = (__v_20 + __v_69); let __v_71: G = (__v_32 * __v_25); let __v_72: G = (__v_34 * __v_26); let __v_73: G = (__v_36 * __v_27); let __v_74: G = (__v_72 + __v_73); let __v_75: G = (__v_71 + __v_74); let __v_76: G = (__v_24 + __v_75); let __v_77: G = (__v_32 * __v_29); let __v_78: G = (__v_34 * __v_30); let __v_79: G = (__v_36 * __v_31); let __v_80: G = (__v_78 + __v_79); let __v_81: G = (__v_77 + __v_80); let __v_82: G = (__v_28 + __v_81); let __ret: [G; OUT_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_34] = { let __args: [G; IN_34] = [__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(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_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_34] = { let __args: [G; IN_34] = [__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(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_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_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __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_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_30] = { let __args: [G; IN_30] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_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 __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_26] = [__v_15]; record.function_queries[26].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +const INPUT_SIZE_27: usize = 1; +const IN_27: usize = 1; +const OUT_27: usize = 64; +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 __loaded: [G; 3] = { let __base = 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_27] = [__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[27].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_28: usize = 2; +const IN_28: usize = 2; +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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_28] = [__v_0]; record.function_queries[28].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_28] = { let __args: [G; IN_28] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_6]; record.function_queries[28].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_29: usize = 6; +const IN_29: usize = 6; 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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_29] = [__v_0]; record.function_queries[29].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_29] = { let __args: [G; IN_29] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_6]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_29(inp: [G; IN_29], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; match __v_9.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { match __v_12.as_canonical_u64() { 0u64 => { match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_6 + __v_7); let __v_18: G = (__v_8 + __v_17); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(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_34] = { let __args: [G; IN_34] = [__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(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_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_29] = [__v_107]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_29] = [__v_5]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_29] = [__v_5]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_29] = [__v_5]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_29] = [__v_5]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_29] = [__v_5]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_29] = [__v_5]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_29] = [__v_5]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_29] = [__v_5]; record.function_queries[29].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_29] = [__v_42]; record.function_queries[29].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_2 - __v_1); let __v_20: G = G::from_bool((__v_19 == G::ZERO)); let __v_21: G = (__v_20 * __v_6); let __v_22: G = (__v_18 + __v_21); let __v_23: G = (__v_7 + __v_22); let __v_24: G = G::from_u64(64); let __v_25: G = (__v_24 - __v_1); let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0, __v_25]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_26]; 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_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_34] = { let __args: [G; IN_34] = [__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(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_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_29] = [__v_171]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_30: usize = 6; const IN_30: usize = 6; const OUT_30: usize = 1; -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 = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; match __v_9.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { match __v_12.as_canonical_u64() { 0u64 => { match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_6 + __v_7); let __v_18: G = (__v_8 + __v_17); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(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_35] = { let __args: [G; IN_35] = [__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(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_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_30] = [__v_107]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_30] = [__v_5]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_30] = [__v_5]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_30] = [__v_5]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_30] = [__v_5]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_30] = [__v_5]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_30] = [__v_5]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_30] = [__v_5]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_30] = [__v_5]; record.function_queries[30].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_30] = [__v_42]; record.function_queries[30].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_7] = { let __args: [G; IN_7] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_2 - __v_1); let __v_20: G = G::from_bool((__v_19 == G::ZERO)); let __v_21: G = (__v_20 * __v_6); let __v_22: G = (__v_18 + __v_21); let __v_23: G = (__v_7 + __v_22); let __v_24: G = G::from_u64(64); let __v_25: G = (__v_24 - __v_1); let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0, __v_25]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_26]; 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_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_35] = { let __args: [G; IN_35] = [__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(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_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_30] = [__v_171]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_31: usize = 6; -const IN_31: usize = 6; -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]; let __v_2: G = 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_28] = { let __args: [G; IN_28] = [__v_1]; 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_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_795] = { let __args: [G; IN_795] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(795, (&__args[..]))?) { [G::ZERO; OUT_795] } else { let (__hash, __hit) = record.function_queries[795].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[795].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[795].bump_multiplicity(__i); } let __ret: [G; OUT_795] = unsafe { (*(record.function_queries[795].output_at(__i).as_ptr() as *const [G; OUT_795])) }; __ret }, _ => { aiur_fn_795::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; let __v_77: G = __loaded[3]; let __v_78: G = __loaded[4]; let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); let __v_85: G = (__v_84 + __v_7); let __v_86: G = G::from_u64(103); let __v_87: G = G::from_u64(230); let __v_88: G = G::from_u64(9); let __v_89: G = G::from_u64(106); let __v_90: G = G::from_u64(133); let __v_91: G = G::from_u64(174); let __v_92: G = G::from_u64(187); let __v_93: G = G::from_u64(114); let __v_94: G = G::from_u64(243); let __v_95: G = G::from_u64(110); let __v_96: G = G::from_u64(60); let __v_97: G = G::from_u64(58); let __v_98: G = G::from_u64(245); let __v_99: G = G::from_u64(79); let __v_100: G = G::from_u64(165); let __v_101: G = G::from_u64(127); let __v_102: G = G::from_u64(82); let __v_103: G = G::from_u64(14); let __v_104: G = G::from_u64(81); let __v_105: G = G::from_u64(140); let __v_106: G = G::from_u64(104); let __v_107: G = G::from_u64(5); let __v_108: G = G::from_u64(155); let __v_109: G = G::from_u64(171); let __v_110: G = G::from_u64(217); let __v_111: G = G::from_u64(131); let __v_112: G = G::from_u64(31); let __v_113: G = G::from_u64(25); let __v_114: G = G::from_u64(205); let __v_115: G = G::from_u64(224); let __v_116: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(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_35] = { let __args: [G; IN_35] = [__v_150, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_149, __v_150, __v_150, __v_150, __v_85, __v_150, __v_150, __v_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; 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_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_17] = { let __args: [G; IN_17] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; 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_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_27] = { let __args: [G; IN_27] = [__v_0, __v_185, __v_150, __v_150, __v_194, __v_195, __v_183]; 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_196: G = __r_arr[0]; let __ret: [G; OUT_31] = [__v_196]; record.function_queries[31].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(795, (&__args[..]))?) { [G::ZERO; OUT_795] } else { let (__hash, __hit) = record.function_queries[795].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[795].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[795].bump_multiplicity(__i); } let __ret: [G; OUT_795] = unsafe { (*(record.function_queries[795].output_at(__i).as_ptr() as *const [G; OUT_795])) }; __ret }, _ => { aiur_fn_795::(__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_795] = { let __args: [G; IN_795] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(795, (&__args[..]))?) { [G::ZERO; OUT_795] } else { let (__hash, __hit) = record.function_queries[795].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[795].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[795].bump_multiplicity(__i); } let __ret: [G; OUT_795] = unsafe { (*(record.function_queries[795].output_at(__i).as_ptr() as *const [G; OUT_795])) }; __ret }, _ => { aiur_fn_795::(__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_7] = { let __args: [G; IN_7] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); let __v_87: G = G::from_u64(63); let __v_88: G = (__v_2 - __v_87); let __v_89: G = G::from_bool((__v_88 == G::ZERO)); let __v_90: G = (__v_89 * __v_6); let __v_91: G = (__v_86 + __v_90); let __v_92: G = (__v_74 + __v_91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(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_35] = { let __args: [G; IN_35] = [__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(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_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_27] = { let __args: [G; IN_27] = [__v_0, __v_175, __v_141, __v_176, __v_3, __v_177, __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_178: G = __r_arr[0]; let __ret: [G; OUT_31] = [__v_178]; record.function_queries[31].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_32: usize = 24; -const IN_32: usize = 24; -const OUT_32: usize = 16; -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 = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))) + u128::from(((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); let __v_25: G = G::from_u8(__u32_bytes[1]); let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(2); let __v_32: G = (__v_28 - __v_31); let __v_33: G = (__v_30 * __v_32); let __v_34: G = (__v_28 * __v_33); let __v_35: G = G::from_u64(0); if (__v_34 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_36: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_12), (&__v_24)) } else { aiur::execute::bytes2_xor_value(__v_12, __v_24, record) }; let __v_37: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_13), (&__v_25)) } else { aiur::execute::bytes2_xor_value(__v_13, __v_25, record) }; let __v_38: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_14), (&__v_26)) } else { aiur::execute::bytes2_xor_value(__v_14, __v_26, record) }; let __v_39: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_15), (&__v_27)) } else { aiur::execute::bytes2_xor_value(__v_15, __v_27, record) }; let __u32_sum: u128 = (u128::from(((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24))) + u128::from(((((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8)) | (__v_36.as_canonical_u64() << 16)) | (__v_37.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_40: G = G::from_u8(__u32_bytes[0]); let __v_41: G = G::from_u8(__u32_bytes[1]); let __v_42: G = G::from_u8(__u32_bytes[2]); let __v_43: G = G::from_u8(__u32_bytes[3]); let __v_44: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_45: G = (__v_44 * __v_44); if (__v_45 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_4), (&__v_40)) } else { aiur::execute::bytes2_xor_split4_value(__v_4, __v_40, record) }; let __v_46: G = __b2_out.0; let __v_47: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_5), (&__v_41)) } else { aiur::execute::bytes2_xor_split4_value(__v_5, __v_41, record) }; let __v_48: G = __b2_out.0; let __v_49: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_6), (&__v_42)) } else { aiur::execute::bytes2_xor_split4_value(__v_6, __v_42, record) }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_7), (&__v_43)) } else { aiur::execute::bytes2_xor_split4_value(__v_7, __v_43, record) }; let __v_52: G = __b2_out.0; let __v_53: G = __b2_out.1; let __v_54: G = (__v_48 + __v_51); let __v_55: G = (__v_50 + __v_53); let __v_56: G = (__v_52 + __v_47); let __v_57: G = (__v_46 + __v_49); let __u32_sum: u128 = ((u128::from(((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24))) + u128::from(((((__v_54.as_canonical_u64() << 0) | (__v_55.as_canonical_u64() << 8)) | (__v_56.as_canonical_u64() << 16)) | (__v_57.as_canonical_u64() << 24)))) + u128::from(((((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_58: G = G::from_u8(__u32_bytes[0]); let __v_59: G = G::from_u8(__u32_bytes[1]); let __v_60: G = G::from_u8(__u32_bytes[2]); let __v_61: G = G::from_u8(__u32_bytes[3]); let __v_62: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_63: G = (__v_62 - __v_29); let __v_64: G = (__v_62 - __v_31); let __v_65: G = (__v_63 * __v_64); let __v_66: G = (__v_62 * __v_65); if (__v_66 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_67: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_38), (&__v_58)) } else { aiur::execute::bytes2_xor_value(__v_38, __v_58, record) }; let __v_68: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_39), (&__v_59)) } else { aiur::execute::bytes2_xor_value(__v_39, __v_59, record) }; let __v_69: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_36), (&__v_60)) } else { aiur::execute::bytes2_xor_value(__v_36, __v_60, record) }; let __v_70: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_37), (&__v_61)) } else { aiur::execute::bytes2_xor_value(__v_37, __v_61, record) }; let __u32_sum: u128 = (u128::from(((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24))) + u128::from(((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_71: G = G::from_u8(__u32_bytes[0]); let __v_72: G = G::from_u8(__u32_bytes[1]); let __v_73: G = G::from_u8(__u32_bytes[2]); let __v_74: G = G::from_u8(__u32_bytes[3]); let __v_75: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_71; let __vj = __v_72; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_73; let __vj = __v_74; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_76: G = (__v_75 * __v_75); if (__v_76 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_54), (&__v_71)) } else { aiur::execute::bytes2_xor_split7_value(__v_54, __v_71, record) }; let __v_77: G = __b2_out.0; let __v_78: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_55), (&__v_72)) } else { aiur::execute::bytes2_xor_split7_value(__v_55, __v_72, record) }; let __v_79: G = __b2_out.0; let __v_80: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_56), (&__v_73)) } else { aiur::execute::bytes2_xor_split7_value(__v_56, __v_73, record) }; let __v_81: G = __b2_out.0; let __v_82: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_57), (&__v_74)) } else { aiur::execute::bytes2_xor_split7_value(__v_57, __v_74, record) }; let __v_83: G = __b2_out.0; let __v_84: G = __b2_out.1; let __v_85: G = (__v_77 + __v_80); let __v_86: G = (__v_79 + __v_82); let __v_87: G = (__v_81 + __v_84); let __v_88: G = (__v_83 + __v_78); let __ret: [G; OUT_32] = [__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[32].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_33: usize = 128; -const IN_33: usize = 128; -const OUT_33: usize = 128; -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 = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)))) + u128::from(((((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8)) | (__v_66.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); let __v_129: G = G::from_u8(__u32_bytes[1]); let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_133: G = G::from_u64(1); let __v_134: G = (__v_132 - __v_133); let __v_135: G = G::from_u64(2); let __v_136: G = (__v_132 - __v_135); let __v_137: G = (__v_134 * __v_136); let __v_138: G = (__v_132 * __v_137); let __v_139: G = G::from_u64(0); if (__v_138 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_48), (&__v_128)) } else { aiur::execute::bytes2_xor_value(__v_48, __v_128, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_49), (&__v_129)) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_50), (&__v_130)) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_51), (&__v_131)) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __u32_sum: u128 = (u128::from(((((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8)) | (__v_34.as_canonical_u64() << 16)) | (__v_35.as_canonical_u64() << 24))) + u128::from(((((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8)) | (__v_140.as_canonical_u64() << 16)) | (__v_141.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_144: G = G::from_u8(__u32_bytes[0]); let __v_145: G = G::from_u8(__u32_bytes[1]); let __v_146: G = G::from_u8(__u32_bytes[2]); let __v_147: G = G::from_u8(__u32_bytes[3]); let __v_148: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_146; let __vj = __v_147; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_149: G = (__v_148 * __v_148); if (__v_149 != __v_148) { return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_16), (&__v_144)) } else { aiur::execute::bytes2_xor_split4_value(__v_16, __v_144, record) }; let __v_150: G = __b2_out.0; let __v_151: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_17), (&__v_145)) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_152: G = __b2_out.0; let __v_153: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_18), (&__v_146)) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_154: G = __b2_out.0; let __v_155: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_19), (&__v_147)) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_156: G = __b2_out.0; let __v_157: G = __b2_out.1; let __v_158: G = (__v_152 + __v_155); let __v_159: G = (__v_154 + __v_157); let __v_160: G = (__v_156 + __v_151); let __v_161: G = (__v_150 + __v_153); let __u32_sum: u128 = ((u128::from(((((__v_128.as_canonical_u64() << 0) | (__v_129.as_canonical_u64() << 8)) | (__v_130.as_canonical_u64() << 16)) | (__v_131.as_canonical_u64() << 24))) + u128::from(((((__v_158.as_canonical_u64() << 0) | (__v_159.as_canonical_u64() << 8)) | (__v_160.as_canonical_u64() << 16)) | (__v_161.as_canonical_u64() << 24)))) + u128::from(((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_71.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_162: G = G::from_u8(__u32_bytes[0]); let __v_163: G = G::from_u8(__u32_bytes[1]); let __v_164: G = G::from_u8(__u32_bytes[2]); let __v_165: G = G::from_u8(__u32_bytes[3]); let __v_166: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_162; let __vj = __v_163; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_164; let __vj = __v_165; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_167: G = (__v_166 - __v_133); let __v_168: G = (__v_166 - __v_135); let __v_169: G = (__v_167 * __v_168); let __v_170: G = (__v_166 * __v_169); if (__v_170 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_171: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_142), (&__v_162)) } else { aiur::execute::bytes2_xor_value(__v_142, __v_162, record) }; let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_143), (&__v_163)) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_140), (&__v_164)) } else { aiur::execute::bytes2_xor_value(__v_140, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_141), (&__v_165)) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __u32_sum: u128 = (u128::from(((((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8)) | (__v_146.as_canonical_u64() << 16)) | (__v_147.as_canonical_u64() << 24))) + u128::from(((((__v_172.as_canonical_u64() << 0) | (__v_173.as_canonical_u64() << 8)) | (__v_174.as_canonical_u64() << 16)) | (__v_171.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_175: G = G::from_u8(__u32_bytes[0]); let __v_176: G = G::from_u8(__u32_bytes[1]); let __v_177: G = G::from_u8(__u32_bytes[2]); let __v_178: G = G::from_u8(__u32_bytes[3]); let __v_179: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_175; let __vj = __v_176; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_177; let __vj = __v_178; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_180: G = (__v_179 * __v_179); if (__v_180 != __v_179) { return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_179.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_158), (&__v_175)) } else { aiur::execute::bytes2_xor_split7_value(__v_158, __v_175, record) }; let __v_181: G = __b2_out.0; let __v_182: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_159), (&__v_176)) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_183: G = __b2_out.0; let __v_184: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_160), (&__v_177)) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_185: G = __b2_out.0; let __v_186: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_161), (&__v_178)) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_187: G = __b2_out.0; let __v_188: G = __b2_out.1; let __v_189: G = (__v_181 + __v_184); let __v_190: G = (__v_183 + __v_186); let __v_191: G = (__v_185 + __v_188); let __v_192: G = (__v_187 + __v_182); let __u32_sum: u128 = ((u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24))) + u128::from(((((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24)))) + u128::from(((((__v_72.as_canonical_u64() << 0) | (__v_73.as_canonical_u64() << 8)) | (__v_74.as_canonical_u64() << 16)) | (__v_75.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_193: G = G::from_u8(__u32_bytes[0]); let __v_194: G = G::from_u8(__u32_bytes[1]); let __v_195: G = G::from_u8(__u32_bytes[2]); let __v_196: G = G::from_u8(__u32_bytes[3]); let __v_197: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_193; let __vj = __v_194; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_195; let __vj = __v_196; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_198: G = (__v_197 - __v_133); let __v_199: G = (__v_197 - __v_135); let __v_200: G = (__v_198 * __v_199); let __v_201: G = (__v_197 * __v_200); if (__v_201 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_201.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_202: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_52), (&__v_193)) } else { aiur::execute::bytes2_xor_value(__v_52, __v_193, record) }; let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_53), (&__v_194)) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_54), (&__v_195)) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_55), (&__v_196)) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __u32_sum: u128 = (u128::from(((((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8)) | (__v_38.as_canonical_u64() << 16)) | (__v_39.as_canonical_u64() << 24))) + u128::from(((((__v_204.as_canonical_u64() << 0) | (__v_205.as_canonical_u64() << 8)) | (__v_202.as_canonical_u64() << 16)) | (__v_203.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_206: G = G::from_u8(__u32_bytes[0]); let __v_207: G = G::from_u8(__u32_bytes[1]); let __v_208: G = G::from_u8(__u32_bytes[2]); let __v_209: G = G::from_u8(__u32_bytes[3]); let __v_210: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_206; let __vj = __v_207; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_208; let __vj = __v_209; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_211: G = (__v_210 * __v_210); if (__v_211 != __v_210) { return Err(ExecError::AssertEqMismatch { lhs: __v_211.as_canonical_u64(), rhs: __v_210.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_20), (&__v_206)) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_206, record) }; let __v_212: G = __b2_out.0; let __v_213: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_21), (&__v_207)) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_214: G = __b2_out.0; let __v_215: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_22), (&__v_208)) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_216: G = __b2_out.0; let __v_217: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_23), (&__v_209)) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_218: G = __b2_out.0; let __v_219: G = __b2_out.1; let __v_220: G = (__v_214 + __v_217); let __v_221: G = (__v_216 + __v_219); let __v_222: G = (__v_218 + __v_213); let __v_223: G = (__v_212 + __v_215); let __u32_sum: u128 = ((u128::from(((((__v_193.as_canonical_u64() << 0) | (__v_194.as_canonical_u64() << 8)) | (__v_195.as_canonical_u64() << 16)) | (__v_196.as_canonical_u64() << 24))) + u128::from(((((__v_220.as_canonical_u64() << 0) | (__v_221.as_canonical_u64() << 8)) | (__v_222.as_canonical_u64() << 16)) | (__v_223.as_canonical_u64() << 24)))) + u128::from(((((__v_76.as_canonical_u64() << 0) | (__v_77.as_canonical_u64() << 8)) | (__v_78.as_canonical_u64() << 16)) | (__v_79.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_224: G = G::from_u8(__u32_bytes[0]); let __v_225: G = G::from_u8(__u32_bytes[1]); let __v_226: G = G::from_u8(__u32_bytes[2]); let __v_227: G = G::from_u8(__u32_bytes[3]); let __v_228: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_224; let __vj = __v_225; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_226; let __vj = __v_227; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_229: G = (__v_228 - __v_133); let __v_230: G = (__v_228 - __v_135); let __v_231: G = (__v_229 * __v_230); let __v_232: G = (__v_228 * __v_231); if (__v_232 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_233: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_204), (&__v_224)) } else { aiur::execute::bytes2_xor_value(__v_204, __v_224, record) }; let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_205), (&__v_225)) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_202), (&__v_226)) } else { aiur::execute::bytes2_xor_value(__v_202, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_203), (&__v_227)) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __u32_sum: u128 = (u128::from(((((__v_206.as_canonical_u64() << 0) | (__v_207.as_canonical_u64() << 8)) | (__v_208.as_canonical_u64() << 16)) | (__v_209.as_canonical_u64() << 24))) + u128::from(((((__v_234.as_canonical_u64() << 0) | (__v_235.as_canonical_u64() << 8)) | (__v_236.as_canonical_u64() << 16)) | (__v_233.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_237: G = G::from_u8(__u32_bytes[0]); let __v_238: G = G::from_u8(__u32_bytes[1]); let __v_239: G = G::from_u8(__u32_bytes[2]); let __v_240: G = G::from_u8(__u32_bytes[3]); let __v_241: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_237; let __vj = __v_238; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_239; let __vj = __v_240; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_242: G = (__v_241 * __v_241); if (__v_242 != __v_241) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_220), (&__v_237)) } else { aiur::execute::bytes2_xor_split7_value(__v_220, __v_237, record) }; let __v_243: G = __b2_out.0; let __v_244: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_221), (&__v_238)) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_245: G = __b2_out.0; let __v_246: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_222), (&__v_239)) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_247: G = __b2_out.0; let __v_248: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_223), (&__v_240)) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_249: G = __b2_out.0; let __v_250: G = __b2_out.1; let __v_251: G = (__v_243 + __v_246); let __v_252: G = (__v_245 + __v_248); let __v_253: G = (__v_247 + __v_250); let __v_254: G = (__v_249 + __v_244); let __u32_sum: u128 = ((u128::from(((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24))) + u128::from(((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24)))) + u128::from(((((__v_80.as_canonical_u64() << 0) | (__v_81.as_canonical_u64() << 8)) | (__v_82.as_canonical_u64() << 16)) | (__v_83.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_255: G = G::from_u8(__u32_bytes[0]); let __v_256: G = G::from_u8(__u32_bytes[1]); let __v_257: G = G::from_u8(__u32_bytes[2]); let __v_258: G = G::from_u8(__u32_bytes[3]); let __v_259: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_255; let __vj = __v_256; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_257; let __vj = __v_258; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_260: G = (__v_259 - __v_133); let __v_261: G = (__v_259 - __v_135); let __v_262: G = (__v_260 * __v_261); let __v_263: G = (__v_259 * __v_262); if (__v_263 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_263.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_264: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_56), (&__v_255)) } else { aiur::execute::bytes2_xor_value(__v_56, __v_255, record) }; let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_57), (&__v_256)) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_58), (&__v_257)) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_59), (&__v_258)) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __u32_sum: u128 = (u128::from(((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24))) + u128::from(((((__v_266.as_canonical_u64() << 0) | (__v_267.as_canonical_u64() << 8)) | (__v_264.as_canonical_u64() << 16)) | (__v_265.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_268: G = G::from_u8(__u32_bytes[0]); let __v_269: G = G::from_u8(__u32_bytes[1]); let __v_270: G = G::from_u8(__u32_bytes[2]); let __v_271: G = G::from_u8(__u32_bytes[3]); let __v_272: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_270; let __vj = __v_271; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_273: G = (__v_272 * __v_272); if (__v_273 != __v_272) { return Err(ExecError::AssertEqMismatch { lhs: __v_273.as_canonical_u64(), rhs: __v_272.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_24), (&__v_268)) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_268, record) }; let __v_274: G = __b2_out.0; let __v_275: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_25), (&__v_269)) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_276: G = __b2_out.0; let __v_277: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_26), (&__v_270)) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_278: G = __b2_out.0; let __v_279: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_27), (&__v_271)) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_280: G = __b2_out.0; let __v_281: G = __b2_out.1; let __v_282: G = (__v_276 + __v_279); let __v_283: G = (__v_278 + __v_281); let __v_284: G = (__v_280 + __v_275); let __v_285: G = (__v_274 + __v_277); let __u32_sum: u128 = ((u128::from(((((__v_255.as_canonical_u64() << 0) | (__v_256.as_canonical_u64() << 8)) | (__v_257.as_canonical_u64() << 16)) | (__v_258.as_canonical_u64() << 24))) + u128::from(((((__v_282.as_canonical_u64() << 0) | (__v_283.as_canonical_u64() << 8)) | (__v_284.as_canonical_u64() << 16)) | (__v_285.as_canonical_u64() << 24)))) + u128::from(((((__v_84.as_canonical_u64() << 0) | (__v_85.as_canonical_u64() << 8)) | (__v_86.as_canonical_u64() << 16)) | (__v_87.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_286: G = G::from_u8(__u32_bytes[0]); let __v_287: G = G::from_u8(__u32_bytes[1]); let __v_288: G = G::from_u8(__u32_bytes[2]); let __v_289: G = G::from_u8(__u32_bytes[3]); let __v_290: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_286; let __vj = __v_287; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_288; let __vj = __v_289; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_291: G = (__v_290 - __v_133); let __v_292: G = (__v_290 - __v_135); let __v_293: G = (__v_291 * __v_292); let __v_294: G = (__v_290 * __v_293); if (__v_294 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_294.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_295: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_266), (&__v_286)) } else { aiur::execute::bytes2_xor_value(__v_266, __v_286, record) }; let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_267), (&__v_287)) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_264), (&__v_288)) } else { aiur::execute::bytes2_xor_value(__v_264, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_265), (&__v_289)) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __u32_sum: u128 = (u128::from(((((__v_268.as_canonical_u64() << 0) | (__v_269.as_canonical_u64() << 8)) | (__v_270.as_canonical_u64() << 16)) | (__v_271.as_canonical_u64() << 24))) + u128::from(((((__v_296.as_canonical_u64() << 0) | (__v_297.as_canonical_u64() << 8)) | (__v_298.as_canonical_u64() << 16)) | (__v_295.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_299: G = G::from_u8(__u32_bytes[0]); let __v_300: G = G::from_u8(__u32_bytes[1]); let __v_301: G = G::from_u8(__u32_bytes[2]); let __v_302: G = G::from_u8(__u32_bytes[3]); let __v_303: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_299; let __vj = __v_300; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_301; let __vj = __v_302; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_304: G = (__v_303 * __v_303); if (__v_304 != __v_303) { return Err(ExecError::AssertEqMismatch { lhs: __v_304.as_canonical_u64(), rhs: __v_303.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_282), (&__v_299)) } else { aiur::execute::bytes2_xor_split7_value(__v_282, __v_299, record) }; let __v_305: G = __b2_out.0; let __v_306: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_283), (&__v_300)) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_307: G = __b2_out.0; let __v_308: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_284), (&__v_301)) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_309: G = __b2_out.0; let __v_310: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_285), (&__v_302)) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_311: G = __b2_out.0; let __v_312: G = __b2_out.1; let __v_313: G = (__v_305 + __v_308); let __v_314: G = (__v_307 + __v_310); let __v_315: G = (__v_309 + __v_312); let __v_316: G = (__v_311 + __v_306); let __u32_sum: u128 = ((u128::from(((((__v_12.as_canonical_u64() << 0) | (__v_13.as_canonical_u64() << 8)) | (__v_14.as_canonical_u64() << 16)) | (__v_15.as_canonical_u64() << 24))) + u128::from(((((__v_28.as_canonical_u64() << 0) | (__v_29.as_canonical_u64() << 8)) | (__v_30.as_canonical_u64() << 16)) | (__v_31.as_canonical_u64() << 24)))) + u128::from(((((__v_88.as_canonical_u64() << 0) | (__v_89.as_canonical_u64() << 8)) | (__v_90.as_canonical_u64() << 16)) | (__v_91.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_317: G = G::from_u8(__u32_bytes[0]); let __v_318: G = G::from_u8(__u32_bytes[1]); let __v_319: G = G::from_u8(__u32_bytes[2]); let __v_320: G = G::from_u8(__u32_bytes[3]); let __v_321: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_317; let __vj = __v_318; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_319; let __vj = __v_320; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_322: G = (__v_321 - __v_133); let __v_323: G = (__v_321 - __v_135); let __v_324: G = (__v_322 * __v_323); let __v_325: G = (__v_321 * __v_324); if (__v_325 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_325.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_326: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_60), (&__v_317)) } else { aiur::execute::bytes2_xor_value(__v_60, __v_317, record) }; let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_61), (&__v_318)) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_62), (&__v_319)) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_63), (&__v_320)) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __u32_sum: u128 = (u128::from(((((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8)) | (__v_46.as_canonical_u64() << 16)) | (__v_47.as_canonical_u64() << 24))) + u128::from(((((__v_328.as_canonical_u64() << 0) | (__v_329.as_canonical_u64() << 8)) | (__v_326.as_canonical_u64() << 16)) | (__v_327.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_330: G = G::from_u8(__u32_bytes[0]); let __v_331: G = G::from_u8(__u32_bytes[1]); let __v_332: G = G::from_u8(__u32_bytes[2]); let __v_333: G = G::from_u8(__u32_bytes[3]); let __v_334: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_330; let __vj = __v_331; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_332; let __vj = __v_333; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_335: G = (__v_334 * __v_334); if (__v_335 != __v_334) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_334.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_28), (&__v_330)) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_330, record) }; let __v_336: G = __b2_out.0; let __v_337: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_29), (&__v_331)) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_338: G = __b2_out.0; let __v_339: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_30), (&__v_332)) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_340: G = __b2_out.0; let __v_341: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_31), (&__v_333)) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_342: G = __b2_out.0; let __v_343: G = __b2_out.1; let __v_344: G = (__v_338 + __v_341); let __v_345: G = (__v_340 + __v_343); let __v_346: G = (__v_342 + __v_337); let __v_347: G = (__v_336 + __v_339); let __u32_sum: u128 = ((u128::from(((((__v_317.as_canonical_u64() << 0) | (__v_318.as_canonical_u64() << 8)) | (__v_319.as_canonical_u64() << 16)) | (__v_320.as_canonical_u64() << 24))) + u128::from(((((__v_344.as_canonical_u64() << 0) | (__v_345.as_canonical_u64() << 8)) | (__v_346.as_canonical_u64() << 16)) | (__v_347.as_canonical_u64() << 24)))) + u128::from(((((__v_92.as_canonical_u64() << 0) | (__v_93.as_canonical_u64() << 8)) | (__v_94.as_canonical_u64() << 16)) | (__v_95.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_348: G = G::from_u8(__u32_bytes[0]); let __v_349: G = G::from_u8(__u32_bytes[1]); let __v_350: G = G::from_u8(__u32_bytes[2]); let __v_351: G = G::from_u8(__u32_bytes[3]); let __v_352: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_348; let __vj = __v_349; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_350; let __vj = __v_351; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_353: G = (__v_352 - __v_133); let __v_354: G = (__v_352 - __v_135); let __v_355: G = (__v_353 * __v_354); let __v_356: G = (__v_352 * __v_355); if (__v_356 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_357: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_328), (&__v_348)) } else { aiur::execute::bytes2_xor_value(__v_328, __v_348, record) }; let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_329), (&__v_349)) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_326), (&__v_350)) } else { aiur::execute::bytes2_xor_value(__v_326, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_327), (&__v_351)) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __u32_sum: u128 = (u128::from(((((__v_330.as_canonical_u64() << 0) | (__v_331.as_canonical_u64() << 8)) | (__v_332.as_canonical_u64() << 16)) | (__v_333.as_canonical_u64() << 24))) + u128::from(((((__v_358.as_canonical_u64() << 0) | (__v_359.as_canonical_u64() << 8)) | (__v_360.as_canonical_u64() << 16)) | (__v_357.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_361: G = G::from_u8(__u32_bytes[0]); let __v_362: G = G::from_u8(__u32_bytes[1]); let __v_363: G = G::from_u8(__u32_bytes[2]); let __v_364: G = G::from_u8(__u32_bytes[3]); let __v_365: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_361; let __vj = __v_362; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_363; let __vj = __v_364; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_366: G = (__v_365 * __v_365); if (__v_366 != __v_365) { return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_365.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_344), (&__v_361)) } else { aiur::execute::bytes2_xor_split7_value(__v_344, __v_361, record) }; let __v_367: G = __b2_out.0; let __v_368: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_345), (&__v_362)) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_369: G = __b2_out.0; let __v_370: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_346), (&__v_363)) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_371: G = __b2_out.0; let __v_372: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_347), (&__v_364)) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_373: G = __b2_out.0; let __v_374: G = __b2_out.1; let __v_375: G = (__v_367 + __v_370); let __v_376: G = (__v_369 + __v_372); let __v_377: G = (__v_371 + __v_374); let __v_378: G = (__v_373 + __v_368); let __u32_sum: u128 = ((u128::from(((((__v_162.as_canonical_u64() << 0) | (__v_163.as_canonical_u64() << 8)) | (__v_164.as_canonical_u64() << 16)) | (__v_165.as_canonical_u64() << 24))) + u128::from(((((__v_251.as_canonical_u64() << 0) | (__v_252.as_canonical_u64() << 8)) | (__v_253.as_canonical_u64() << 16)) | (__v_254.as_canonical_u64() << 24)))) + u128::from(((((__v_96.as_canonical_u64() << 0) | (__v_97.as_canonical_u64() << 8)) | (__v_98.as_canonical_u64() << 16)) | (__v_99.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_379: G = G::from_u8(__u32_bytes[0]); let __v_380: G = G::from_u8(__u32_bytes[1]); let __v_381: G = G::from_u8(__u32_bytes[2]); let __v_382: G = G::from_u8(__u32_bytes[3]); let __v_383: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_379; let __vj = __v_380; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_381; let __vj = __v_382; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_384: G = (__v_383 - __v_133); let __v_385: G = (__v_383 - __v_135); let __v_386: G = (__v_384 * __v_385); let __v_387: G = (__v_383 * __v_386); if (__v_387 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_388: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_358), (&__v_379)) } else { aiur::execute::bytes2_xor_value(__v_358, __v_379, record) }; let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_359), (&__v_380)) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_360), (&__v_381)) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_357), (&__v_382)) } else { aiur::execute::bytes2_xor_value(__v_357, __v_382, record) }; let __u32_sum: u128 = (u128::from(((((__v_299.as_canonical_u64() << 0) | (__v_300.as_canonical_u64() << 8)) | (__v_301.as_canonical_u64() << 16)) | (__v_302.as_canonical_u64() << 24))) + u128::from(((((__v_390.as_canonical_u64() << 0) | (__v_391.as_canonical_u64() << 8)) | (__v_388.as_canonical_u64() << 16)) | (__v_389.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_392: G = G::from_u8(__u32_bytes[0]); let __v_393: G = G::from_u8(__u32_bytes[1]); let __v_394: G = G::from_u8(__u32_bytes[2]); let __v_395: G = G::from_u8(__u32_bytes[3]); let __v_396: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_392; let __vj = __v_393; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_394; let __vj = __v_395; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_397: G = (__v_396 * __v_396); if (__v_397 != __v_396) { return Err(ExecError::AssertEqMismatch { lhs: __v_397.as_canonical_u64(), rhs: __v_396.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_251), (&__v_392)) } else { aiur::execute::bytes2_xor_split4_value(__v_251, __v_392, record) }; let __v_398: G = __b2_out.0; let __v_399: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_252), (&__v_393)) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_400: G = __b2_out.0; let __v_401: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_253), (&__v_394)) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_402: G = __b2_out.0; let __v_403: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_254), (&__v_395)) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_404: G = __b2_out.0; let __v_405: G = __b2_out.1; let __v_406: G = (__v_400 + __v_403); let __v_407: G = (__v_402 + __v_405); let __v_408: G = (__v_404 + __v_399); let __v_409: G = (__v_398 + __v_401); let __u32_sum: u128 = ((u128::from(((((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8)) | (__v_381.as_canonical_u64() << 16)) | (__v_382.as_canonical_u64() << 24))) + u128::from(((((__v_406.as_canonical_u64() << 0) | (__v_407.as_canonical_u64() << 8)) | (__v_408.as_canonical_u64() << 16)) | (__v_409.as_canonical_u64() << 24)))) + u128::from(((((__v_100.as_canonical_u64() << 0) | (__v_101.as_canonical_u64() << 8)) | (__v_102.as_canonical_u64() << 16)) | (__v_103.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_410: G = G::from_u8(__u32_bytes[0]); let __v_411: G = G::from_u8(__u32_bytes[1]); let __v_412: G = G::from_u8(__u32_bytes[2]); let __v_413: G = G::from_u8(__u32_bytes[3]); let __v_414: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_410; let __vj = __v_411; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_412; let __vj = __v_413; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_415: G = (__v_414 - __v_133); let __v_416: G = (__v_414 - __v_135); let __v_417: G = (__v_415 * __v_416); let __v_418: G = (__v_414 * __v_417); if (__v_418 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_418.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_419: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_390), (&__v_410)) } else { aiur::execute::bytes2_xor_value(__v_390, __v_410, record) }; let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_391), (&__v_411)) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_388), (&__v_412)) } else { aiur::execute::bytes2_xor_value(__v_388, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_389), (&__v_413)) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __u32_sum: u128 = (u128::from(((((__v_392.as_canonical_u64() << 0) | (__v_393.as_canonical_u64() << 8)) | (__v_394.as_canonical_u64() << 16)) | (__v_395.as_canonical_u64() << 24))) + u128::from(((((__v_420.as_canonical_u64() << 0) | (__v_421.as_canonical_u64() << 8)) | (__v_422.as_canonical_u64() << 16)) | (__v_419.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_423: G = G::from_u8(__u32_bytes[0]); let __v_424: G = G::from_u8(__u32_bytes[1]); let __v_425: G = G::from_u8(__u32_bytes[2]); let __v_426: G = G::from_u8(__u32_bytes[3]); let __v_427: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_423; let __vj = __v_424; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_425; let __vj = __v_426; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_428: G = (__v_427 * __v_427); if (__v_428 != __v_427) { return Err(ExecError::AssertEqMismatch { lhs: __v_428.as_canonical_u64(), rhs: __v_427.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_406), (&__v_423)) } else { aiur::execute::bytes2_xor_split7_value(__v_406, __v_423, record) }; let __v_429: G = __b2_out.0; let __v_430: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_407), (&__v_424)) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_431: G = __b2_out.0; let __v_432: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_408), (&__v_425)) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_433: G = __b2_out.0; let __v_434: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_409), (&__v_426)) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_435: G = __b2_out.0; let __v_436: G = __b2_out.1; let __v_437: G = (__v_429 + __v_432); let __v_438: G = (__v_431 + __v_434); let __v_439: G = (__v_433 + __v_436); let __v_440: G = (__v_435 + __v_430); let __u32_sum: u128 = ((u128::from(((((__v_224.as_canonical_u64() << 0) | (__v_225.as_canonical_u64() << 8)) | (__v_226.as_canonical_u64() << 16)) | (__v_227.as_canonical_u64() << 24))) + u128::from(((((__v_313.as_canonical_u64() << 0) | (__v_314.as_canonical_u64() << 8)) | (__v_315.as_canonical_u64() << 16)) | (__v_316.as_canonical_u64() << 24)))) + u128::from(((((__v_104.as_canonical_u64() << 0) | (__v_105.as_canonical_u64() << 8)) | (__v_106.as_canonical_u64() << 16)) | (__v_107.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_441: G = G::from_u8(__u32_bytes[0]); let __v_442: G = G::from_u8(__u32_bytes[1]); let __v_443: G = G::from_u8(__u32_bytes[2]); let __v_444: G = G::from_u8(__u32_bytes[3]); let __v_445: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_441; let __vj = __v_442; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_443; let __vj = __v_444; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_446: G = (__v_445 - __v_133); let __v_447: G = (__v_445 - __v_135); let __v_448: G = (__v_446 * __v_447); let __v_449: G = (__v_445 * __v_448); if (__v_449 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_449.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_450: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_172), (&__v_441)) } else { aiur::execute::bytes2_xor_value(__v_172, __v_441, record) }; let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_173), (&__v_442)) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_174), (&__v_443)) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_171), (&__v_444)) } else { aiur::execute::bytes2_xor_value(__v_171, __v_444, record) }; let __u32_sum: u128 = (u128::from(((((__v_361.as_canonical_u64() << 0) | (__v_362.as_canonical_u64() << 8)) | (__v_363.as_canonical_u64() << 16)) | (__v_364.as_canonical_u64() << 24))) + u128::from(((((__v_452.as_canonical_u64() << 0) | (__v_453.as_canonical_u64() << 8)) | (__v_450.as_canonical_u64() << 16)) | (__v_451.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_454: G = G::from_u8(__u32_bytes[0]); let __v_455: G = G::from_u8(__u32_bytes[1]); let __v_456: G = G::from_u8(__u32_bytes[2]); let __v_457: G = G::from_u8(__u32_bytes[3]); let __v_458: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_454; let __vj = __v_455; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_456; let __vj = __v_457; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_459: G = (__v_458 * __v_458); if (__v_459 != __v_458) { return Err(ExecError::AssertEqMismatch { lhs: __v_459.as_canonical_u64(), rhs: __v_458.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_313), (&__v_454)) } else { aiur::execute::bytes2_xor_split4_value(__v_313, __v_454, record) }; let __v_460: G = __b2_out.0; let __v_461: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_314), (&__v_455)) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_462: G = __b2_out.0; let __v_463: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_315), (&__v_456)) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_464: G = __b2_out.0; let __v_465: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_316), (&__v_457)) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_466: G = __b2_out.0; let __v_467: G = __b2_out.1; let __v_468: G = (__v_462 + __v_465); let __v_469: G = (__v_464 + __v_467); let __v_470: G = (__v_466 + __v_461); let __v_471: G = (__v_460 + __v_463); let __u32_sum: u128 = ((u128::from(((((__v_441.as_canonical_u64() << 0) | (__v_442.as_canonical_u64() << 8)) | (__v_443.as_canonical_u64() << 16)) | (__v_444.as_canonical_u64() << 24))) + u128::from(((((__v_468.as_canonical_u64() << 0) | (__v_469.as_canonical_u64() << 8)) | (__v_470.as_canonical_u64() << 16)) | (__v_471.as_canonical_u64() << 24)))) + u128::from(((((__v_108.as_canonical_u64() << 0) | (__v_109.as_canonical_u64() << 8)) | (__v_110.as_canonical_u64() << 16)) | (__v_111.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_472: G = G::from_u8(__u32_bytes[0]); let __v_473: G = G::from_u8(__u32_bytes[1]); let __v_474: G = G::from_u8(__u32_bytes[2]); let __v_475: G = G::from_u8(__u32_bytes[3]); let __v_476: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_472; let __vj = __v_473; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_474; let __vj = __v_475; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_477: G = (__v_476 - __v_133); let __v_478: G = (__v_476 - __v_135); let __v_479: G = (__v_477 * __v_478); let __v_480: G = (__v_476 * __v_479); if (__v_480 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_481: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_452), (&__v_472)) } else { aiur::execute::bytes2_xor_value(__v_452, __v_472, record) }; let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_453), (&__v_473)) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_450), (&__v_474)) } else { aiur::execute::bytes2_xor_value(__v_450, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_451), (&__v_475)) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __u32_sum: u128 = (u128::from(((((__v_454.as_canonical_u64() << 0) | (__v_455.as_canonical_u64() << 8)) | (__v_456.as_canonical_u64() << 16)) | (__v_457.as_canonical_u64() << 24))) + u128::from(((((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8)) | (__v_484.as_canonical_u64() << 16)) | (__v_481.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_485: G = G::from_u8(__u32_bytes[0]); let __v_486: G = G::from_u8(__u32_bytes[1]); let __v_487: G = G::from_u8(__u32_bytes[2]); let __v_488: G = G::from_u8(__u32_bytes[3]); let __v_489: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_485; let __vj = __v_486; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_487; let __vj = __v_488; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_490: G = (__v_489 * __v_489); if (__v_490 != __v_489) { return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_468), (&__v_485)) } else { aiur::execute::bytes2_xor_split7_value(__v_468, __v_485, record) }; let __v_491: G = __b2_out.0; let __v_492: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_469), (&__v_486)) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_493: G = __b2_out.0; let __v_494: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_470), (&__v_487)) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_495: G = __b2_out.0; let __v_496: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_471), (&__v_488)) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_497: G = __b2_out.0; let __v_498: G = __b2_out.1; let __v_499: G = (__v_491 + __v_494); let __v_500: G = (__v_493 + __v_496); let __v_501: G = (__v_495 + __v_498); let __v_502: G = (__v_497 + __v_492); let __u32_sum: u128 = ((u128::from(((((__v_286.as_canonical_u64() << 0) | (__v_287.as_canonical_u64() << 8)) | (__v_288.as_canonical_u64() << 16)) | (__v_289.as_canonical_u64() << 24))) + u128::from(((((__v_375.as_canonical_u64() << 0) | (__v_376.as_canonical_u64() << 8)) | (__v_377.as_canonical_u64() << 16)) | (__v_378.as_canonical_u64() << 24)))) + u128::from(((((__v_112.as_canonical_u64() << 0) | (__v_113.as_canonical_u64() << 8)) | (__v_114.as_canonical_u64() << 16)) | (__v_115.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_503: G = G::from_u8(__u32_bytes[0]); let __v_504: G = G::from_u8(__u32_bytes[1]); let __v_505: G = G::from_u8(__u32_bytes[2]); let __v_506: G = G::from_u8(__u32_bytes[3]); let __v_507: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_503; let __vj = __v_504; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_505; let __vj = __v_506; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_508: G = (__v_507 - __v_133); let __v_509: G = (__v_507 - __v_135); let __v_510: G = (__v_508 * __v_509); let __v_511: G = (__v_507 * __v_510); if (__v_511 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_511.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_512: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_234), (&__v_503)) } else { aiur::execute::bytes2_xor_value(__v_234, __v_503, record) }; let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_235), (&__v_504)) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_236), (&__v_505)) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_233), (&__v_506)) } else { aiur::execute::bytes2_xor_value(__v_233, __v_506, record) }; let __u32_sum: u128 = (u128::from(((((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8)) | (__v_177.as_canonical_u64() << 16)) | (__v_178.as_canonical_u64() << 24))) + u128::from(((((__v_514.as_canonical_u64() << 0) | (__v_515.as_canonical_u64() << 8)) | (__v_512.as_canonical_u64() << 16)) | (__v_513.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_516: G = G::from_u8(__u32_bytes[0]); let __v_517: G = G::from_u8(__u32_bytes[1]); let __v_518: G = G::from_u8(__u32_bytes[2]); let __v_519: G = G::from_u8(__u32_bytes[3]); let __v_520: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_516; let __vj = __v_517; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_518; let __vj = __v_519; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_521: G = (__v_520 * __v_520); if (__v_521 != __v_520) { return Err(ExecError::AssertEqMismatch { lhs: __v_521.as_canonical_u64(), rhs: __v_520.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_375), (&__v_516)) } else { aiur::execute::bytes2_xor_split4_value(__v_375, __v_516, record) }; let __v_522: G = __b2_out.0; let __v_523: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_376), (&__v_517)) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_524: G = __b2_out.0; let __v_525: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_377), (&__v_518)) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_526: G = __b2_out.0; let __v_527: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_378), (&__v_519)) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_528: G = __b2_out.0; let __v_529: G = __b2_out.1; let __v_530: G = (__v_524 + __v_527); let __v_531: G = (__v_526 + __v_529); let __v_532: G = (__v_528 + __v_523); let __v_533: G = (__v_522 + __v_525); let __u32_sum: u128 = ((u128::from(((((__v_503.as_canonical_u64() << 0) | (__v_504.as_canonical_u64() << 8)) | (__v_505.as_canonical_u64() << 16)) | (__v_506.as_canonical_u64() << 24))) + u128::from(((((__v_530.as_canonical_u64() << 0) | (__v_531.as_canonical_u64() << 8)) | (__v_532.as_canonical_u64() << 16)) | (__v_533.as_canonical_u64() << 24)))) + u128::from(((((__v_116.as_canonical_u64() << 0) | (__v_117.as_canonical_u64() << 8)) | (__v_118.as_canonical_u64() << 16)) | (__v_119.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_534: G = G::from_u8(__u32_bytes[0]); let __v_535: G = G::from_u8(__u32_bytes[1]); let __v_536: G = G::from_u8(__u32_bytes[2]); let __v_537: G = G::from_u8(__u32_bytes[3]); let __v_538: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_534; let __vj = __v_535; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_536; let __vj = __v_537; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_539: G = (__v_538 - __v_133); let __v_540: G = (__v_538 - __v_135); let __v_541: G = (__v_539 * __v_540); let __v_542: G = (__v_538 * __v_541); if (__v_542 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_542.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_543: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_514), (&__v_534)) } else { aiur::execute::bytes2_xor_value(__v_514, __v_534, record) }; let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_515), (&__v_535)) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_512), (&__v_536)) } else { aiur::execute::bytes2_xor_value(__v_512, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_513), (&__v_537)) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __u32_sum: u128 = (u128::from(((((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8)) | (__v_518.as_canonical_u64() << 16)) | (__v_519.as_canonical_u64() << 24))) + u128::from(((((__v_544.as_canonical_u64() << 0) | (__v_545.as_canonical_u64() << 8)) | (__v_546.as_canonical_u64() << 16)) | (__v_543.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_547: G = G::from_u8(__u32_bytes[0]); let __v_548: G = G::from_u8(__u32_bytes[1]); let __v_549: G = G::from_u8(__u32_bytes[2]); let __v_550: G = G::from_u8(__u32_bytes[3]); let __v_551: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_547; let __vj = __v_548; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_549; let __vj = __v_550; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_552: G = (__v_551 * __v_551); if (__v_552 != __v_551) { return Err(ExecError::AssertEqMismatch { lhs: __v_552.as_canonical_u64(), rhs: __v_551.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_530), (&__v_547)) } else { aiur::execute::bytes2_xor_split7_value(__v_530, __v_547, record) }; let __v_553: G = __b2_out.0; let __v_554: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_531), (&__v_548)) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_555: G = __b2_out.0; let __v_556: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_532), (&__v_549)) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_557: G = __b2_out.0; let __v_558: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_533), (&__v_550)) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_559: G = __b2_out.0; let __v_560: G = __b2_out.1; let __v_561: G = (__v_553 + __v_556); let __v_562: G = (__v_555 + __v_558); let __v_563: G = (__v_557 + __v_560); let __v_564: G = (__v_559 + __v_554); let __u32_sum: u128 = ((u128::from(((((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8)) | (__v_350.as_canonical_u64() << 16)) | (__v_351.as_canonical_u64() << 24))) + u128::from(((((__v_189.as_canonical_u64() << 0) | (__v_190.as_canonical_u64() << 8)) | (__v_191.as_canonical_u64() << 16)) | (__v_192.as_canonical_u64() << 24)))) + u128::from(((((__v_120.as_canonical_u64() << 0) | (__v_121.as_canonical_u64() << 8)) | (__v_122.as_canonical_u64() << 16)) | (__v_123.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_565: G = G::from_u8(__u32_bytes[0]); let __v_566: G = G::from_u8(__u32_bytes[1]); let __v_567: G = G::from_u8(__u32_bytes[2]); let __v_568: G = G::from_u8(__u32_bytes[3]); let __v_569: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_565; let __vj = __v_566; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_567; let __vj = __v_568; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_570: G = (__v_569 - __v_133); let __v_571: G = (__v_569 - __v_135); let __v_572: G = (__v_570 * __v_571); let __v_573: G = (__v_569 * __v_572); if (__v_573 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_574: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_296), (&__v_565)) } else { aiur::execute::bytes2_xor_value(__v_296, __v_565, record) }; let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_297), (&__v_566)) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_298), (&__v_567)) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_295), (&__v_568)) } else { aiur::execute::bytes2_xor_value(__v_295, __v_568, record) }; let __u32_sum: u128 = (u128::from(((((__v_237.as_canonical_u64() << 0) | (__v_238.as_canonical_u64() << 8)) | (__v_239.as_canonical_u64() << 16)) | (__v_240.as_canonical_u64() << 24))) + u128::from(((((__v_576.as_canonical_u64() << 0) | (__v_577.as_canonical_u64() << 8)) | (__v_574.as_canonical_u64() << 16)) | (__v_575.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_578: G = G::from_u8(__u32_bytes[0]); let __v_579: G = G::from_u8(__u32_bytes[1]); let __v_580: G = G::from_u8(__u32_bytes[2]); let __v_581: G = G::from_u8(__u32_bytes[3]); let __v_582: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_578; let __vj = __v_579; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_580; let __vj = __v_581; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_583: G = (__v_582 * __v_582); if (__v_583 != __v_582) { return Err(ExecError::AssertEqMismatch { lhs: __v_583.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_189), (&__v_578)) } else { aiur::execute::bytes2_xor_split4_value(__v_189, __v_578, record) }; let __v_584: G = __b2_out.0; let __v_585: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_190), (&__v_579)) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_586: G = __b2_out.0; let __v_587: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_191), (&__v_580)) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_588: G = __b2_out.0; let __v_589: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_192), (&__v_581)) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_590: G = __b2_out.0; let __v_591: G = __b2_out.1; let __v_592: G = (__v_586 + __v_589); let __v_593: G = (__v_588 + __v_591); let __v_594: G = (__v_590 + __v_585); let __v_595: G = (__v_584 + __v_587); let __u32_sum: u128 = ((u128::from(((((__v_565.as_canonical_u64() << 0) | (__v_566.as_canonical_u64() << 8)) | (__v_567.as_canonical_u64() << 16)) | (__v_568.as_canonical_u64() << 24))) + u128::from(((((__v_592.as_canonical_u64() << 0) | (__v_593.as_canonical_u64() << 8)) | (__v_594.as_canonical_u64() << 16)) | (__v_595.as_canonical_u64() << 24)))) + u128::from(((((__v_124.as_canonical_u64() << 0) | (__v_125.as_canonical_u64() << 8)) | (__v_126.as_canonical_u64() << 16)) | (__v_127.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_596: G = G::from_u8(__u32_bytes[0]); let __v_597: G = G::from_u8(__u32_bytes[1]); let __v_598: G = G::from_u8(__u32_bytes[2]); let __v_599: G = G::from_u8(__u32_bytes[3]); let __v_600: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_596; let __vj = __v_597; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_598; let __vj = __v_599; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_601: G = (__v_600 - __v_133); let __v_602: G = (__v_600 - __v_135); let __v_603: G = (__v_601 * __v_602); let __v_604: G = (__v_600 * __v_603); if (__v_604 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_604.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_605: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_576), (&__v_596)) } else { aiur::execute::bytes2_xor_value(__v_576, __v_596, record) }; let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_577), (&__v_597)) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_574), (&__v_598)) } else { aiur::execute::bytes2_xor_value(__v_574, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_575), (&__v_599)) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __u32_sum: u128 = (u128::from(((((__v_578.as_canonical_u64() << 0) | (__v_579.as_canonical_u64() << 8)) | (__v_580.as_canonical_u64() << 16)) | (__v_581.as_canonical_u64() << 24))) + u128::from(((((__v_606.as_canonical_u64() << 0) | (__v_607.as_canonical_u64() << 8)) | (__v_608.as_canonical_u64() << 16)) | (__v_605.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_609: G = G::from_u8(__u32_bytes[0]); let __v_610: G = G::from_u8(__u32_bytes[1]); let __v_611: G = G::from_u8(__u32_bytes[2]); let __v_612: G = G::from_u8(__u32_bytes[3]); let __v_613: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_609; let __vj = __v_610; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_611; let __vj = __v_612; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_614: G = (__v_613 * __v_613); if (__v_614 != __v_613) { return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_613.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_592), (&__v_609)) } else { aiur::execute::bytes2_xor_split7_value(__v_592, __v_609, record) }; let __v_615: G = __b2_out.0; let __v_616: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_593), (&__v_610)) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_617: G = __b2_out.0; let __v_618: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_594), (&__v_611)) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_619: G = __b2_out.0; let __v_620: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_595), (&__v_612)) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_621: G = __b2_out.0; let __v_622: G = __b2_out.1; let __v_623: G = (__v_615 + __v_618); let __v_624: G = (__v_617 + __v_620); let __v_625: G = (__v_619 + __v_622); let __v_626: G = (__v_621 + __v_616); let __ret: [G; OUT_33] = [__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[33].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_34: usize = 106; -const IN_34: usize = 106; +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 = inp[1]; let __v_2: G = 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_27] = { let __args: [G; IN_27] = [__v_1]; 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 __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_798] = { let __args: [G; IN_798] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; let __v_77: G = __loaded[3]; let __v_78: G = __loaded[4]; let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; 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_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); let __v_85: G = (__v_84 + __v_7); let __v_86: G = G::from_u64(103); let __v_87: G = G::from_u64(230); let __v_88: G = G::from_u64(9); let __v_89: G = G::from_u64(106); let __v_90: G = G::from_u64(133); let __v_91: G = G::from_u64(174); let __v_92: G = G::from_u64(187); let __v_93: G = G::from_u64(114); let __v_94: G = G::from_u64(243); let __v_95: G = G::from_u64(110); let __v_96: G = G::from_u64(60); let __v_97: G = G::from_u64(58); let __v_98: G = G::from_u64(245); let __v_99: G = G::from_u64(79); let __v_100: G = G::from_u64(165); let __v_101: G = G::from_u64(127); let __v_102: G = G::from_u64(82); let __v_103: G = G::from_u64(14); let __v_104: G = G::from_u64(81); let __v_105: G = G::from_u64(140); let __v_106: G = G::from_u64(104); let __v_107: G = G::from_u64(5); let __v_108: G = G::from_u64(155); let __v_109: G = G::from_u64(171); let __v_110: G = G::from_u64(217); let __v_111: G = G::from_u64(131); let __v_112: G = G::from_u64(31); let __v_113: G = G::from_u64(25); let __v_114: G = G::from_u64(205); let __v_115: G = G::from_u64(224); let __v_116: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(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_34] = { let __args: [G; IN_34] = [__v_150, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_149, __v_150, __v_150, __v_150, __v_85, __v_150, __v_150, __v_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_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_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; 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_30] = [__v_196]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_798] = { let __args: [G; IN_798] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_84 * __v_8); let __v_86: G = (__v_75 * __v_85); let __v_87: G = G::from_u64(63); let __v_88: G = (__v_2 - __v_87); let __v_89: G = G::from_bool((__v_88 == G::ZERO)); let __v_90: G = (__v_89 * __v_6); let __v_91: G = (__v_86 + __v_90); let __v_92: G = (__v_74 + __v_91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(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_34] = { let __args: [G; IN_34] = [__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(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_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_30] = [__v_178]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_31: usize = 24; +const IN_31: usize = 24; +const OUT_31: usize = 16; +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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))) + u128::from(((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); let __v_25: G = G::from_u8(__u32_bytes[1]); let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(2); let __v_32: G = (__v_28 - __v_31); let __v_33: G = (__v_30 * __v_32); let __v_34: G = (__v_28 * __v_33); let __v_35: G = G::from_u64(0); if (__v_34 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_36: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_12), (&__v_24)) } else { aiur::execute::bytes2_xor_value(__v_12, __v_24, record) }; let __v_37: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_13), (&__v_25)) } else { aiur::execute::bytes2_xor_value(__v_13, __v_25, record) }; let __v_38: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_14), (&__v_26)) } else { aiur::execute::bytes2_xor_value(__v_14, __v_26, record) }; let __v_39: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_15), (&__v_27)) } else { aiur::execute::bytes2_xor_value(__v_15, __v_27, record) }; let __u32_sum: u128 = (u128::from(((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24))) + u128::from(((((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8)) | (__v_36.as_canonical_u64() << 16)) | (__v_37.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_40: G = G::from_u8(__u32_bytes[0]); let __v_41: G = G::from_u8(__u32_bytes[1]); let __v_42: G = G::from_u8(__u32_bytes[2]); let __v_43: G = G::from_u8(__u32_bytes[3]); let __v_44: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_45: G = (__v_44 * __v_44); if (__v_45 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_4), (&__v_40)) } else { aiur::execute::bytes2_xor_split4_value(__v_4, __v_40, record) }; let __v_46: G = __b2_out.0; let __v_47: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_5), (&__v_41)) } else { aiur::execute::bytes2_xor_split4_value(__v_5, __v_41, record) }; let __v_48: G = __b2_out.0; let __v_49: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_6), (&__v_42)) } else { aiur::execute::bytes2_xor_split4_value(__v_6, __v_42, record) }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_7), (&__v_43)) } else { aiur::execute::bytes2_xor_split4_value(__v_7, __v_43, record) }; let __v_52: G = __b2_out.0; let __v_53: G = __b2_out.1; let __v_54: G = (__v_48 + __v_51); let __v_55: G = (__v_50 + __v_53); let __v_56: G = (__v_52 + __v_47); let __v_57: G = (__v_46 + __v_49); let __u32_sum: u128 = ((u128::from(((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24))) + u128::from(((((__v_54.as_canonical_u64() << 0) | (__v_55.as_canonical_u64() << 8)) | (__v_56.as_canonical_u64() << 16)) | (__v_57.as_canonical_u64() << 24)))) + u128::from(((((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_58: G = G::from_u8(__u32_bytes[0]); let __v_59: G = G::from_u8(__u32_bytes[1]); let __v_60: G = G::from_u8(__u32_bytes[2]); let __v_61: G = G::from_u8(__u32_bytes[3]); let __v_62: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_63: G = (__v_62 - __v_29); let __v_64: G = (__v_62 - __v_31); let __v_65: G = (__v_63 * __v_64); let __v_66: G = (__v_62 * __v_65); if (__v_66 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_67: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_38), (&__v_58)) } else { aiur::execute::bytes2_xor_value(__v_38, __v_58, record) }; let __v_68: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_39), (&__v_59)) } else { aiur::execute::bytes2_xor_value(__v_39, __v_59, record) }; let __v_69: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_36), (&__v_60)) } else { aiur::execute::bytes2_xor_value(__v_36, __v_60, record) }; let __v_70: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_37), (&__v_61)) } else { aiur::execute::bytes2_xor_value(__v_37, __v_61, record) }; let __u32_sum: u128 = (u128::from(((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24))) + u128::from(((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_71: G = G::from_u8(__u32_bytes[0]); let __v_72: G = G::from_u8(__u32_bytes[1]); let __v_73: G = G::from_u8(__u32_bytes[2]); let __v_74: G = G::from_u8(__u32_bytes[3]); let __v_75: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_71; let __vj = __v_72; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_73; let __vj = __v_74; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_76: G = (__v_75 * __v_75); if (__v_76 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_54), (&__v_71)) } else { aiur::execute::bytes2_xor_split7_value(__v_54, __v_71, record) }; let __v_77: G = __b2_out.0; let __v_78: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_55), (&__v_72)) } else { aiur::execute::bytes2_xor_split7_value(__v_55, __v_72, record) }; let __v_79: G = __b2_out.0; let __v_80: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_56), (&__v_73)) } else { aiur::execute::bytes2_xor_split7_value(__v_56, __v_73, record) }; let __v_81: G = __b2_out.0; let __v_82: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_57), (&__v_74)) } else { aiur::execute::bytes2_xor_split7_value(__v_57, __v_74, record) }; let __v_83: G = __b2_out.0; let __v_84: G = __b2_out.1; let __v_85: G = (__v_77 + __v_80); let __v_86: G = (__v_79 + __v_82); let __v_87: G = (__v_81 + __v_84); let __v_88: G = (__v_83 + __v_78); let __ret: [G; OUT_31] = [__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[31].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_32: usize = 128; +const IN_32: usize = 128; +const OUT_32: usize = 128; +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 = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)))) + u128::from(((((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8)) | (__v_66.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); let __v_129: G = G::from_u8(__u32_bytes[1]); let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_133: G = G::from_u64(1); let __v_134: G = (__v_132 - __v_133); let __v_135: G = G::from_u64(2); let __v_136: G = (__v_132 - __v_135); let __v_137: G = (__v_134 * __v_136); let __v_138: G = (__v_132 * __v_137); let __v_139: G = G::from_u64(0); if (__v_138 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_48), (&__v_128)) } else { aiur::execute::bytes2_xor_value(__v_48, __v_128, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_49), (&__v_129)) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_50), (&__v_130)) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_51), (&__v_131)) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __u32_sum: u128 = (u128::from(((((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8)) | (__v_34.as_canonical_u64() << 16)) | (__v_35.as_canonical_u64() << 24))) + u128::from(((((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8)) | (__v_140.as_canonical_u64() << 16)) | (__v_141.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_144: G = G::from_u8(__u32_bytes[0]); let __v_145: G = G::from_u8(__u32_bytes[1]); let __v_146: G = G::from_u8(__u32_bytes[2]); let __v_147: G = G::from_u8(__u32_bytes[3]); let __v_148: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_146; let __vj = __v_147; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_149: G = (__v_148 * __v_148); if (__v_149 != __v_148) { return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_16), (&__v_144)) } else { aiur::execute::bytes2_xor_split4_value(__v_16, __v_144, record) }; let __v_150: G = __b2_out.0; let __v_151: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_17), (&__v_145)) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_152: G = __b2_out.0; let __v_153: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_18), (&__v_146)) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_154: G = __b2_out.0; let __v_155: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_19), (&__v_147)) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_156: G = __b2_out.0; let __v_157: G = __b2_out.1; let __v_158: G = (__v_152 + __v_155); let __v_159: G = (__v_154 + __v_157); let __v_160: G = (__v_156 + __v_151); let __v_161: G = (__v_150 + __v_153); let __u32_sum: u128 = ((u128::from(((((__v_128.as_canonical_u64() << 0) | (__v_129.as_canonical_u64() << 8)) | (__v_130.as_canonical_u64() << 16)) | (__v_131.as_canonical_u64() << 24))) + u128::from(((((__v_158.as_canonical_u64() << 0) | (__v_159.as_canonical_u64() << 8)) | (__v_160.as_canonical_u64() << 16)) | (__v_161.as_canonical_u64() << 24)))) + u128::from(((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_71.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_162: G = G::from_u8(__u32_bytes[0]); let __v_163: G = G::from_u8(__u32_bytes[1]); let __v_164: G = G::from_u8(__u32_bytes[2]); let __v_165: G = G::from_u8(__u32_bytes[3]); let __v_166: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_162; let __vj = __v_163; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_164; let __vj = __v_165; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_167: G = (__v_166 - __v_133); let __v_168: G = (__v_166 - __v_135); let __v_169: G = (__v_167 * __v_168); let __v_170: G = (__v_166 * __v_169); if (__v_170 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_171: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_142), (&__v_162)) } else { aiur::execute::bytes2_xor_value(__v_142, __v_162, record) }; let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_143), (&__v_163)) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_140), (&__v_164)) } else { aiur::execute::bytes2_xor_value(__v_140, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_141), (&__v_165)) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __u32_sum: u128 = (u128::from(((((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8)) | (__v_146.as_canonical_u64() << 16)) | (__v_147.as_canonical_u64() << 24))) + u128::from(((((__v_172.as_canonical_u64() << 0) | (__v_173.as_canonical_u64() << 8)) | (__v_174.as_canonical_u64() << 16)) | (__v_171.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_175: G = G::from_u8(__u32_bytes[0]); let __v_176: G = G::from_u8(__u32_bytes[1]); let __v_177: G = G::from_u8(__u32_bytes[2]); let __v_178: G = G::from_u8(__u32_bytes[3]); let __v_179: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_175; let __vj = __v_176; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_177; let __vj = __v_178; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_180: G = (__v_179 * __v_179); if (__v_180 != __v_179) { return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_179.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_158), (&__v_175)) } else { aiur::execute::bytes2_xor_split7_value(__v_158, __v_175, record) }; let __v_181: G = __b2_out.0; let __v_182: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_159), (&__v_176)) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_183: G = __b2_out.0; let __v_184: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_160), (&__v_177)) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_185: G = __b2_out.0; let __v_186: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_161), (&__v_178)) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_187: G = __b2_out.0; let __v_188: G = __b2_out.1; let __v_189: G = (__v_181 + __v_184); let __v_190: G = (__v_183 + __v_186); let __v_191: G = (__v_185 + __v_188); let __v_192: G = (__v_187 + __v_182); let __u32_sum: u128 = ((u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24))) + u128::from(((((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24)))) + u128::from(((((__v_72.as_canonical_u64() << 0) | (__v_73.as_canonical_u64() << 8)) | (__v_74.as_canonical_u64() << 16)) | (__v_75.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_193: G = G::from_u8(__u32_bytes[0]); let __v_194: G = G::from_u8(__u32_bytes[1]); let __v_195: G = G::from_u8(__u32_bytes[2]); let __v_196: G = G::from_u8(__u32_bytes[3]); let __v_197: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_193; let __vj = __v_194; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_195; let __vj = __v_196; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_198: G = (__v_197 - __v_133); let __v_199: G = (__v_197 - __v_135); let __v_200: G = (__v_198 * __v_199); let __v_201: G = (__v_197 * __v_200); if (__v_201 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_201.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_202: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_52), (&__v_193)) } else { aiur::execute::bytes2_xor_value(__v_52, __v_193, record) }; let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_53), (&__v_194)) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_54), (&__v_195)) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_55), (&__v_196)) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __u32_sum: u128 = (u128::from(((((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8)) | (__v_38.as_canonical_u64() << 16)) | (__v_39.as_canonical_u64() << 24))) + u128::from(((((__v_204.as_canonical_u64() << 0) | (__v_205.as_canonical_u64() << 8)) | (__v_202.as_canonical_u64() << 16)) | (__v_203.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_206: G = G::from_u8(__u32_bytes[0]); let __v_207: G = G::from_u8(__u32_bytes[1]); let __v_208: G = G::from_u8(__u32_bytes[2]); let __v_209: G = G::from_u8(__u32_bytes[3]); let __v_210: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_206; let __vj = __v_207; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_208; let __vj = __v_209; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_211: G = (__v_210 * __v_210); if (__v_211 != __v_210) { return Err(ExecError::AssertEqMismatch { lhs: __v_211.as_canonical_u64(), rhs: __v_210.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_20), (&__v_206)) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_206, record) }; let __v_212: G = __b2_out.0; let __v_213: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_21), (&__v_207)) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_214: G = __b2_out.0; let __v_215: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_22), (&__v_208)) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_216: G = __b2_out.0; let __v_217: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_23), (&__v_209)) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_218: G = __b2_out.0; let __v_219: G = __b2_out.1; let __v_220: G = (__v_214 + __v_217); let __v_221: G = (__v_216 + __v_219); let __v_222: G = (__v_218 + __v_213); let __v_223: G = (__v_212 + __v_215); let __u32_sum: u128 = ((u128::from(((((__v_193.as_canonical_u64() << 0) | (__v_194.as_canonical_u64() << 8)) | (__v_195.as_canonical_u64() << 16)) | (__v_196.as_canonical_u64() << 24))) + u128::from(((((__v_220.as_canonical_u64() << 0) | (__v_221.as_canonical_u64() << 8)) | (__v_222.as_canonical_u64() << 16)) | (__v_223.as_canonical_u64() << 24)))) + u128::from(((((__v_76.as_canonical_u64() << 0) | (__v_77.as_canonical_u64() << 8)) | (__v_78.as_canonical_u64() << 16)) | (__v_79.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_224: G = G::from_u8(__u32_bytes[0]); let __v_225: G = G::from_u8(__u32_bytes[1]); let __v_226: G = G::from_u8(__u32_bytes[2]); let __v_227: G = G::from_u8(__u32_bytes[3]); let __v_228: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_224; let __vj = __v_225; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_226; let __vj = __v_227; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_229: G = (__v_228 - __v_133); let __v_230: G = (__v_228 - __v_135); let __v_231: G = (__v_229 * __v_230); let __v_232: G = (__v_228 * __v_231); if (__v_232 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_233: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_204), (&__v_224)) } else { aiur::execute::bytes2_xor_value(__v_204, __v_224, record) }; let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_205), (&__v_225)) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_202), (&__v_226)) } else { aiur::execute::bytes2_xor_value(__v_202, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_203), (&__v_227)) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __u32_sum: u128 = (u128::from(((((__v_206.as_canonical_u64() << 0) | (__v_207.as_canonical_u64() << 8)) | (__v_208.as_canonical_u64() << 16)) | (__v_209.as_canonical_u64() << 24))) + u128::from(((((__v_234.as_canonical_u64() << 0) | (__v_235.as_canonical_u64() << 8)) | (__v_236.as_canonical_u64() << 16)) | (__v_233.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_237: G = G::from_u8(__u32_bytes[0]); let __v_238: G = G::from_u8(__u32_bytes[1]); let __v_239: G = G::from_u8(__u32_bytes[2]); let __v_240: G = G::from_u8(__u32_bytes[3]); let __v_241: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_237; let __vj = __v_238; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_239; let __vj = __v_240; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_242: G = (__v_241 * __v_241); if (__v_242 != __v_241) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_220), (&__v_237)) } else { aiur::execute::bytes2_xor_split7_value(__v_220, __v_237, record) }; let __v_243: G = __b2_out.0; let __v_244: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_221), (&__v_238)) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_245: G = __b2_out.0; let __v_246: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_222), (&__v_239)) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_247: G = __b2_out.0; let __v_248: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_223), (&__v_240)) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_249: G = __b2_out.0; let __v_250: G = __b2_out.1; let __v_251: G = (__v_243 + __v_246); let __v_252: G = (__v_245 + __v_248); let __v_253: G = (__v_247 + __v_250); let __v_254: G = (__v_249 + __v_244); let __u32_sum: u128 = ((u128::from(((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24))) + u128::from(((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24)))) + u128::from(((((__v_80.as_canonical_u64() << 0) | (__v_81.as_canonical_u64() << 8)) | (__v_82.as_canonical_u64() << 16)) | (__v_83.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_255: G = G::from_u8(__u32_bytes[0]); let __v_256: G = G::from_u8(__u32_bytes[1]); let __v_257: G = G::from_u8(__u32_bytes[2]); let __v_258: G = G::from_u8(__u32_bytes[3]); let __v_259: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_255; let __vj = __v_256; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_257; let __vj = __v_258; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_260: G = (__v_259 - __v_133); let __v_261: G = (__v_259 - __v_135); let __v_262: G = (__v_260 * __v_261); let __v_263: G = (__v_259 * __v_262); if (__v_263 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_263.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_264: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_56), (&__v_255)) } else { aiur::execute::bytes2_xor_value(__v_56, __v_255, record) }; let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_57), (&__v_256)) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_58), (&__v_257)) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_59), (&__v_258)) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __u32_sum: u128 = (u128::from(((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24))) + u128::from(((((__v_266.as_canonical_u64() << 0) | (__v_267.as_canonical_u64() << 8)) | (__v_264.as_canonical_u64() << 16)) | (__v_265.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_268: G = G::from_u8(__u32_bytes[0]); let __v_269: G = G::from_u8(__u32_bytes[1]); let __v_270: G = G::from_u8(__u32_bytes[2]); let __v_271: G = G::from_u8(__u32_bytes[3]); let __v_272: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_270; let __vj = __v_271; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_273: G = (__v_272 * __v_272); if (__v_273 != __v_272) { return Err(ExecError::AssertEqMismatch { lhs: __v_273.as_canonical_u64(), rhs: __v_272.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_24), (&__v_268)) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_268, record) }; let __v_274: G = __b2_out.0; let __v_275: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_25), (&__v_269)) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_276: G = __b2_out.0; let __v_277: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_26), (&__v_270)) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_278: G = __b2_out.0; let __v_279: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_27), (&__v_271)) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_280: G = __b2_out.0; let __v_281: G = __b2_out.1; let __v_282: G = (__v_276 + __v_279); let __v_283: G = (__v_278 + __v_281); let __v_284: G = (__v_280 + __v_275); let __v_285: G = (__v_274 + __v_277); let __u32_sum: u128 = ((u128::from(((((__v_255.as_canonical_u64() << 0) | (__v_256.as_canonical_u64() << 8)) | (__v_257.as_canonical_u64() << 16)) | (__v_258.as_canonical_u64() << 24))) + u128::from(((((__v_282.as_canonical_u64() << 0) | (__v_283.as_canonical_u64() << 8)) | (__v_284.as_canonical_u64() << 16)) | (__v_285.as_canonical_u64() << 24)))) + u128::from(((((__v_84.as_canonical_u64() << 0) | (__v_85.as_canonical_u64() << 8)) | (__v_86.as_canonical_u64() << 16)) | (__v_87.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_286: G = G::from_u8(__u32_bytes[0]); let __v_287: G = G::from_u8(__u32_bytes[1]); let __v_288: G = G::from_u8(__u32_bytes[2]); let __v_289: G = G::from_u8(__u32_bytes[3]); let __v_290: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_286; let __vj = __v_287; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_288; let __vj = __v_289; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_291: G = (__v_290 - __v_133); let __v_292: G = (__v_290 - __v_135); let __v_293: G = (__v_291 * __v_292); let __v_294: G = (__v_290 * __v_293); if (__v_294 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_294.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_295: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_266), (&__v_286)) } else { aiur::execute::bytes2_xor_value(__v_266, __v_286, record) }; let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_267), (&__v_287)) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_264), (&__v_288)) } else { aiur::execute::bytes2_xor_value(__v_264, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_265), (&__v_289)) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __u32_sum: u128 = (u128::from(((((__v_268.as_canonical_u64() << 0) | (__v_269.as_canonical_u64() << 8)) | (__v_270.as_canonical_u64() << 16)) | (__v_271.as_canonical_u64() << 24))) + u128::from(((((__v_296.as_canonical_u64() << 0) | (__v_297.as_canonical_u64() << 8)) | (__v_298.as_canonical_u64() << 16)) | (__v_295.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_299: G = G::from_u8(__u32_bytes[0]); let __v_300: G = G::from_u8(__u32_bytes[1]); let __v_301: G = G::from_u8(__u32_bytes[2]); let __v_302: G = G::from_u8(__u32_bytes[3]); let __v_303: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_299; let __vj = __v_300; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_301; let __vj = __v_302; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_304: G = (__v_303 * __v_303); if (__v_304 != __v_303) { return Err(ExecError::AssertEqMismatch { lhs: __v_304.as_canonical_u64(), rhs: __v_303.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_282), (&__v_299)) } else { aiur::execute::bytes2_xor_split7_value(__v_282, __v_299, record) }; let __v_305: G = __b2_out.0; let __v_306: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_283), (&__v_300)) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_307: G = __b2_out.0; let __v_308: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_284), (&__v_301)) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_309: G = __b2_out.0; let __v_310: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_285), (&__v_302)) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_311: G = __b2_out.0; let __v_312: G = __b2_out.1; let __v_313: G = (__v_305 + __v_308); let __v_314: G = (__v_307 + __v_310); let __v_315: G = (__v_309 + __v_312); let __v_316: G = (__v_311 + __v_306); let __u32_sum: u128 = ((u128::from(((((__v_12.as_canonical_u64() << 0) | (__v_13.as_canonical_u64() << 8)) | (__v_14.as_canonical_u64() << 16)) | (__v_15.as_canonical_u64() << 24))) + u128::from(((((__v_28.as_canonical_u64() << 0) | (__v_29.as_canonical_u64() << 8)) | (__v_30.as_canonical_u64() << 16)) | (__v_31.as_canonical_u64() << 24)))) + u128::from(((((__v_88.as_canonical_u64() << 0) | (__v_89.as_canonical_u64() << 8)) | (__v_90.as_canonical_u64() << 16)) | (__v_91.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_317: G = G::from_u8(__u32_bytes[0]); let __v_318: G = G::from_u8(__u32_bytes[1]); let __v_319: G = G::from_u8(__u32_bytes[2]); let __v_320: G = G::from_u8(__u32_bytes[3]); let __v_321: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_317; let __vj = __v_318; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_319; let __vj = __v_320; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_322: G = (__v_321 - __v_133); let __v_323: G = (__v_321 - __v_135); let __v_324: G = (__v_322 * __v_323); let __v_325: G = (__v_321 * __v_324); if (__v_325 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_325.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_326: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_60), (&__v_317)) } else { aiur::execute::bytes2_xor_value(__v_60, __v_317, record) }; let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_61), (&__v_318)) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_62), (&__v_319)) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_63), (&__v_320)) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __u32_sum: u128 = (u128::from(((((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8)) | (__v_46.as_canonical_u64() << 16)) | (__v_47.as_canonical_u64() << 24))) + u128::from(((((__v_328.as_canonical_u64() << 0) | (__v_329.as_canonical_u64() << 8)) | (__v_326.as_canonical_u64() << 16)) | (__v_327.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_330: G = G::from_u8(__u32_bytes[0]); let __v_331: G = G::from_u8(__u32_bytes[1]); let __v_332: G = G::from_u8(__u32_bytes[2]); let __v_333: G = G::from_u8(__u32_bytes[3]); let __v_334: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_330; let __vj = __v_331; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_332; let __vj = __v_333; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_335: G = (__v_334 * __v_334); if (__v_335 != __v_334) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_334.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_28), (&__v_330)) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_330, record) }; let __v_336: G = __b2_out.0; let __v_337: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_29), (&__v_331)) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_338: G = __b2_out.0; let __v_339: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_30), (&__v_332)) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_340: G = __b2_out.0; let __v_341: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_31), (&__v_333)) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_342: G = __b2_out.0; let __v_343: G = __b2_out.1; let __v_344: G = (__v_338 + __v_341); let __v_345: G = (__v_340 + __v_343); let __v_346: G = (__v_342 + __v_337); let __v_347: G = (__v_336 + __v_339); let __u32_sum: u128 = ((u128::from(((((__v_317.as_canonical_u64() << 0) | (__v_318.as_canonical_u64() << 8)) | (__v_319.as_canonical_u64() << 16)) | (__v_320.as_canonical_u64() << 24))) + u128::from(((((__v_344.as_canonical_u64() << 0) | (__v_345.as_canonical_u64() << 8)) | (__v_346.as_canonical_u64() << 16)) | (__v_347.as_canonical_u64() << 24)))) + u128::from(((((__v_92.as_canonical_u64() << 0) | (__v_93.as_canonical_u64() << 8)) | (__v_94.as_canonical_u64() << 16)) | (__v_95.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_348: G = G::from_u8(__u32_bytes[0]); let __v_349: G = G::from_u8(__u32_bytes[1]); let __v_350: G = G::from_u8(__u32_bytes[2]); let __v_351: G = G::from_u8(__u32_bytes[3]); let __v_352: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_348; let __vj = __v_349; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_350; let __vj = __v_351; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_353: G = (__v_352 - __v_133); let __v_354: G = (__v_352 - __v_135); let __v_355: G = (__v_353 * __v_354); let __v_356: G = (__v_352 * __v_355); if (__v_356 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_357: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_328), (&__v_348)) } else { aiur::execute::bytes2_xor_value(__v_328, __v_348, record) }; let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_329), (&__v_349)) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_326), (&__v_350)) } else { aiur::execute::bytes2_xor_value(__v_326, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_327), (&__v_351)) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __u32_sum: u128 = (u128::from(((((__v_330.as_canonical_u64() << 0) | (__v_331.as_canonical_u64() << 8)) | (__v_332.as_canonical_u64() << 16)) | (__v_333.as_canonical_u64() << 24))) + u128::from(((((__v_358.as_canonical_u64() << 0) | (__v_359.as_canonical_u64() << 8)) | (__v_360.as_canonical_u64() << 16)) | (__v_357.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_361: G = G::from_u8(__u32_bytes[0]); let __v_362: G = G::from_u8(__u32_bytes[1]); let __v_363: G = G::from_u8(__u32_bytes[2]); let __v_364: G = G::from_u8(__u32_bytes[3]); let __v_365: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_361; let __vj = __v_362; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_363; let __vj = __v_364; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_366: G = (__v_365 * __v_365); if (__v_366 != __v_365) { return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_365.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_344), (&__v_361)) } else { aiur::execute::bytes2_xor_split7_value(__v_344, __v_361, record) }; let __v_367: G = __b2_out.0; let __v_368: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_345), (&__v_362)) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_369: G = __b2_out.0; let __v_370: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_346), (&__v_363)) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_371: G = __b2_out.0; let __v_372: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_347), (&__v_364)) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_373: G = __b2_out.0; let __v_374: G = __b2_out.1; let __v_375: G = (__v_367 + __v_370); let __v_376: G = (__v_369 + __v_372); let __v_377: G = (__v_371 + __v_374); let __v_378: G = (__v_373 + __v_368); let __u32_sum: u128 = ((u128::from(((((__v_162.as_canonical_u64() << 0) | (__v_163.as_canonical_u64() << 8)) | (__v_164.as_canonical_u64() << 16)) | (__v_165.as_canonical_u64() << 24))) + u128::from(((((__v_251.as_canonical_u64() << 0) | (__v_252.as_canonical_u64() << 8)) | (__v_253.as_canonical_u64() << 16)) | (__v_254.as_canonical_u64() << 24)))) + u128::from(((((__v_96.as_canonical_u64() << 0) | (__v_97.as_canonical_u64() << 8)) | (__v_98.as_canonical_u64() << 16)) | (__v_99.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_379: G = G::from_u8(__u32_bytes[0]); let __v_380: G = G::from_u8(__u32_bytes[1]); let __v_381: G = G::from_u8(__u32_bytes[2]); let __v_382: G = G::from_u8(__u32_bytes[3]); let __v_383: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_379; let __vj = __v_380; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_381; let __vj = __v_382; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_384: G = (__v_383 - __v_133); let __v_385: G = (__v_383 - __v_135); let __v_386: G = (__v_384 * __v_385); let __v_387: G = (__v_383 * __v_386); if (__v_387 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_388: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_358), (&__v_379)) } else { aiur::execute::bytes2_xor_value(__v_358, __v_379, record) }; let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_359), (&__v_380)) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_360), (&__v_381)) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_357), (&__v_382)) } else { aiur::execute::bytes2_xor_value(__v_357, __v_382, record) }; let __u32_sum: u128 = (u128::from(((((__v_299.as_canonical_u64() << 0) | (__v_300.as_canonical_u64() << 8)) | (__v_301.as_canonical_u64() << 16)) | (__v_302.as_canonical_u64() << 24))) + u128::from(((((__v_390.as_canonical_u64() << 0) | (__v_391.as_canonical_u64() << 8)) | (__v_388.as_canonical_u64() << 16)) | (__v_389.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_392: G = G::from_u8(__u32_bytes[0]); let __v_393: G = G::from_u8(__u32_bytes[1]); let __v_394: G = G::from_u8(__u32_bytes[2]); let __v_395: G = G::from_u8(__u32_bytes[3]); let __v_396: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_392; let __vj = __v_393; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_394; let __vj = __v_395; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_397: G = (__v_396 * __v_396); if (__v_397 != __v_396) { return Err(ExecError::AssertEqMismatch { lhs: __v_397.as_canonical_u64(), rhs: __v_396.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_251), (&__v_392)) } else { aiur::execute::bytes2_xor_split4_value(__v_251, __v_392, record) }; let __v_398: G = __b2_out.0; let __v_399: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_252), (&__v_393)) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_400: G = __b2_out.0; let __v_401: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_253), (&__v_394)) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_402: G = __b2_out.0; let __v_403: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_254), (&__v_395)) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_404: G = __b2_out.0; let __v_405: G = __b2_out.1; let __v_406: G = (__v_400 + __v_403); let __v_407: G = (__v_402 + __v_405); let __v_408: G = (__v_404 + __v_399); let __v_409: G = (__v_398 + __v_401); let __u32_sum: u128 = ((u128::from(((((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8)) | (__v_381.as_canonical_u64() << 16)) | (__v_382.as_canonical_u64() << 24))) + u128::from(((((__v_406.as_canonical_u64() << 0) | (__v_407.as_canonical_u64() << 8)) | (__v_408.as_canonical_u64() << 16)) | (__v_409.as_canonical_u64() << 24)))) + u128::from(((((__v_100.as_canonical_u64() << 0) | (__v_101.as_canonical_u64() << 8)) | (__v_102.as_canonical_u64() << 16)) | (__v_103.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_410: G = G::from_u8(__u32_bytes[0]); let __v_411: G = G::from_u8(__u32_bytes[1]); let __v_412: G = G::from_u8(__u32_bytes[2]); let __v_413: G = G::from_u8(__u32_bytes[3]); let __v_414: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_410; let __vj = __v_411; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_412; let __vj = __v_413; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_415: G = (__v_414 - __v_133); let __v_416: G = (__v_414 - __v_135); let __v_417: G = (__v_415 * __v_416); let __v_418: G = (__v_414 * __v_417); if (__v_418 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_418.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_419: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_390), (&__v_410)) } else { aiur::execute::bytes2_xor_value(__v_390, __v_410, record) }; let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_391), (&__v_411)) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_388), (&__v_412)) } else { aiur::execute::bytes2_xor_value(__v_388, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_389), (&__v_413)) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __u32_sum: u128 = (u128::from(((((__v_392.as_canonical_u64() << 0) | (__v_393.as_canonical_u64() << 8)) | (__v_394.as_canonical_u64() << 16)) | (__v_395.as_canonical_u64() << 24))) + u128::from(((((__v_420.as_canonical_u64() << 0) | (__v_421.as_canonical_u64() << 8)) | (__v_422.as_canonical_u64() << 16)) | (__v_419.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_423: G = G::from_u8(__u32_bytes[0]); let __v_424: G = G::from_u8(__u32_bytes[1]); let __v_425: G = G::from_u8(__u32_bytes[2]); let __v_426: G = G::from_u8(__u32_bytes[3]); let __v_427: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_423; let __vj = __v_424; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_425; let __vj = __v_426; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_428: G = (__v_427 * __v_427); if (__v_428 != __v_427) { return Err(ExecError::AssertEqMismatch { lhs: __v_428.as_canonical_u64(), rhs: __v_427.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_406), (&__v_423)) } else { aiur::execute::bytes2_xor_split7_value(__v_406, __v_423, record) }; let __v_429: G = __b2_out.0; let __v_430: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_407), (&__v_424)) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_431: G = __b2_out.0; let __v_432: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_408), (&__v_425)) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_433: G = __b2_out.0; let __v_434: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_409), (&__v_426)) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_435: G = __b2_out.0; let __v_436: G = __b2_out.1; let __v_437: G = (__v_429 + __v_432); let __v_438: G = (__v_431 + __v_434); let __v_439: G = (__v_433 + __v_436); let __v_440: G = (__v_435 + __v_430); let __u32_sum: u128 = ((u128::from(((((__v_224.as_canonical_u64() << 0) | (__v_225.as_canonical_u64() << 8)) | (__v_226.as_canonical_u64() << 16)) | (__v_227.as_canonical_u64() << 24))) + u128::from(((((__v_313.as_canonical_u64() << 0) | (__v_314.as_canonical_u64() << 8)) | (__v_315.as_canonical_u64() << 16)) | (__v_316.as_canonical_u64() << 24)))) + u128::from(((((__v_104.as_canonical_u64() << 0) | (__v_105.as_canonical_u64() << 8)) | (__v_106.as_canonical_u64() << 16)) | (__v_107.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_441: G = G::from_u8(__u32_bytes[0]); let __v_442: G = G::from_u8(__u32_bytes[1]); let __v_443: G = G::from_u8(__u32_bytes[2]); let __v_444: G = G::from_u8(__u32_bytes[3]); let __v_445: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_441; let __vj = __v_442; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_443; let __vj = __v_444; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_446: G = (__v_445 - __v_133); let __v_447: G = (__v_445 - __v_135); let __v_448: G = (__v_446 * __v_447); let __v_449: G = (__v_445 * __v_448); if (__v_449 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_449.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_450: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_172), (&__v_441)) } else { aiur::execute::bytes2_xor_value(__v_172, __v_441, record) }; let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_173), (&__v_442)) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_174), (&__v_443)) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_171), (&__v_444)) } else { aiur::execute::bytes2_xor_value(__v_171, __v_444, record) }; let __u32_sum: u128 = (u128::from(((((__v_361.as_canonical_u64() << 0) | (__v_362.as_canonical_u64() << 8)) | (__v_363.as_canonical_u64() << 16)) | (__v_364.as_canonical_u64() << 24))) + u128::from(((((__v_452.as_canonical_u64() << 0) | (__v_453.as_canonical_u64() << 8)) | (__v_450.as_canonical_u64() << 16)) | (__v_451.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_454: G = G::from_u8(__u32_bytes[0]); let __v_455: G = G::from_u8(__u32_bytes[1]); let __v_456: G = G::from_u8(__u32_bytes[2]); let __v_457: G = G::from_u8(__u32_bytes[3]); let __v_458: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_454; let __vj = __v_455; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_456; let __vj = __v_457; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_459: G = (__v_458 * __v_458); if (__v_459 != __v_458) { return Err(ExecError::AssertEqMismatch { lhs: __v_459.as_canonical_u64(), rhs: __v_458.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_313), (&__v_454)) } else { aiur::execute::bytes2_xor_split4_value(__v_313, __v_454, record) }; let __v_460: G = __b2_out.0; let __v_461: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_314), (&__v_455)) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_462: G = __b2_out.0; let __v_463: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_315), (&__v_456)) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_464: G = __b2_out.0; let __v_465: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_316), (&__v_457)) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_466: G = __b2_out.0; let __v_467: G = __b2_out.1; let __v_468: G = (__v_462 + __v_465); let __v_469: G = (__v_464 + __v_467); let __v_470: G = (__v_466 + __v_461); let __v_471: G = (__v_460 + __v_463); let __u32_sum: u128 = ((u128::from(((((__v_441.as_canonical_u64() << 0) | (__v_442.as_canonical_u64() << 8)) | (__v_443.as_canonical_u64() << 16)) | (__v_444.as_canonical_u64() << 24))) + u128::from(((((__v_468.as_canonical_u64() << 0) | (__v_469.as_canonical_u64() << 8)) | (__v_470.as_canonical_u64() << 16)) | (__v_471.as_canonical_u64() << 24)))) + u128::from(((((__v_108.as_canonical_u64() << 0) | (__v_109.as_canonical_u64() << 8)) | (__v_110.as_canonical_u64() << 16)) | (__v_111.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_472: G = G::from_u8(__u32_bytes[0]); let __v_473: G = G::from_u8(__u32_bytes[1]); let __v_474: G = G::from_u8(__u32_bytes[2]); let __v_475: G = G::from_u8(__u32_bytes[3]); let __v_476: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_472; let __vj = __v_473; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_474; let __vj = __v_475; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_477: G = (__v_476 - __v_133); let __v_478: G = (__v_476 - __v_135); let __v_479: G = (__v_477 * __v_478); let __v_480: G = (__v_476 * __v_479); if (__v_480 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_481: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_452), (&__v_472)) } else { aiur::execute::bytes2_xor_value(__v_452, __v_472, record) }; let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_453), (&__v_473)) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_450), (&__v_474)) } else { aiur::execute::bytes2_xor_value(__v_450, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_451), (&__v_475)) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __u32_sum: u128 = (u128::from(((((__v_454.as_canonical_u64() << 0) | (__v_455.as_canonical_u64() << 8)) | (__v_456.as_canonical_u64() << 16)) | (__v_457.as_canonical_u64() << 24))) + u128::from(((((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8)) | (__v_484.as_canonical_u64() << 16)) | (__v_481.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_485: G = G::from_u8(__u32_bytes[0]); let __v_486: G = G::from_u8(__u32_bytes[1]); let __v_487: G = G::from_u8(__u32_bytes[2]); let __v_488: G = G::from_u8(__u32_bytes[3]); let __v_489: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_485; let __vj = __v_486; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_487; let __vj = __v_488; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_490: G = (__v_489 * __v_489); if (__v_490 != __v_489) { return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_468), (&__v_485)) } else { aiur::execute::bytes2_xor_split7_value(__v_468, __v_485, record) }; let __v_491: G = __b2_out.0; let __v_492: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_469), (&__v_486)) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_493: G = __b2_out.0; let __v_494: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_470), (&__v_487)) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_495: G = __b2_out.0; let __v_496: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_471), (&__v_488)) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_497: G = __b2_out.0; let __v_498: G = __b2_out.1; let __v_499: G = (__v_491 + __v_494); let __v_500: G = (__v_493 + __v_496); let __v_501: G = (__v_495 + __v_498); let __v_502: G = (__v_497 + __v_492); let __u32_sum: u128 = ((u128::from(((((__v_286.as_canonical_u64() << 0) | (__v_287.as_canonical_u64() << 8)) | (__v_288.as_canonical_u64() << 16)) | (__v_289.as_canonical_u64() << 24))) + u128::from(((((__v_375.as_canonical_u64() << 0) | (__v_376.as_canonical_u64() << 8)) | (__v_377.as_canonical_u64() << 16)) | (__v_378.as_canonical_u64() << 24)))) + u128::from(((((__v_112.as_canonical_u64() << 0) | (__v_113.as_canonical_u64() << 8)) | (__v_114.as_canonical_u64() << 16)) | (__v_115.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_503: G = G::from_u8(__u32_bytes[0]); let __v_504: G = G::from_u8(__u32_bytes[1]); let __v_505: G = G::from_u8(__u32_bytes[2]); let __v_506: G = G::from_u8(__u32_bytes[3]); let __v_507: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_503; let __vj = __v_504; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_505; let __vj = __v_506; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_508: G = (__v_507 - __v_133); let __v_509: G = (__v_507 - __v_135); let __v_510: G = (__v_508 * __v_509); let __v_511: G = (__v_507 * __v_510); if (__v_511 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_511.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_512: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_234), (&__v_503)) } else { aiur::execute::bytes2_xor_value(__v_234, __v_503, record) }; let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_235), (&__v_504)) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_236), (&__v_505)) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_233), (&__v_506)) } else { aiur::execute::bytes2_xor_value(__v_233, __v_506, record) }; let __u32_sum: u128 = (u128::from(((((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8)) | (__v_177.as_canonical_u64() << 16)) | (__v_178.as_canonical_u64() << 24))) + u128::from(((((__v_514.as_canonical_u64() << 0) | (__v_515.as_canonical_u64() << 8)) | (__v_512.as_canonical_u64() << 16)) | (__v_513.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_516: G = G::from_u8(__u32_bytes[0]); let __v_517: G = G::from_u8(__u32_bytes[1]); let __v_518: G = G::from_u8(__u32_bytes[2]); let __v_519: G = G::from_u8(__u32_bytes[3]); let __v_520: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_516; let __vj = __v_517; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_518; let __vj = __v_519; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_521: G = (__v_520 * __v_520); if (__v_521 != __v_520) { return Err(ExecError::AssertEqMismatch { lhs: __v_521.as_canonical_u64(), rhs: __v_520.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_375), (&__v_516)) } else { aiur::execute::bytes2_xor_split4_value(__v_375, __v_516, record) }; let __v_522: G = __b2_out.0; let __v_523: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_376), (&__v_517)) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_524: G = __b2_out.0; let __v_525: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_377), (&__v_518)) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_526: G = __b2_out.0; let __v_527: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_378), (&__v_519)) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_528: G = __b2_out.0; let __v_529: G = __b2_out.1; let __v_530: G = (__v_524 + __v_527); let __v_531: G = (__v_526 + __v_529); let __v_532: G = (__v_528 + __v_523); let __v_533: G = (__v_522 + __v_525); let __u32_sum: u128 = ((u128::from(((((__v_503.as_canonical_u64() << 0) | (__v_504.as_canonical_u64() << 8)) | (__v_505.as_canonical_u64() << 16)) | (__v_506.as_canonical_u64() << 24))) + u128::from(((((__v_530.as_canonical_u64() << 0) | (__v_531.as_canonical_u64() << 8)) | (__v_532.as_canonical_u64() << 16)) | (__v_533.as_canonical_u64() << 24)))) + u128::from(((((__v_116.as_canonical_u64() << 0) | (__v_117.as_canonical_u64() << 8)) | (__v_118.as_canonical_u64() << 16)) | (__v_119.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_534: G = G::from_u8(__u32_bytes[0]); let __v_535: G = G::from_u8(__u32_bytes[1]); let __v_536: G = G::from_u8(__u32_bytes[2]); let __v_537: G = G::from_u8(__u32_bytes[3]); let __v_538: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_534; let __vj = __v_535; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_536; let __vj = __v_537; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_539: G = (__v_538 - __v_133); let __v_540: G = (__v_538 - __v_135); let __v_541: G = (__v_539 * __v_540); let __v_542: G = (__v_538 * __v_541); if (__v_542 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_542.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_543: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_514), (&__v_534)) } else { aiur::execute::bytes2_xor_value(__v_514, __v_534, record) }; let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_515), (&__v_535)) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_512), (&__v_536)) } else { aiur::execute::bytes2_xor_value(__v_512, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_513), (&__v_537)) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __u32_sum: u128 = (u128::from(((((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8)) | (__v_518.as_canonical_u64() << 16)) | (__v_519.as_canonical_u64() << 24))) + u128::from(((((__v_544.as_canonical_u64() << 0) | (__v_545.as_canonical_u64() << 8)) | (__v_546.as_canonical_u64() << 16)) | (__v_543.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_547: G = G::from_u8(__u32_bytes[0]); let __v_548: G = G::from_u8(__u32_bytes[1]); let __v_549: G = G::from_u8(__u32_bytes[2]); let __v_550: G = G::from_u8(__u32_bytes[3]); let __v_551: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_547; let __vj = __v_548; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_549; let __vj = __v_550; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_552: G = (__v_551 * __v_551); if (__v_552 != __v_551) { return Err(ExecError::AssertEqMismatch { lhs: __v_552.as_canonical_u64(), rhs: __v_551.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_530), (&__v_547)) } else { aiur::execute::bytes2_xor_split7_value(__v_530, __v_547, record) }; let __v_553: G = __b2_out.0; let __v_554: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_531), (&__v_548)) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_555: G = __b2_out.0; let __v_556: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_532), (&__v_549)) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_557: G = __b2_out.0; let __v_558: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_533), (&__v_550)) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_559: G = __b2_out.0; let __v_560: G = __b2_out.1; let __v_561: G = (__v_553 + __v_556); let __v_562: G = (__v_555 + __v_558); let __v_563: G = (__v_557 + __v_560); let __v_564: G = (__v_559 + __v_554); let __u32_sum: u128 = ((u128::from(((((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8)) | (__v_350.as_canonical_u64() << 16)) | (__v_351.as_canonical_u64() << 24))) + u128::from(((((__v_189.as_canonical_u64() << 0) | (__v_190.as_canonical_u64() << 8)) | (__v_191.as_canonical_u64() << 16)) | (__v_192.as_canonical_u64() << 24)))) + u128::from(((((__v_120.as_canonical_u64() << 0) | (__v_121.as_canonical_u64() << 8)) | (__v_122.as_canonical_u64() << 16)) | (__v_123.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_565: G = G::from_u8(__u32_bytes[0]); let __v_566: G = G::from_u8(__u32_bytes[1]); let __v_567: G = G::from_u8(__u32_bytes[2]); let __v_568: G = G::from_u8(__u32_bytes[3]); let __v_569: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_565; let __vj = __v_566; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_567; let __vj = __v_568; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_570: G = (__v_569 - __v_133); let __v_571: G = (__v_569 - __v_135); let __v_572: G = (__v_570 * __v_571); let __v_573: G = (__v_569 * __v_572); if (__v_573 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_574: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_296), (&__v_565)) } else { aiur::execute::bytes2_xor_value(__v_296, __v_565, record) }; let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_297), (&__v_566)) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_298), (&__v_567)) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_295), (&__v_568)) } else { aiur::execute::bytes2_xor_value(__v_295, __v_568, record) }; let __u32_sum: u128 = (u128::from(((((__v_237.as_canonical_u64() << 0) | (__v_238.as_canonical_u64() << 8)) | (__v_239.as_canonical_u64() << 16)) | (__v_240.as_canonical_u64() << 24))) + u128::from(((((__v_576.as_canonical_u64() << 0) | (__v_577.as_canonical_u64() << 8)) | (__v_574.as_canonical_u64() << 16)) | (__v_575.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_578: G = G::from_u8(__u32_bytes[0]); let __v_579: G = G::from_u8(__u32_bytes[1]); let __v_580: G = G::from_u8(__u32_bytes[2]); let __v_581: G = G::from_u8(__u32_bytes[3]); let __v_582: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_578; let __vj = __v_579; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_580; let __vj = __v_581; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_583: G = (__v_582 * __v_582); if (__v_583 != __v_582) { return Err(ExecError::AssertEqMismatch { lhs: __v_583.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_189), (&__v_578)) } else { aiur::execute::bytes2_xor_split4_value(__v_189, __v_578, record) }; let __v_584: G = __b2_out.0; let __v_585: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_190), (&__v_579)) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_586: G = __b2_out.0; let __v_587: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_191), (&__v_580)) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_588: G = __b2_out.0; let __v_589: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_192), (&__v_581)) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_590: G = __b2_out.0; let __v_591: G = __b2_out.1; let __v_592: G = (__v_586 + __v_589); let __v_593: G = (__v_588 + __v_591); let __v_594: G = (__v_590 + __v_585); let __v_595: G = (__v_584 + __v_587); let __u32_sum: u128 = ((u128::from(((((__v_565.as_canonical_u64() << 0) | (__v_566.as_canonical_u64() << 8)) | (__v_567.as_canonical_u64() << 16)) | (__v_568.as_canonical_u64() << 24))) + u128::from(((((__v_592.as_canonical_u64() << 0) | (__v_593.as_canonical_u64() << 8)) | (__v_594.as_canonical_u64() << 16)) | (__v_595.as_canonical_u64() << 24)))) + u128::from(((((__v_124.as_canonical_u64() << 0) | (__v_125.as_canonical_u64() << 8)) | (__v_126.as_canonical_u64() << 16)) | (__v_127.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_596: G = G::from_u8(__u32_bytes[0]); let __v_597: G = G::from_u8(__u32_bytes[1]); let __v_598: G = G::from_u8(__u32_bytes[2]); let __v_599: G = G::from_u8(__u32_bytes[3]); let __v_600: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_596; let __vj = __v_597; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_598; let __vj = __v_599; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_601: G = (__v_600 - __v_133); let __v_602: G = (__v_600 - __v_135); let __v_603: G = (__v_601 * __v_602); let __v_604: G = (__v_600 * __v_603); if (__v_604 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_604.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_605: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_576), (&__v_596)) } else { aiur::execute::bytes2_xor_value(__v_576, __v_596, record) }; let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_577), (&__v_597)) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_574), (&__v_598)) } else { aiur::execute::bytes2_xor_value(__v_574, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_575), (&__v_599)) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __u32_sum: u128 = (u128::from(((((__v_578.as_canonical_u64() << 0) | (__v_579.as_canonical_u64() << 8)) | (__v_580.as_canonical_u64() << 16)) | (__v_581.as_canonical_u64() << 24))) + u128::from(((((__v_606.as_canonical_u64() << 0) | (__v_607.as_canonical_u64() << 8)) | (__v_608.as_canonical_u64() << 16)) | (__v_605.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_609: G = G::from_u8(__u32_bytes[0]); let __v_610: G = G::from_u8(__u32_bytes[1]); let __v_611: G = G::from_u8(__u32_bytes[2]); let __v_612: G = G::from_u8(__u32_bytes[3]); let __v_613: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_609; let __vj = __v_610; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_611; let __vj = __v_612; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_614: G = (__v_613 * __v_613); if (__v_614 != __v_613) { return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_613.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_592), (&__v_609)) } else { aiur::execute::bytes2_xor_split7_value(__v_592, __v_609, record) }; let __v_615: G = __b2_out.0; let __v_616: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_593), (&__v_610)) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_617: G = __b2_out.0; let __v_618: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_594), (&__v_611)) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_619: G = __b2_out.0; let __v_620: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_595), (&__v_612)) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_621: G = __b2_out.0; let __v_622: G = __b2_out.1; let __v_623: G = (__v_615 + __v_618); let __v_624: G = (__v_617 + __v_620); let __v_625: G = (__v_619 + __v_622); let __v_626: G = (__v_621 + __v_616); let __ret: [G; OUT_32] = [__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[32].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_33: usize = 106; +const IN_33: usize = 106; +const OUT_33: usize = 32; +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 = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_34] = { let __args: [G; IN_34] = [__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(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_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_33] = [__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[33].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_34: usize = 129; +const IN_34: usize = 129; const OUT_34: usize = 32; -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 __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_35] = { let __args: [G; IN_35] = [__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(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_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_34] = [__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[34].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_35: usize = 129; -const IN_35: usize = 129; -const OUT_35: usize = 32; -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 __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_35] = [__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[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __u32_sum: u128 = ((u128::from(((((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8)) | (__v_3.as_canonical_u64() << 16)) | (__v_4.as_canonical_u64() << 24))) + u128::from(((((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8)) | (__v_19.as_canonical_u64() << 16)) | (__v_20.as_canonical_u64() << 24)))) + u128::from(((((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8)) | (__v_67.as_canonical_u64() << 16)) | (__v_68.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_129: G = G::from_u8(__u32_bytes[0]); let __v_130: G = G::from_u8(__u32_bytes[1]); let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_134: G = G::from_u64(1); let __v_135: G = (__v_133 - __v_134); let __v_136: G = G::from_u64(2); let __v_137: G = (__v_133 - __v_136); let __v_138: G = (__v_135 * __v_137); let __v_139: G = (__v_133 * __v_138); let __v_140: G = G::from_u64(0); if (__v_139 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_49), (&__v_129)) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_50), (&__v_130)) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_51), (&__v_131)) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_52), (&__v_132)) } else { aiur::execute::bytes2_xor_value(__v_52, __v_132, record) }; let __u32_sum: u128 = (u128::from(((((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8)) | (__v_35.as_canonical_u64() << 16)) | (__v_36.as_canonical_u64() << 24))) + u128::from(((((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8)) | (__v_141.as_canonical_u64() << 16)) | (__v_142.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_145: G = G::from_u8(__u32_bytes[0]); let __v_146: G = G::from_u8(__u32_bytes[1]); let __v_147: G = G::from_u8(__u32_bytes[2]); let __v_148: G = G::from_u8(__u32_bytes[3]); let __v_149: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_147; let __vj = __v_148; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_150: G = (__v_149 * __v_149); if (__v_150 != __v_149) { return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_17), (&__v_145)) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_151: G = __b2_out.0; let __v_152: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_18), (&__v_146)) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_153: G = __b2_out.0; let __v_154: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_19), (&__v_147)) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_155: G = __b2_out.0; let __v_156: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_20), (&__v_148)) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_148, record) }; let __v_157: G = __b2_out.0; let __v_158: G = __b2_out.1; let __v_159: G = (__v_153 + __v_156); let __v_160: G = (__v_155 + __v_158); let __v_161: G = (__v_157 + __v_152); let __v_162: G = (__v_151 + __v_154); let __u32_sum: u128 = ((u128::from(((((__v_129.as_canonical_u64() << 0) | (__v_130.as_canonical_u64() << 8)) | (__v_131.as_canonical_u64() << 16)) | (__v_132.as_canonical_u64() << 24))) + u128::from(((((__v_159.as_canonical_u64() << 0) | (__v_160.as_canonical_u64() << 8)) | (__v_161.as_canonical_u64() << 16)) | (__v_162.as_canonical_u64() << 24)))) + u128::from(((((__v_69.as_canonical_u64() << 0) | (__v_70.as_canonical_u64() << 8)) | (__v_71.as_canonical_u64() << 16)) | (__v_72.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_163: G = G::from_u8(__u32_bytes[0]); let __v_164: G = G::from_u8(__u32_bytes[1]); let __v_165: G = G::from_u8(__u32_bytes[2]); let __v_166: G = G::from_u8(__u32_bytes[3]); let __v_167: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_163; let __vj = __v_164; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_165; let __vj = __v_166; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_168: G = (__v_167 - __v_134); let __v_169: G = (__v_167 - __v_136); let __v_170: G = (__v_168 * __v_169); let __v_171: G = (__v_167 * __v_170); if (__v_171 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_143), (&__v_163)) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_144), (&__v_164)) } else { aiur::execute::bytes2_xor_value(__v_144, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_141), (&__v_165)) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __v_175: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_142), (&__v_166)) } else { aiur::execute::bytes2_xor_value(__v_142, __v_166, record) }; let __u32_sum: u128 = (u128::from(((((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8)) | (__v_147.as_canonical_u64() << 16)) | (__v_148.as_canonical_u64() << 24))) + u128::from(((((__v_173.as_canonical_u64() << 0) | (__v_174.as_canonical_u64() << 8)) | (__v_175.as_canonical_u64() << 16)) | (__v_172.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_176: G = G::from_u8(__u32_bytes[0]); let __v_177: G = G::from_u8(__u32_bytes[1]); let __v_178: G = G::from_u8(__u32_bytes[2]); let __v_179: G = G::from_u8(__u32_bytes[3]); let __v_180: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_176; let __vj = __v_177; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_178; let __vj = __v_179; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_181: G = (__v_180 * __v_180); if (__v_181 != __v_180) { return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_180.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_159), (&__v_176)) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_182: G = __b2_out.0; let __v_183: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_160), (&__v_177)) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_184: G = __b2_out.0; let __v_185: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_161), (&__v_178)) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_186: G = __b2_out.0; let __v_187: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_162), (&__v_179)) } else { aiur::execute::bytes2_xor_split7_value(__v_162, __v_179, record) }; let __v_188: G = __b2_out.0; let __v_189: G = __b2_out.1; let __v_190: G = (__v_182 + __v_185); let __v_191: G = (__v_184 + __v_187); let __v_192: G = (__v_186 + __v_189); let __v_193: G = (__v_188 + __v_183); let __u32_sum: u128 = ((u128::from(((((__v_5.as_canonical_u64() << 0) | (__v_6.as_canonical_u64() << 8)) | (__v_7.as_canonical_u64() << 16)) | (__v_8.as_canonical_u64() << 24))) + u128::from(((((__v_21.as_canonical_u64() << 0) | (__v_22.as_canonical_u64() << 8)) | (__v_23.as_canonical_u64() << 16)) | (__v_24.as_canonical_u64() << 24)))) + u128::from(((((__v_73.as_canonical_u64() << 0) | (__v_74.as_canonical_u64() << 8)) | (__v_75.as_canonical_u64() << 16)) | (__v_76.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_194: G = G::from_u8(__u32_bytes[0]); let __v_195: G = G::from_u8(__u32_bytes[1]); let __v_196: G = G::from_u8(__u32_bytes[2]); let __v_197: G = G::from_u8(__u32_bytes[3]); let __v_198: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_194; let __vj = __v_195; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_199: G = (__v_198 - __v_134); let __v_200: G = (__v_198 - __v_136); let __v_201: G = (__v_199 * __v_200); let __v_202: G = (__v_198 * __v_201); if (__v_202 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_202.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_53), (&__v_194)) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_54), (&__v_195)) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_55), (&__v_196)) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __v_206: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_56), (&__v_197)) } else { aiur::execute::bytes2_xor_value(__v_56, __v_197, record) }; let __u32_sum: u128 = (u128::from(((((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8)) | (__v_39.as_canonical_u64() << 16)) | (__v_40.as_canonical_u64() << 24))) + u128::from(((((__v_205.as_canonical_u64() << 0) | (__v_206.as_canonical_u64() << 8)) | (__v_203.as_canonical_u64() << 16)) | (__v_204.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_207: G = G::from_u8(__u32_bytes[0]); let __v_208: G = G::from_u8(__u32_bytes[1]); let __v_209: G = G::from_u8(__u32_bytes[2]); let __v_210: G = G::from_u8(__u32_bytes[3]); let __v_211: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_207; let __vj = __v_208; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_209; let __vj = __v_210; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_212: G = (__v_211 * __v_211); if (__v_212 != __v_211) { return Err(ExecError::AssertEqMismatch { lhs: __v_212.as_canonical_u64(), rhs: __v_211.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_21), (&__v_207)) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_213: G = __b2_out.0; let __v_214: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_22), (&__v_208)) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_215: G = __b2_out.0; let __v_216: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_23), (&__v_209)) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_217: G = __b2_out.0; let __v_218: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_24), (&__v_210)) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_210, record) }; let __v_219: G = __b2_out.0; let __v_220: G = __b2_out.1; let __v_221: G = (__v_215 + __v_218); let __v_222: G = (__v_217 + __v_220); let __v_223: G = (__v_219 + __v_214); let __v_224: G = (__v_213 + __v_216); let __u32_sum: u128 = ((u128::from(((((__v_194.as_canonical_u64() << 0) | (__v_195.as_canonical_u64() << 8)) | (__v_196.as_canonical_u64() << 16)) | (__v_197.as_canonical_u64() << 24))) + u128::from(((((__v_221.as_canonical_u64() << 0) | (__v_222.as_canonical_u64() << 8)) | (__v_223.as_canonical_u64() << 16)) | (__v_224.as_canonical_u64() << 24)))) + u128::from(((((__v_77.as_canonical_u64() << 0) | (__v_78.as_canonical_u64() << 8)) | (__v_79.as_canonical_u64() << 16)) | (__v_80.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_225: G = G::from_u8(__u32_bytes[0]); let __v_226: G = G::from_u8(__u32_bytes[1]); let __v_227: G = G::from_u8(__u32_bytes[2]); let __v_228: G = G::from_u8(__u32_bytes[3]); let __v_229: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_225; let __vj = __v_226; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_227; let __vj = __v_228; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_230: G = (__v_229 - __v_134); let __v_231: G = (__v_229 - __v_136); let __v_232: G = (__v_230 * __v_231); let __v_233: G = (__v_229 * __v_232); if (__v_233 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_205), (&__v_225)) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_206), (&__v_226)) } else { aiur::execute::bytes2_xor_value(__v_206, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_203), (&__v_227)) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __v_237: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_204), (&__v_228)) } else { aiur::execute::bytes2_xor_value(__v_204, __v_228, record) }; let __u32_sum: u128 = (u128::from(((((__v_207.as_canonical_u64() << 0) | (__v_208.as_canonical_u64() << 8)) | (__v_209.as_canonical_u64() << 16)) | (__v_210.as_canonical_u64() << 24))) + u128::from(((((__v_235.as_canonical_u64() << 0) | (__v_236.as_canonical_u64() << 8)) | (__v_237.as_canonical_u64() << 16)) | (__v_234.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_238: G = G::from_u8(__u32_bytes[0]); let __v_239: G = G::from_u8(__u32_bytes[1]); let __v_240: G = G::from_u8(__u32_bytes[2]); let __v_241: G = G::from_u8(__u32_bytes[3]); let __v_242: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_238; let __vj = __v_239; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_240; let __vj = __v_241; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_243: G = (__v_242 * __v_242); if (__v_243 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_221), (&__v_238)) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_244: G = __b2_out.0; let __v_245: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_222), (&__v_239)) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_246: G = __b2_out.0; let __v_247: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_223), (&__v_240)) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_248: G = __b2_out.0; let __v_249: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_224), (&__v_241)) } else { aiur::execute::bytes2_xor_split7_value(__v_224, __v_241, record) }; let __v_250: G = __b2_out.0; let __v_251: G = __b2_out.1; let __v_252: G = (__v_244 + __v_247); let __v_253: G = (__v_246 + __v_249); let __v_254: G = (__v_248 + __v_251); let __v_255: G = (__v_250 + __v_245); let __u32_sum: u128 = ((u128::from(((((__v_9.as_canonical_u64() << 0) | (__v_10.as_canonical_u64() << 8)) | (__v_11.as_canonical_u64() << 16)) | (__v_12.as_canonical_u64() << 24))) + u128::from(((((__v_25.as_canonical_u64() << 0) | (__v_26.as_canonical_u64() << 8)) | (__v_27.as_canonical_u64() << 16)) | (__v_28.as_canonical_u64() << 24)))) + u128::from(((((__v_81.as_canonical_u64() << 0) | (__v_82.as_canonical_u64() << 8)) | (__v_83.as_canonical_u64() << 16)) | (__v_84.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_256: G = G::from_u8(__u32_bytes[0]); let __v_257: G = G::from_u8(__u32_bytes[1]); let __v_258: G = G::from_u8(__u32_bytes[2]); let __v_259: G = G::from_u8(__u32_bytes[3]); let __v_260: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_256; let __vj = __v_257; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_258; let __vj = __v_259; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_261: G = (__v_260 - __v_134); let __v_262: G = (__v_260 - __v_136); let __v_263: G = (__v_261 * __v_262); let __v_264: G = (__v_260 * __v_263); if (__v_264 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_57), (&__v_256)) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_58), (&__v_257)) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_59), (&__v_258)) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __v_268: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_60), (&__v_259)) } else { aiur::execute::bytes2_xor_value(__v_60, __v_259, record) }; let __u32_sum: u128 = (u128::from(((((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8)) | (__v_43.as_canonical_u64() << 16)) | (__v_44.as_canonical_u64() << 24))) + u128::from(((((__v_267.as_canonical_u64() << 0) | (__v_268.as_canonical_u64() << 8)) | (__v_265.as_canonical_u64() << 16)) | (__v_266.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_269: G = G::from_u8(__u32_bytes[0]); let __v_270: G = G::from_u8(__u32_bytes[1]); let __v_271: G = G::from_u8(__u32_bytes[2]); let __v_272: G = G::from_u8(__u32_bytes[3]); let __v_273: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_269; let __vj = __v_270; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_271; let __vj = __v_272; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_274: G = (__v_273 * __v_273); if (__v_274 != __v_273) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_273.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_25), (&__v_269)) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_275: G = __b2_out.0; let __v_276: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_26), (&__v_270)) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_277: G = __b2_out.0; let __v_278: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_27), (&__v_271)) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_279: G = __b2_out.0; let __v_280: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_28), (&__v_272)) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_272, record) }; let __v_281: G = __b2_out.0; let __v_282: G = __b2_out.1; let __v_283: G = (__v_277 + __v_280); let __v_284: G = (__v_279 + __v_282); let __v_285: G = (__v_281 + __v_276); let __v_286: G = (__v_275 + __v_278); let __u32_sum: u128 = ((u128::from(((((__v_256.as_canonical_u64() << 0) | (__v_257.as_canonical_u64() << 8)) | (__v_258.as_canonical_u64() << 16)) | (__v_259.as_canonical_u64() << 24))) + u128::from(((((__v_283.as_canonical_u64() << 0) | (__v_284.as_canonical_u64() << 8)) | (__v_285.as_canonical_u64() << 16)) | (__v_286.as_canonical_u64() << 24)))) + u128::from(((((__v_85.as_canonical_u64() << 0) | (__v_86.as_canonical_u64() << 8)) | (__v_87.as_canonical_u64() << 16)) | (__v_88.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_287: G = G::from_u8(__u32_bytes[0]); let __v_288: G = G::from_u8(__u32_bytes[1]); let __v_289: G = G::from_u8(__u32_bytes[2]); let __v_290: G = G::from_u8(__u32_bytes[3]); let __v_291: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_287; let __vj = __v_288; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_289; let __vj = __v_290; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_292: G = (__v_291 - __v_134); let __v_293: G = (__v_291 - __v_136); let __v_294: G = (__v_292 * __v_293); let __v_295: G = (__v_291 * __v_294); if (__v_295 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_295.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_267), (&__v_287)) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_268), (&__v_288)) } else { aiur::execute::bytes2_xor_value(__v_268, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_265), (&__v_289)) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __v_299: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_266), (&__v_290)) } else { aiur::execute::bytes2_xor_value(__v_266, __v_290, record) }; let __u32_sum: u128 = (u128::from(((((__v_269.as_canonical_u64() << 0) | (__v_270.as_canonical_u64() << 8)) | (__v_271.as_canonical_u64() << 16)) | (__v_272.as_canonical_u64() << 24))) + u128::from(((((__v_297.as_canonical_u64() << 0) | (__v_298.as_canonical_u64() << 8)) | (__v_299.as_canonical_u64() << 16)) | (__v_296.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_300: G = G::from_u8(__u32_bytes[0]); let __v_301: G = G::from_u8(__u32_bytes[1]); let __v_302: G = G::from_u8(__u32_bytes[2]); let __v_303: G = G::from_u8(__u32_bytes[3]); let __v_304: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_300; let __vj = __v_301; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_302; let __vj = __v_303; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_305: G = (__v_304 * __v_304); if (__v_305 != __v_304) { return Err(ExecError::AssertEqMismatch { lhs: __v_305.as_canonical_u64(), rhs: __v_304.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_283), (&__v_300)) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_306: G = __b2_out.0; let __v_307: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_284), (&__v_301)) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_308: G = __b2_out.0; let __v_309: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_285), (&__v_302)) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_310: G = __b2_out.0; let __v_311: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_286), (&__v_303)) } else { aiur::execute::bytes2_xor_split7_value(__v_286, __v_303, record) }; let __v_312: G = __b2_out.0; let __v_313: G = __b2_out.1; let __v_314: G = (__v_306 + __v_309); let __v_315: G = (__v_308 + __v_311); let __v_316: G = (__v_310 + __v_313); let __v_317: G = (__v_312 + __v_307); let __u32_sum: u128 = ((u128::from(((((__v_13.as_canonical_u64() << 0) | (__v_14.as_canonical_u64() << 8)) | (__v_15.as_canonical_u64() << 16)) | (__v_16.as_canonical_u64() << 24))) + u128::from(((((__v_29.as_canonical_u64() << 0) | (__v_30.as_canonical_u64() << 8)) | (__v_31.as_canonical_u64() << 16)) | (__v_32.as_canonical_u64() << 24)))) + u128::from(((((__v_89.as_canonical_u64() << 0) | (__v_90.as_canonical_u64() << 8)) | (__v_91.as_canonical_u64() << 16)) | (__v_92.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_318: G = G::from_u8(__u32_bytes[0]); let __v_319: G = G::from_u8(__u32_bytes[1]); let __v_320: G = G::from_u8(__u32_bytes[2]); let __v_321: G = G::from_u8(__u32_bytes[3]); let __v_322: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_318; let __vj = __v_319; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_320; let __vj = __v_321; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_323: G = (__v_322 - __v_134); let __v_324: G = (__v_322 - __v_136); let __v_325: G = (__v_323 * __v_324); let __v_326: G = (__v_322 * __v_325); if (__v_326 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_326.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_61), (&__v_318)) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_62), (&__v_319)) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_63), (&__v_320)) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __v_330: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_64), (&__v_321)) } else { aiur::execute::bytes2_xor_value(__v_64, __v_321, record) }; let __u32_sum: u128 = (u128::from(((((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8)) | (__v_47.as_canonical_u64() << 16)) | (__v_48.as_canonical_u64() << 24))) + u128::from(((((__v_329.as_canonical_u64() << 0) | (__v_330.as_canonical_u64() << 8)) | (__v_327.as_canonical_u64() << 16)) | (__v_328.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_331: G = G::from_u8(__u32_bytes[0]); let __v_332: G = G::from_u8(__u32_bytes[1]); let __v_333: G = G::from_u8(__u32_bytes[2]); let __v_334: G = G::from_u8(__u32_bytes[3]); let __v_335: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_331; let __vj = __v_332; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_333; let __vj = __v_334; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_336: G = (__v_335 * __v_335); if (__v_336 != __v_335) { return Err(ExecError::AssertEqMismatch { lhs: __v_336.as_canonical_u64(), rhs: __v_335.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_29), (&__v_331)) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_337: G = __b2_out.0; let __v_338: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_30), (&__v_332)) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_339: G = __b2_out.0; let __v_340: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_31), (&__v_333)) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_341: G = __b2_out.0; let __v_342: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_32), (&__v_334)) } else { aiur::execute::bytes2_xor_split4_value(__v_32, __v_334, record) }; let __v_343: G = __b2_out.0; let __v_344: G = __b2_out.1; let __v_345: G = (__v_339 + __v_342); let __v_346: G = (__v_341 + __v_344); let __v_347: G = (__v_343 + __v_338); let __v_348: G = (__v_337 + __v_340); let __u32_sum: u128 = ((u128::from(((((__v_318.as_canonical_u64() << 0) | (__v_319.as_canonical_u64() << 8)) | (__v_320.as_canonical_u64() << 16)) | (__v_321.as_canonical_u64() << 24))) + u128::from(((((__v_345.as_canonical_u64() << 0) | (__v_346.as_canonical_u64() << 8)) | (__v_347.as_canonical_u64() << 16)) | (__v_348.as_canonical_u64() << 24)))) + u128::from(((((__v_93.as_canonical_u64() << 0) | (__v_94.as_canonical_u64() << 8)) | (__v_95.as_canonical_u64() << 16)) | (__v_96.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_349: G = G::from_u8(__u32_bytes[0]); let __v_350: G = G::from_u8(__u32_bytes[1]); let __v_351: G = G::from_u8(__u32_bytes[2]); let __v_352: G = G::from_u8(__u32_bytes[3]); let __v_353: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_349; let __vj = __v_350; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_351; let __vj = __v_352; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_354: G = (__v_353 - __v_134); let __v_355: G = (__v_353 - __v_136); let __v_356: G = (__v_354 * __v_355); let __v_357: G = (__v_353 * __v_356); if (__v_357 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_329), (&__v_349)) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_330), (&__v_350)) } else { aiur::execute::bytes2_xor_value(__v_330, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_327), (&__v_351)) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __v_361: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_328), (&__v_352)) } else { aiur::execute::bytes2_xor_value(__v_328, __v_352, record) }; let __u32_sum: u128 = (u128::from(((((__v_331.as_canonical_u64() << 0) | (__v_332.as_canonical_u64() << 8)) | (__v_333.as_canonical_u64() << 16)) | (__v_334.as_canonical_u64() << 24))) + u128::from(((((__v_359.as_canonical_u64() << 0) | (__v_360.as_canonical_u64() << 8)) | (__v_361.as_canonical_u64() << 16)) | (__v_358.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_362: G = G::from_u8(__u32_bytes[0]); let __v_363: G = G::from_u8(__u32_bytes[1]); let __v_364: G = G::from_u8(__u32_bytes[2]); let __v_365: G = G::from_u8(__u32_bytes[3]); let __v_366: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_362; let __vj = __v_363; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_364; let __vj = __v_365; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_367: G = (__v_366 * __v_366); if (__v_367 != __v_366) { return Err(ExecError::AssertEqMismatch { lhs: __v_367.as_canonical_u64(), rhs: __v_366.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_345), (&__v_362)) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_368: G = __b2_out.0; let __v_369: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_346), (&__v_363)) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_370: G = __b2_out.0; let __v_371: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_347), (&__v_364)) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_372: G = __b2_out.0; let __v_373: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_348), (&__v_365)) } else { aiur::execute::bytes2_xor_split7_value(__v_348, __v_365, record) }; let __v_374: G = __b2_out.0; let __v_375: G = __b2_out.1; let __v_376: G = (__v_368 + __v_371); let __v_377: G = (__v_370 + __v_373); let __v_378: G = (__v_372 + __v_375); let __v_379: G = (__v_374 + __v_369); let __u32_sum: u128 = ((u128::from(((((__v_163.as_canonical_u64() << 0) | (__v_164.as_canonical_u64() << 8)) | (__v_165.as_canonical_u64() << 16)) | (__v_166.as_canonical_u64() << 24))) + u128::from(((((__v_252.as_canonical_u64() << 0) | (__v_253.as_canonical_u64() << 8)) | (__v_254.as_canonical_u64() << 16)) | (__v_255.as_canonical_u64() << 24)))) + u128::from(((((__v_97.as_canonical_u64() << 0) | (__v_98.as_canonical_u64() << 8)) | (__v_99.as_canonical_u64() << 16)) | (__v_100.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_380: G = G::from_u8(__u32_bytes[0]); let __v_381: G = G::from_u8(__u32_bytes[1]); let __v_382: G = G::from_u8(__u32_bytes[2]); let __v_383: G = G::from_u8(__u32_bytes[3]); let __v_384: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_380; let __vj = __v_381; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_382; let __vj = __v_383; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_385: G = (__v_384 - __v_134); let __v_386: G = (__v_384 - __v_136); let __v_387: G = (__v_385 * __v_386); let __v_388: G = (__v_384 * __v_387); if (__v_388 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_359), (&__v_380)) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_360), (&__v_381)) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_361), (&__v_382)) } else { aiur::execute::bytes2_xor_value(__v_361, __v_382, record) }; let __v_392: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_358), (&__v_383)) } else { aiur::execute::bytes2_xor_value(__v_358, __v_383, record) }; let __u32_sum: u128 = (u128::from(((((__v_300.as_canonical_u64() << 0) | (__v_301.as_canonical_u64() << 8)) | (__v_302.as_canonical_u64() << 16)) | (__v_303.as_canonical_u64() << 24))) + u128::from(((((__v_391.as_canonical_u64() << 0) | (__v_392.as_canonical_u64() << 8)) | (__v_389.as_canonical_u64() << 16)) | (__v_390.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_393: G = G::from_u8(__u32_bytes[0]); let __v_394: G = G::from_u8(__u32_bytes[1]); let __v_395: G = G::from_u8(__u32_bytes[2]); let __v_396: G = G::from_u8(__u32_bytes[3]); let __v_397: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_393; let __vj = __v_394; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_395; let __vj = __v_396; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_398: G = (__v_397 * __v_397); if (__v_398 != __v_397) { return Err(ExecError::AssertEqMismatch { lhs: __v_398.as_canonical_u64(), rhs: __v_397.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_252), (&__v_393)) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_399: G = __b2_out.0; let __v_400: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_253), (&__v_394)) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_401: G = __b2_out.0; let __v_402: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_254), (&__v_395)) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_403: G = __b2_out.0; let __v_404: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_255), (&__v_396)) } else { aiur::execute::bytes2_xor_split4_value(__v_255, __v_396, record) }; let __v_405: G = __b2_out.0; let __v_406: G = __b2_out.1; let __v_407: G = (__v_401 + __v_404); let __v_408: G = (__v_403 + __v_406); let __v_409: G = (__v_405 + __v_400); let __v_410: G = (__v_399 + __v_402); let __u32_sum: u128 = ((u128::from(((((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8)) | (__v_382.as_canonical_u64() << 16)) | (__v_383.as_canonical_u64() << 24))) + u128::from(((((__v_407.as_canonical_u64() << 0) | (__v_408.as_canonical_u64() << 8)) | (__v_409.as_canonical_u64() << 16)) | (__v_410.as_canonical_u64() << 24)))) + u128::from(((((__v_101.as_canonical_u64() << 0) | (__v_102.as_canonical_u64() << 8)) | (__v_103.as_canonical_u64() << 16)) | (__v_104.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_411: G = G::from_u8(__u32_bytes[0]); let __v_412: G = G::from_u8(__u32_bytes[1]); let __v_413: G = G::from_u8(__u32_bytes[2]); let __v_414: G = G::from_u8(__u32_bytes[3]); let __v_415: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_411; let __vj = __v_412; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_413; let __vj = __v_414; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_416: G = (__v_415 - __v_134); let __v_417: G = (__v_415 - __v_136); let __v_418: G = (__v_416 * __v_417); let __v_419: G = (__v_415 * __v_418); if (__v_419 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_419.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_391), (&__v_411)) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_392), (&__v_412)) } else { aiur::execute::bytes2_xor_value(__v_392, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_389), (&__v_413)) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __v_423: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_390), (&__v_414)) } else { aiur::execute::bytes2_xor_value(__v_390, __v_414, record) }; let __u32_sum: u128 = (u128::from(((((__v_393.as_canonical_u64() << 0) | (__v_394.as_canonical_u64() << 8)) | (__v_395.as_canonical_u64() << 16)) | (__v_396.as_canonical_u64() << 24))) + u128::from(((((__v_421.as_canonical_u64() << 0) | (__v_422.as_canonical_u64() << 8)) | (__v_423.as_canonical_u64() << 16)) | (__v_420.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_424: G = G::from_u8(__u32_bytes[0]); let __v_425: G = G::from_u8(__u32_bytes[1]); let __v_426: G = G::from_u8(__u32_bytes[2]); let __v_427: G = G::from_u8(__u32_bytes[3]); let __v_428: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_424; let __vj = __v_425; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_426; let __vj = __v_427; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_429: G = (__v_428 * __v_428); if (__v_429 != __v_428) { return Err(ExecError::AssertEqMismatch { lhs: __v_429.as_canonical_u64(), rhs: __v_428.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_407), (&__v_424)) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_430: G = __b2_out.0; let __v_431: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_408), (&__v_425)) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_432: G = __b2_out.0; let __v_433: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_409), (&__v_426)) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_434: G = __b2_out.0; let __v_435: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_410), (&__v_427)) } else { aiur::execute::bytes2_xor_split7_value(__v_410, __v_427, record) }; let __v_436: G = __b2_out.0; let __v_437: G = __b2_out.1; let __v_438: G = (__v_430 + __v_433); let __v_439: G = (__v_432 + __v_435); let __v_440: G = (__v_434 + __v_437); let __v_441: G = (__v_436 + __v_431); let __u32_sum: u128 = ((u128::from(((((__v_225.as_canonical_u64() << 0) | (__v_226.as_canonical_u64() << 8)) | (__v_227.as_canonical_u64() << 16)) | (__v_228.as_canonical_u64() << 24))) + u128::from(((((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8)) | (__v_316.as_canonical_u64() << 16)) | (__v_317.as_canonical_u64() << 24)))) + u128::from(((((__v_105.as_canonical_u64() << 0) | (__v_106.as_canonical_u64() << 8)) | (__v_107.as_canonical_u64() << 16)) | (__v_108.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_442: G = G::from_u8(__u32_bytes[0]); let __v_443: G = G::from_u8(__u32_bytes[1]); let __v_444: G = G::from_u8(__u32_bytes[2]); let __v_445: G = G::from_u8(__u32_bytes[3]); let __v_446: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_442; let __vj = __v_443; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_444; let __vj = __v_445; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_447: G = (__v_446 - __v_134); let __v_448: G = (__v_446 - __v_136); let __v_449: G = (__v_447 * __v_448); let __v_450: G = (__v_446 * __v_449); if (__v_450 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_450.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_173), (&__v_442)) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_174), (&__v_443)) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_175), (&__v_444)) } else { aiur::execute::bytes2_xor_value(__v_175, __v_444, record) }; let __v_454: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_172), (&__v_445)) } else { aiur::execute::bytes2_xor_value(__v_172, __v_445, record) }; let __u32_sum: u128 = (u128::from(((((__v_362.as_canonical_u64() << 0) | (__v_363.as_canonical_u64() << 8)) | (__v_364.as_canonical_u64() << 16)) | (__v_365.as_canonical_u64() << 24))) + u128::from(((((__v_453.as_canonical_u64() << 0) | (__v_454.as_canonical_u64() << 8)) | (__v_451.as_canonical_u64() << 16)) | (__v_452.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_455: G = G::from_u8(__u32_bytes[0]); let __v_456: G = G::from_u8(__u32_bytes[1]); let __v_457: G = G::from_u8(__u32_bytes[2]); let __v_458: G = G::from_u8(__u32_bytes[3]); let __v_459: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_455; let __vj = __v_456; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_457; let __vj = __v_458; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_460: G = (__v_459 * __v_459); if (__v_460 != __v_459) { return Err(ExecError::AssertEqMismatch { lhs: __v_460.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_314), (&__v_455)) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_461: G = __b2_out.0; let __v_462: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_315), (&__v_456)) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_463: G = __b2_out.0; let __v_464: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_316), (&__v_457)) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_465: G = __b2_out.0; let __v_466: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_317), (&__v_458)) } else { aiur::execute::bytes2_xor_split4_value(__v_317, __v_458, record) }; let __v_467: G = __b2_out.0; let __v_468: G = __b2_out.1; let __v_469: G = (__v_463 + __v_466); let __v_470: G = (__v_465 + __v_468); let __v_471: G = (__v_467 + __v_462); let __v_472: G = (__v_461 + __v_464); let __u32_sum: u128 = ((u128::from(((((__v_442.as_canonical_u64() << 0) | (__v_443.as_canonical_u64() << 8)) | (__v_444.as_canonical_u64() << 16)) | (__v_445.as_canonical_u64() << 24))) + u128::from(((((__v_469.as_canonical_u64() << 0) | (__v_470.as_canonical_u64() << 8)) | (__v_471.as_canonical_u64() << 16)) | (__v_472.as_canonical_u64() << 24)))) + u128::from(((((__v_109.as_canonical_u64() << 0) | (__v_110.as_canonical_u64() << 8)) | (__v_111.as_canonical_u64() << 16)) | (__v_112.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_473: G = G::from_u8(__u32_bytes[0]); let __v_474: G = G::from_u8(__u32_bytes[1]); let __v_475: G = G::from_u8(__u32_bytes[2]); let __v_476: G = G::from_u8(__u32_bytes[3]); let __v_477: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_473; let __vj = __v_474; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_475; let __vj = __v_476; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_478: G = (__v_477 - __v_134); let __v_479: G = (__v_477 - __v_136); let __v_480: G = (__v_478 * __v_479); let __v_481: G = (__v_477 * __v_480); if (__v_481 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_481.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_453), (&__v_473)) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_454), (&__v_474)) } else { aiur::execute::bytes2_xor_value(__v_454, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_451), (&__v_475)) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __v_485: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_452), (&__v_476)) } else { aiur::execute::bytes2_xor_value(__v_452, __v_476, record) }; let __u32_sum: u128 = (u128::from(((((__v_455.as_canonical_u64() << 0) | (__v_456.as_canonical_u64() << 8)) | (__v_457.as_canonical_u64() << 16)) | (__v_458.as_canonical_u64() << 24))) + u128::from(((((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8)) | (__v_485.as_canonical_u64() << 16)) | (__v_482.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_486: G = G::from_u8(__u32_bytes[0]); let __v_487: G = G::from_u8(__u32_bytes[1]); let __v_488: G = G::from_u8(__u32_bytes[2]); let __v_489: G = G::from_u8(__u32_bytes[3]); let __v_490: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_486; let __vj = __v_487; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_488; let __vj = __v_489; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_491: G = (__v_490 * __v_490); if (__v_491 != __v_490) { return Err(ExecError::AssertEqMismatch { lhs: __v_491.as_canonical_u64(), rhs: __v_490.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_469), (&__v_486)) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_492: G = __b2_out.0; let __v_493: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_470), (&__v_487)) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_494: G = __b2_out.0; let __v_495: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_471), (&__v_488)) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_496: G = __b2_out.0; let __v_497: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_472), (&__v_489)) } else { aiur::execute::bytes2_xor_split7_value(__v_472, __v_489, record) }; let __v_498: G = __b2_out.0; let __v_499: G = __b2_out.1; let __v_500: G = (__v_492 + __v_495); let __v_501: G = (__v_494 + __v_497); let __v_502: G = (__v_496 + __v_499); let __v_503: G = (__v_498 + __v_493); let __u32_sum: u128 = ((u128::from(((((__v_287.as_canonical_u64() << 0) | (__v_288.as_canonical_u64() << 8)) | (__v_289.as_canonical_u64() << 16)) | (__v_290.as_canonical_u64() << 24))) + u128::from(((((__v_376.as_canonical_u64() << 0) | (__v_377.as_canonical_u64() << 8)) | (__v_378.as_canonical_u64() << 16)) | (__v_379.as_canonical_u64() << 24)))) + u128::from(((((__v_113.as_canonical_u64() << 0) | (__v_114.as_canonical_u64() << 8)) | (__v_115.as_canonical_u64() << 16)) | (__v_116.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_504: G = G::from_u8(__u32_bytes[0]); let __v_505: G = G::from_u8(__u32_bytes[1]); let __v_506: G = G::from_u8(__u32_bytes[2]); let __v_507: G = G::from_u8(__u32_bytes[3]); let __v_508: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_504; let __vj = __v_505; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_506; let __vj = __v_507; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_509: G = (__v_508 - __v_134); let __v_510: G = (__v_508 - __v_136); let __v_511: G = (__v_509 * __v_510); let __v_512: G = (__v_508 * __v_511); if (__v_512 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_235), (&__v_504)) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_236), (&__v_505)) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_237), (&__v_506)) } else { aiur::execute::bytes2_xor_value(__v_237, __v_506, record) }; let __v_516: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_234), (&__v_507)) } else { aiur::execute::bytes2_xor_value(__v_234, __v_507, record) }; let __u32_sum: u128 = (u128::from(((((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8)) | (__v_178.as_canonical_u64() << 16)) | (__v_179.as_canonical_u64() << 24))) + u128::from(((((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8)) | (__v_513.as_canonical_u64() << 16)) | (__v_514.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_517: G = G::from_u8(__u32_bytes[0]); let __v_518: G = G::from_u8(__u32_bytes[1]); let __v_519: G = G::from_u8(__u32_bytes[2]); let __v_520: G = G::from_u8(__u32_bytes[3]); let __v_521: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_517; let __vj = __v_518; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_519; let __vj = __v_520; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_522: G = (__v_521 * __v_521); if (__v_522 != __v_521) { return Err(ExecError::AssertEqMismatch { lhs: __v_522.as_canonical_u64(), rhs: __v_521.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_376), (&__v_517)) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_523: G = __b2_out.0; let __v_524: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_377), (&__v_518)) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_525: G = __b2_out.0; let __v_526: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_378), (&__v_519)) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_527: G = __b2_out.0; let __v_528: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_379), (&__v_520)) } else { aiur::execute::bytes2_xor_split4_value(__v_379, __v_520, record) }; let __v_529: G = __b2_out.0; let __v_530: G = __b2_out.1; let __v_531: G = (__v_525 + __v_528); let __v_532: G = (__v_527 + __v_530); let __v_533: G = (__v_529 + __v_524); let __v_534: G = (__v_523 + __v_526); let __u32_sum: u128 = ((u128::from(((((__v_504.as_canonical_u64() << 0) | (__v_505.as_canonical_u64() << 8)) | (__v_506.as_canonical_u64() << 16)) | (__v_507.as_canonical_u64() << 24))) + u128::from(((((__v_531.as_canonical_u64() << 0) | (__v_532.as_canonical_u64() << 8)) | (__v_533.as_canonical_u64() << 16)) | (__v_534.as_canonical_u64() << 24)))) + u128::from(((((__v_117.as_canonical_u64() << 0) | (__v_118.as_canonical_u64() << 8)) | (__v_119.as_canonical_u64() << 16)) | (__v_120.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_535: G = G::from_u8(__u32_bytes[0]); let __v_536: G = G::from_u8(__u32_bytes[1]); let __v_537: G = G::from_u8(__u32_bytes[2]); let __v_538: G = G::from_u8(__u32_bytes[3]); let __v_539: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_535; let __vj = __v_536; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_537; let __vj = __v_538; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_540: G = (__v_539 - __v_134); let __v_541: G = (__v_539 - __v_136); let __v_542: G = (__v_540 * __v_541); let __v_543: G = (__v_539 * __v_542); if (__v_543 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_515), (&__v_535)) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_516), (&__v_536)) } else { aiur::execute::bytes2_xor_value(__v_516, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_513), (&__v_537)) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __v_547: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_514), (&__v_538)) } else { aiur::execute::bytes2_xor_value(__v_514, __v_538, record) }; let __u32_sum: u128 = (u128::from(((((__v_517.as_canonical_u64() << 0) | (__v_518.as_canonical_u64() << 8)) | (__v_519.as_canonical_u64() << 16)) | (__v_520.as_canonical_u64() << 24))) + u128::from(((((__v_545.as_canonical_u64() << 0) | (__v_546.as_canonical_u64() << 8)) | (__v_547.as_canonical_u64() << 16)) | (__v_544.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_548: G = G::from_u8(__u32_bytes[0]); let __v_549: G = G::from_u8(__u32_bytes[1]); let __v_550: G = G::from_u8(__u32_bytes[2]); let __v_551: G = G::from_u8(__u32_bytes[3]); let __v_552: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_548; let __vj = __v_549; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_550; let __vj = __v_551; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_553: G = (__v_552 * __v_552); if (__v_553 != __v_552) { return Err(ExecError::AssertEqMismatch { lhs: __v_553.as_canonical_u64(), rhs: __v_552.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_531), (&__v_548)) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_554: G = __b2_out.0; let __v_555: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_532), (&__v_549)) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_556: G = __b2_out.0; let __v_557: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_533), (&__v_550)) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_558: G = __b2_out.0; let __v_559: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_534), (&__v_551)) } else { aiur::execute::bytes2_xor_split7_value(__v_534, __v_551, record) }; let __v_560: G = __b2_out.0; let __v_561: G = __b2_out.1; let __v_562: G = (__v_554 + __v_557); let __v_563: G = (__v_556 + __v_559); let __v_564: G = (__v_558 + __v_561); let __v_565: G = (__v_560 + __v_555); let __u32_sum: u128 = ((u128::from(((((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8)) | (__v_351.as_canonical_u64() << 16)) | (__v_352.as_canonical_u64() << 24))) + u128::from(((((__v_190.as_canonical_u64() << 0) | (__v_191.as_canonical_u64() << 8)) | (__v_192.as_canonical_u64() << 16)) | (__v_193.as_canonical_u64() << 24)))) + u128::from(((((__v_121.as_canonical_u64() << 0) | (__v_122.as_canonical_u64() << 8)) | (__v_123.as_canonical_u64() << 16)) | (__v_124.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_566: G = G::from_u8(__u32_bytes[0]); let __v_567: G = G::from_u8(__u32_bytes[1]); let __v_568: G = G::from_u8(__u32_bytes[2]); let __v_569: G = G::from_u8(__u32_bytes[3]); let __v_570: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_566; let __vj = __v_567; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_568; let __vj = __v_569; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_571: G = (__v_570 - __v_134); let __v_572: G = (__v_570 - __v_136); let __v_573: G = (__v_571 * __v_572); let __v_574: G = (__v_570 * __v_573); if (__v_574 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_574.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_297), (&__v_566)) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_298), (&__v_567)) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_299), (&__v_568)) } else { aiur::execute::bytes2_xor_value(__v_299, __v_568, record) }; let __v_578: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_296), (&__v_569)) } else { aiur::execute::bytes2_xor_value(__v_296, __v_569, record) }; let __u32_sum: u128 = (u128::from(((((__v_238.as_canonical_u64() << 0) | (__v_239.as_canonical_u64() << 8)) | (__v_240.as_canonical_u64() << 16)) | (__v_241.as_canonical_u64() << 24))) + u128::from(((((__v_577.as_canonical_u64() << 0) | (__v_578.as_canonical_u64() << 8)) | (__v_575.as_canonical_u64() << 16)) | (__v_576.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_579: G = G::from_u8(__u32_bytes[0]); let __v_580: G = G::from_u8(__u32_bytes[1]); let __v_581: G = G::from_u8(__u32_bytes[2]); let __v_582: G = G::from_u8(__u32_bytes[3]); let __v_583: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_579; let __vj = __v_580; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_581; let __vj = __v_582; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_584: G = (__v_583 * __v_583); if (__v_584 != __v_583) { return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_583.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_190), (&__v_579)) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_585: G = __b2_out.0; let __v_586: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_191), (&__v_580)) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_587: G = __b2_out.0; let __v_588: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_192), (&__v_581)) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_589: G = __b2_out.0; let __v_590: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_193), (&__v_582)) } else { aiur::execute::bytes2_xor_split4_value(__v_193, __v_582, record) }; let __v_591: G = __b2_out.0; let __v_592: G = __b2_out.1; let __v_593: G = (__v_587 + __v_590); let __v_594: G = (__v_589 + __v_592); let __v_595: G = (__v_591 + __v_586); let __v_596: G = (__v_585 + __v_588); let __u32_sum: u128 = ((u128::from(((((__v_566.as_canonical_u64() << 0) | (__v_567.as_canonical_u64() << 8)) | (__v_568.as_canonical_u64() << 16)) | (__v_569.as_canonical_u64() << 24))) + u128::from(((((__v_593.as_canonical_u64() << 0) | (__v_594.as_canonical_u64() << 8)) | (__v_595.as_canonical_u64() << 16)) | (__v_596.as_canonical_u64() << 24)))) + u128::from(((((__v_125.as_canonical_u64() << 0) | (__v_126.as_canonical_u64() << 8)) | (__v_127.as_canonical_u64() << 16)) | (__v_128.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_597: G = G::from_u8(__u32_bytes[0]); let __v_598: G = G::from_u8(__u32_bytes[1]); let __v_599: G = G::from_u8(__u32_bytes[2]); let __v_600: G = G::from_u8(__u32_bytes[3]); let __v_601: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_597; let __vj = __v_598; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_599; let __vj = __v_600; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_602: G = (__v_601 - __v_134); let __v_603: G = (__v_601 - __v_136); let __v_604: G = (__v_602 * __v_603); let __v_605: G = (__v_601 * __v_604); if (__v_605 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_605.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_577), (&__v_597)) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_578), (&__v_598)) } else { aiur::execute::bytes2_xor_value(__v_578, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_575), (&__v_599)) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __v_609: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_576), (&__v_600)) } else { aiur::execute::bytes2_xor_value(__v_576, __v_600, record) }; let __u32_sum: u128 = (u128::from(((((__v_579.as_canonical_u64() << 0) | (__v_580.as_canonical_u64() << 8)) | (__v_581.as_canonical_u64() << 16)) | (__v_582.as_canonical_u64() << 24))) + u128::from(((((__v_607.as_canonical_u64() << 0) | (__v_608.as_canonical_u64() << 8)) | (__v_609.as_canonical_u64() << 16)) | (__v_606.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_610: G = G::from_u8(__u32_bytes[0]); let __v_611: G = G::from_u8(__u32_bytes[1]); let __v_612: G = G::from_u8(__u32_bytes[2]); let __v_613: G = G::from_u8(__u32_bytes[3]); let __v_614: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_610; let __vj = __v_611; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_612; let __vj = __v_613; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_615: G = (__v_614 * __v_614); if (__v_615 != __v_614) { return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_614.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_593), (&__v_610)) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_616: G = __b2_out.0; let __v_617: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_594), (&__v_611)) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_618: G = __b2_out.0; let __v_619: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_595), (&__v_612)) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_620: G = __b2_out.0; let __v_621: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_596), (&__v_613)) } else { aiur::execute::bytes2_xor_split7_value(__v_596, __v_613, record) }; let __v_622: G = __b2_out.0; let __v_623: G = __b2_out.1; let __v_624: G = (__v_616 + __v_619); let __v_625: G = (__v_618 + __v_621); let __v_626: G = (__v_620 + __v_623); let __v_627: G = (__v_622 + __v_617); let __v_628: G = (__v_0 + __v_134); let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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(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_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_35] = [__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[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_36: usize = 19; -const IN_36: usize = 19; +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 __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_34] = [__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[34].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __u32_sum: u128 = ((u128::from(((((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8)) | (__v_3.as_canonical_u64() << 16)) | (__v_4.as_canonical_u64() << 24))) + u128::from(((((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8)) | (__v_19.as_canonical_u64() << 16)) | (__v_20.as_canonical_u64() << 24)))) + u128::from(((((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8)) | (__v_67.as_canonical_u64() << 16)) | (__v_68.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_129: G = G::from_u8(__u32_bytes[0]); let __v_130: G = G::from_u8(__u32_bytes[1]); let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_134: G = G::from_u64(1); let __v_135: G = (__v_133 - __v_134); let __v_136: G = G::from_u64(2); let __v_137: G = (__v_133 - __v_136); let __v_138: G = (__v_135 * __v_137); let __v_139: G = (__v_133 * __v_138); let __v_140: G = G::from_u64(0); if (__v_139 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_49), (&__v_129)) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_50), (&__v_130)) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_51), (&__v_131)) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_52), (&__v_132)) } else { aiur::execute::bytes2_xor_value(__v_52, __v_132, record) }; let __u32_sum: u128 = (u128::from(((((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8)) | (__v_35.as_canonical_u64() << 16)) | (__v_36.as_canonical_u64() << 24))) + u128::from(((((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8)) | (__v_141.as_canonical_u64() << 16)) | (__v_142.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_145: G = G::from_u8(__u32_bytes[0]); let __v_146: G = G::from_u8(__u32_bytes[1]); let __v_147: G = G::from_u8(__u32_bytes[2]); let __v_148: G = G::from_u8(__u32_bytes[3]); let __v_149: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_147; let __vj = __v_148; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_150: G = (__v_149 * __v_149); if (__v_150 != __v_149) { return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_17), (&__v_145)) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_151: G = __b2_out.0; let __v_152: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_18), (&__v_146)) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_153: G = __b2_out.0; let __v_154: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_19), (&__v_147)) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_155: G = __b2_out.0; let __v_156: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_20), (&__v_148)) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_148, record) }; let __v_157: G = __b2_out.0; let __v_158: G = __b2_out.1; let __v_159: G = (__v_153 + __v_156); let __v_160: G = (__v_155 + __v_158); let __v_161: G = (__v_157 + __v_152); let __v_162: G = (__v_151 + __v_154); let __u32_sum: u128 = ((u128::from(((((__v_129.as_canonical_u64() << 0) | (__v_130.as_canonical_u64() << 8)) | (__v_131.as_canonical_u64() << 16)) | (__v_132.as_canonical_u64() << 24))) + u128::from(((((__v_159.as_canonical_u64() << 0) | (__v_160.as_canonical_u64() << 8)) | (__v_161.as_canonical_u64() << 16)) | (__v_162.as_canonical_u64() << 24)))) + u128::from(((((__v_69.as_canonical_u64() << 0) | (__v_70.as_canonical_u64() << 8)) | (__v_71.as_canonical_u64() << 16)) | (__v_72.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_163: G = G::from_u8(__u32_bytes[0]); let __v_164: G = G::from_u8(__u32_bytes[1]); let __v_165: G = G::from_u8(__u32_bytes[2]); let __v_166: G = G::from_u8(__u32_bytes[3]); let __v_167: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_163; let __vj = __v_164; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_165; let __vj = __v_166; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_168: G = (__v_167 - __v_134); let __v_169: G = (__v_167 - __v_136); let __v_170: G = (__v_168 * __v_169); let __v_171: G = (__v_167 * __v_170); if (__v_171 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_143), (&__v_163)) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_144), (&__v_164)) } else { aiur::execute::bytes2_xor_value(__v_144, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_141), (&__v_165)) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __v_175: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_142), (&__v_166)) } else { aiur::execute::bytes2_xor_value(__v_142, __v_166, record) }; let __u32_sum: u128 = (u128::from(((((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8)) | (__v_147.as_canonical_u64() << 16)) | (__v_148.as_canonical_u64() << 24))) + u128::from(((((__v_173.as_canonical_u64() << 0) | (__v_174.as_canonical_u64() << 8)) | (__v_175.as_canonical_u64() << 16)) | (__v_172.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_176: G = G::from_u8(__u32_bytes[0]); let __v_177: G = G::from_u8(__u32_bytes[1]); let __v_178: G = G::from_u8(__u32_bytes[2]); let __v_179: G = G::from_u8(__u32_bytes[3]); let __v_180: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_176; let __vj = __v_177; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_178; let __vj = __v_179; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_181: G = (__v_180 * __v_180); if (__v_181 != __v_180) { return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_180.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_159), (&__v_176)) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_182: G = __b2_out.0; let __v_183: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_160), (&__v_177)) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_184: G = __b2_out.0; let __v_185: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_161), (&__v_178)) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_186: G = __b2_out.0; let __v_187: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_162), (&__v_179)) } else { aiur::execute::bytes2_xor_split7_value(__v_162, __v_179, record) }; let __v_188: G = __b2_out.0; let __v_189: G = __b2_out.1; let __v_190: G = (__v_182 + __v_185); let __v_191: G = (__v_184 + __v_187); let __v_192: G = (__v_186 + __v_189); let __v_193: G = (__v_188 + __v_183); let __u32_sum: u128 = ((u128::from(((((__v_5.as_canonical_u64() << 0) | (__v_6.as_canonical_u64() << 8)) | (__v_7.as_canonical_u64() << 16)) | (__v_8.as_canonical_u64() << 24))) + u128::from(((((__v_21.as_canonical_u64() << 0) | (__v_22.as_canonical_u64() << 8)) | (__v_23.as_canonical_u64() << 16)) | (__v_24.as_canonical_u64() << 24)))) + u128::from(((((__v_73.as_canonical_u64() << 0) | (__v_74.as_canonical_u64() << 8)) | (__v_75.as_canonical_u64() << 16)) | (__v_76.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_194: G = G::from_u8(__u32_bytes[0]); let __v_195: G = G::from_u8(__u32_bytes[1]); let __v_196: G = G::from_u8(__u32_bytes[2]); let __v_197: G = G::from_u8(__u32_bytes[3]); let __v_198: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_194; let __vj = __v_195; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_199: G = (__v_198 - __v_134); let __v_200: G = (__v_198 - __v_136); let __v_201: G = (__v_199 * __v_200); let __v_202: G = (__v_198 * __v_201); if (__v_202 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_202.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_53), (&__v_194)) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_54), (&__v_195)) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_55), (&__v_196)) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __v_206: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_56), (&__v_197)) } else { aiur::execute::bytes2_xor_value(__v_56, __v_197, record) }; let __u32_sum: u128 = (u128::from(((((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8)) | (__v_39.as_canonical_u64() << 16)) | (__v_40.as_canonical_u64() << 24))) + u128::from(((((__v_205.as_canonical_u64() << 0) | (__v_206.as_canonical_u64() << 8)) | (__v_203.as_canonical_u64() << 16)) | (__v_204.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_207: G = G::from_u8(__u32_bytes[0]); let __v_208: G = G::from_u8(__u32_bytes[1]); let __v_209: G = G::from_u8(__u32_bytes[2]); let __v_210: G = G::from_u8(__u32_bytes[3]); let __v_211: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_207; let __vj = __v_208; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_209; let __vj = __v_210; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_212: G = (__v_211 * __v_211); if (__v_212 != __v_211) { return Err(ExecError::AssertEqMismatch { lhs: __v_212.as_canonical_u64(), rhs: __v_211.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_21), (&__v_207)) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_213: G = __b2_out.0; let __v_214: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_22), (&__v_208)) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_215: G = __b2_out.0; let __v_216: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_23), (&__v_209)) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_217: G = __b2_out.0; let __v_218: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_24), (&__v_210)) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_210, record) }; let __v_219: G = __b2_out.0; let __v_220: G = __b2_out.1; let __v_221: G = (__v_215 + __v_218); let __v_222: G = (__v_217 + __v_220); let __v_223: G = (__v_219 + __v_214); let __v_224: G = (__v_213 + __v_216); let __u32_sum: u128 = ((u128::from(((((__v_194.as_canonical_u64() << 0) | (__v_195.as_canonical_u64() << 8)) | (__v_196.as_canonical_u64() << 16)) | (__v_197.as_canonical_u64() << 24))) + u128::from(((((__v_221.as_canonical_u64() << 0) | (__v_222.as_canonical_u64() << 8)) | (__v_223.as_canonical_u64() << 16)) | (__v_224.as_canonical_u64() << 24)))) + u128::from(((((__v_77.as_canonical_u64() << 0) | (__v_78.as_canonical_u64() << 8)) | (__v_79.as_canonical_u64() << 16)) | (__v_80.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_225: G = G::from_u8(__u32_bytes[0]); let __v_226: G = G::from_u8(__u32_bytes[1]); let __v_227: G = G::from_u8(__u32_bytes[2]); let __v_228: G = G::from_u8(__u32_bytes[3]); let __v_229: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_225; let __vj = __v_226; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_227; let __vj = __v_228; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_230: G = (__v_229 - __v_134); let __v_231: G = (__v_229 - __v_136); let __v_232: G = (__v_230 * __v_231); let __v_233: G = (__v_229 * __v_232); if (__v_233 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_205), (&__v_225)) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_206), (&__v_226)) } else { aiur::execute::bytes2_xor_value(__v_206, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_203), (&__v_227)) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __v_237: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_204), (&__v_228)) } else { aiur::execute::bytes2_xor_value(__v_204, __v_228, record) }; let __u32_sum: u128 = (u128::from(((((__v_207.as_canonical_u64() << 0) | (__v_208.as_canonical_u64() << 8)) | (__v_209.as_canonical_u64() << 16)) | (__v_210.as_canonical_u64() << 24))) + u128::from(((((__v_235.as_canonical_u64() << 0) | (__v_236.as_canonical_u64() << 8)) | (__v_237.as_canonical_u64() << 16)) | (__v_234.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_238: G = G::from_u8(__u32_bytes[0]); let __v_239: G = G::from_u8(__u32_bytes[1]); let __v_240: G = G::from_u8(__u32_bytes[2]); let __v_241: G = G::from_u8(__u32_bytes[3]); let __v_242: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_238; let __vj = __v_239; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_240; let __vj = __v_241; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_243: G = (__v_242 * __v_242); if (__v_243 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_221), (&__v_238)) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_244: G = __b2_out.0; let __v_245: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_222), (&__v_239)) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_246: G = __b2_out.0; let __v_247: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_223), (&__v_240)) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_248: G = __b2_out.0; let __v_249: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_224), (&__v_241)) } else { aiur::execute::bytes2_xor_split7_value(__v_224, __v_241, record) }; let __v_250: G = __b2_out.0; let __v_251: G = __b2_out.1; let __v_252: G = (__v_244 + __v_247); let __v_253: G = (__v_246 + __v_249); let __v_254: G = (__v_248 + __v_251); let __v_255: G = (__v_250 + __v_245); let __u32_sum: u128 = ((u128::from(((((__v_9.as_canonical_u64() << 0) | (__v_10.as_canonical_u64() << 8)) | (__v_11.as_canonical_u64() << 16)) | (__v_12.as_canonical_u64() << 24))) + u128::from(((((__v_25.as_canonical_u64() << 0) | (__v_26.as_canonical_u64() << 8)) | (__v_27.as_canonical_u64() << 16)) | (__v_28.as_canonical_u64() << 24)))) + u128::from(((((__v_81.as_canonical_u64() << 0) | (__v_82.as_canonical_u64() << 8)) | (__v_83.as_canonical_u64() << 16)) | (__v_84.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_256: G = G::from_u8(__u32_bytes[0]); let __v_257: G = G::from_u8(__u32_bytes[1]); let __v_258: G = G::from_u8(__u32_bytes[2]); let __v_259: G = G::from_u8(__u32_bytes[3]); let __v_260: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_256; let __vj = __v_257; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_258; let __vj = __v_259; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_261: G = (__v_260 - __v_134); let __v_262: G = (__v_260 - __v_136); let __v_263: G = (__v_261 * __v_262); let __v_264: G = (__v_260 * __v_263); if (__v_264 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_57), (&__v_256)) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_58), (&__v_257)) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_59), (&__v_258)) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __v_268: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_60), (&__v_259)) } else { aiur::execute::bytes2_xor_value(__v_60, __v_259, record) }; let __u32_sum: u128 = (u128::from(((((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8)) | (__v_43.as_canonical_u64() << 16)) | (__v_44.as_canonical_u64() << 24))) + u128::from(((((__v_267.as_canonical_u64() << 0) | (__v_268.as_canonical_u64() << 8)) | (__v_265.as_canonical_u64() << 16)) | (__v_266.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_269: G = G::from_u8(__u32_bytes[0]); let __v_270: G = G::from_u8(__u32_bytes[1]); let __v_271: G = G::from_u8(__u32_bytes[2]); let __v_272: G = G::from_u8(__u32_bytes[3]); let __v_273: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_269; let __vj = __v_270; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_271; let __vj = __v_272; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_274: G = (__v_273 * __v_273); if (__v_274 != __v_273) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_273.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_25), (&__v_269)) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_275: G = __b2_out.0; let __v_276: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_26), (&__v_270)) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_277: G = __b2_out.0; let __v_278: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_27), (&__v_271)) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_279: G = __b2_out.0; let __v_280: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_28), (&__v_272)) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_272, record) }; let __v_281: G = __b2_out.0; let __v_282: G = __b2_out.1; let __v_283: G = (__v_277 + __v_280); let __v_284: G = (__v_279 + __v_282); let __v_285: G = (__v_281 + __v_276); let __v_286: G = (__v_275 + __v_278); let __u32_sum: u128 = ((u128::from(((((__v_256.as_canonical_u64() << 0) | (__v_257.as_canonical_u64() << 8)) | (__v_258.as_canonical_u64() << 16)) | (__v_259.as_canonical_u64() << 24))) + u128::from(((((__v_283.as_canonical_u64() << 0) | (__v_284.as_canonical_u64() << 8)) | (__v_285.as_canonical_u64() << 16)) | (__v_286.as_canonical_u64() << 24)))) + u128::from(((((__v_85.as_canonical_u64() << 0) | (__v_86.as_canonical_u64() << 8)) | (__v_87.as_canonical_u64() << 16)) | (__v_88.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_287: G = G::from_u8(__u32_bytes[0]); let __v_288: G = G::from_u8(__u32_bytes[1]); let __v_289: G = G::from_u8(__u32_bytes[2]); let __v_290: G = G::from_u8(__u32_bytes[3]); let __v_291: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_287; let __vj = __v_288; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_289; let __vj = __v_290; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_292: G = (__v_291 - __v_134); let __v_293: G = (__v_291 - __v_136); let __v_294: G = (__v_292 * __v_293); let __v_295: G = (__v_291 * __v_294); if (__v_295 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_295.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_267), (&__v_287)) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_268), (&__v_288)) } else { aiur::execute::bytes2_xor_value(__v_268, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_265), (&__v_289)) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __v_299: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_266), (&__v_290)) } else { aiur::execute::bytes2_xor_value(__v_266, __v_290, record) }; let __u32_sum: u128 = (u128::from(((((__v_269.as_canonical_u64() << 0) | (__v_270.as_canonical_u64() << 8)) | (__v_271.as_canonical_u64() << 16)) | (__v_272.as_canonical_u64() << 24))) + u128::from(((((__v_297.as_canonical_u64() << 0) | (__v_298.as_canonical_u64() << 8)) | (__v_299.as_canonical_u64() << 16)) | (__v_296.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_300: G = G::from_u8(__u32_bytes[0]); let __v_301: G = G::from_u8(__u32_bytes[1]); let __v_302: G = G::from_u8(__u32_bytes[2]); let __v_303: G = G::from_u8(__u32_bytes[3]); let __v_304: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_300; let __vj = __v_301; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_302; let __vj = __v_303; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_305: G = (__v_304 * __v_304); if (__v_305 != __v_304) { return Err(ExecError::AssertEqMismatch { lhs: __v_305.as_canonical_u64(), rhs: __v_304.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_283), (&__v_300)) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_306: G = __b2_out.0; let __v_307: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_284), (&__v_301)) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_308: G = __b2_out.0; let __v_309: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_285), (&__v_302)) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_310: G = __b2_out.0; let __v_311: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_286), (&__v_303)) } else { aiur::execute::bytes2_xor_split7_value(__v_286, __v_303, record) }; let __v_312: G = __b2_out.0; let __v_313: G = __b2_out.1; let __v_314: G = (__v_306 + __v_309); let __v_315: G = (__v_308 + __v_311); let __v_316: G = (__v_310 + __v_313); let __v_317: G = (__v_312 + __v_307); let __u32_sum: u128 = ((u128::from(((((__v_13.as_canonical_u64() << 0) | (__v_14.as_canonical_u64() << 8)) | (__v_15.as_canonical_u64() << 16)) | (__v_16.as_canonical_u64() << 24))) + u128::from(((((__v_29.as_canonical_u64() << 0) | (__v_30.as_canonical_u64() << 8)) | (__v_31.as_canonical_u64() << 16)) | (__v_32.as_canonical_u64() << 24)))) + u128::from(((((__v_89.as_canonical_u64() << 0) | (__v_90.as_canonical_u64() << 8)) | (__v_91.as_canonical_u64() << 16)) | (__v_92.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_318: G = G::from_u8(__u32_bytes[0]); let __v_319: G = G::from_u8(__u32_bytes[1]); let __v_320: G = G::from_u8(__u32_bytes[2]); let __v_321: G = G::from_u8(__u32_bytes[3]); let __v_322: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_318; let __vj = __v_319; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_320; let __vj = __v_321; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_323: G = (__v_322 - __v_134); let __v_324: G = (__v_322 - __v_136); let __v_325: G = (__v_323 * __v_324); let __v_326: G = (__v_322 * __v_325); if (__v_326 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_326.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_61), (&__v_318)) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_62), (&__v_319)) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_63), (&__v_320)) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __v_330: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_64), (&__v_321)) } else { aiur::execute::bytes2_xor_value(__v_64, __v_321, record) }; let __u32_sum: u128 = (u128::from(((((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8)) | (__v_47.as_canonical_u64() << 16)) | (__v_48.as_canonical_u64() << 24))) + u128::from(((((__v_329.as_canonical_u64() << 0) | (__v_330.as_canonical_u64() << 8)) | (__v_327.as_canonical_u64() << 16)) | (__v_328.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_331: G = G::from_u8(__u32_bytes[0]); let __v_332: G = G::from_u8(__u32_bytes[1]); let __v_333: G = G::from_u8(__u32_bytes[2]); let __v_334: G = G::from_u8(__u32_bytes[3]); let __v_335: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_331; let __vj = __v_332; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_333; let __vj = __v_334; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_336: G = (__v_335 * __v_335); if (__v_336 != __v_335) { return Err(ExecError::AssertEqMismatch { lhs: __v_336.as_canonical_u64(), rhs: __v_335.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_29), (&__v_331)) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_337: G = __b2_out.0; let __v_338: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_30), (&__v_332)) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_339: G = __b2_out.0; let __v_340: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_31), (&__v_333)) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_341: G = __b2_out.0; let __v_342: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_32), (&__v_334)) } else { aiur::execute::bytes2_xor_split4_value(__v_32, __v_334, record) }; let __v_343: G = __b2_out.0; let __v_344: G = __b2_out.1; let __v_345: G = (__v_339 + __v_342); let __v_346: G = (__v_341 + __v_344); let __v_347: G = (__v_343 + __v_338); let __v_348: G = (__v_337 + __v_340); let __u32_sum: u128 = ((u128::from(((((__v_318.as_canonical_u64() << 0) | (__v_319.as_canonical_u64() << 8)) | (__v_320.as_canonical_u64() << 16)) | (__v_321.as_canonical_u64() << 24))) + u128::from(((((__v_345.as_canonical_u64() << 0) | (__v_346.as_canonical_u64() << 8)) | (__v_347.as_canonical_u64() << 16)) | (__v_348.as_canonical_u64() << 24)))) + u128::from(((((__v_93.as_canonical_u64() << 0) | (__v_94.as_canonical_u64() << 8)) | (__v_95.as_canonical_u64() << 16)) | (__v_96.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_349: G = G::from_u8(__u32_bytes[0]); let __v_350: G = G::from_u8(__u32_bytes[1]); let __v_351: G = G::from_u8(__u32_bytes[2]); let __v_352: G = G::from_u8(__u32_bytes[3]); let __v_353: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_349; let __vj = __v_350; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_351; let __vj = __v_352; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_354: G = (__v_353 - __v_134); let __v_355: G = (__v_353 - __v_136); let __v_356: G = (__v_354 * __v_355); let __v_357: G = (__v_353 * __v_356); if (__v_357 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_329), (&__v_349)) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_330), (&__v_350)) } else { aiur::execute::bytes2_xor_value(__v_330, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_327), (&__v_351)) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __v_361: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_328), (&__v_352)) } else { aiur::execute::bytes2_xor_value(__v_328, __v_352, record) }; let __u32_sum: u128 = (u128::from(((((__v_331.as_canonical_u64() << 0) | (__v_332.as_canonical_u64() << 8)) | (__v_333.as_canonical_u64() << 16)) | (__v_334.as_canonical_u64() << 24))) + u128::from(((((__v_359.as_canonical_u64() << 0) | (__v_360.as_canonical_u64() << 8)) | (__v_361.as_canonical_u64() << 16)) | (__v_358.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_362: G = G::from_u8(__u32_bytes[0]); let __v_363: G = G::from_u8(__u32_bytes[1]); let __v_364: G = G::from_u8(__u32_bytes[2]); let __v_365: G = G::from_u8(__u32_bytes[3]); let __v_366: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_362; let __vj = __v_363; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_364; let __vj = __v_365; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_367: G = (__v_366 * __v_366); if (__v_367 != __v_366) { return Err(ExecError::AssertEqMismatch { lhs: __v_367.as_canonical_u64(), rhs: __v_366.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_345), (&__v_362)) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_368: G = __b2_out.0; let __v_369: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_346), (&__v_363)) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_370: G = __b2_out.0; let __v_371: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_347), (&__v_364)) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_372: G = __b2_out.0; let __v_373: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_348), (&__v_365)) } else { aiur::execute::bytes2_xor_split7_value(__v_348, __v_365, record) }; let __v_374: G = __b2_out.0; let __v_375: G = __b2_out.1; let __v_376: G = (__v_368 + __v_371); let __v_377: G = (__v_370 + __v_373); let __v_378: G = (__v_372 + __v_375); let __v_379: G = (__v_374 + __v_369); let __u32_sum: u128 = ((u128::from(((((__v_163.as_canonical_u64() << 0) | (__v_164.as_canonical_u64() << 8)) | (__v_165.as_canonical_u64() << 16)) | (__v_166.as_canonical_u64() << 24))) + u128::from(((((__v_252.as_canonical_u64() << 0) | (__v_253.as_canonical_u64() << 8)) | (__v_254.as_canonical_u64() << 16)) | (__v_255.as_canonical_u64() << 24)))) + u128::from(((((__v_97.as_canonical_u64() << 0) | (__v_98.as_canonical_u64() << 8)) | (__v_99.as_canonical_u64() << 16)) | (__v_100.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_380: G = G::from_u8(__u32_bytes[0]); let __v_381: G = G::from_u8(__u32_bytes[1]); let __v_382: G = G::from_u8(__u32_bytes[2]); let __v_383: G = G::from_u8(__u32_bytes[3]); let __v_384: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_380; let __vj = __v_381; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_382; let __vj = __v_383; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_385: G = (__v_384 - __v_134); let __v_386: G = (__v_384 - __v_136); let __v_387: G = (__v_385 * __v_386); let __v_388: G = (__v_384 * __v_387); if (__v_388 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_359), (&__v_380)) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_360), (&__v_381)) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_361), (&__v_382)) } else { aiur::execute::bytes2_xor_value(__v_361, __v_382, record) }; let __v_392: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_358), (&__v_383)) } else { aiur::execute::bytes2_xor_value(__v_358, __v_383, record) }; let __u32_sum: u128 = (u128::from(((((__v_300.as_canonical_u64() << 0) | (__v_301.as_canonical_u64() << 8)) | (__v_302.as_canonical_u64() << 16)) | (__v_303.as_canonical_u64() << 24))) + u128::from(((((__v_391.as_canonical_u64() << 0) | (__v_392.as_canonical_u64() << 8)) | (__v_389.as_canonical_u64() << 16)) | (__v_390.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_393: G = G::from_u8(__u32_bytes[0]); let __v_394: G = G::from_u8(__u32_bytes[1]); let __v_395: G = G::from_u8(__u32_bytes[2]); let __v_396: G = G::from_u8(__u32_bytes[3]); let __v_397: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_393; let __vj = __v_394; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_395; let __vj = __v_396; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_398: G = (__v_397 * __v_397); if (__v_398 != __v_397) { return Err(ExecError::AssertEqMismatch { lhs: __v_398.as_canonical_u64(), rhs: __v_397.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_252), (&__v_393)) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_399: G = __b2_out.0; let __v_400: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_253), (&__v_394)) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_401: G = __b2_out.0; let __v_402: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_254), (&__v_395)) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_403: G = __b2_out.0; let __v_404: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_255), (&__v_396)) } else { aiur::execute::bytes2_xor_split4_value(__v_255, __v_396, record) }; let __v_405: G = __b2_out.0; let __v_406: G = __b2_out.1; let __v_407: G = (__v_401 + __v_404); let __v_408: G = (__v_403 + __v_406); let __v_409: G = (__v_405 + __v_400); let __v_410: G = (__v_399 + __v_402); let __u32_sum: u128 = ((u128::from(((((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8)) | (__v_382.as_canonical_u64() << 16)) | (__v_383.as_canonical_u64() << 24))) + u128::from(((((__v_407.as_canonical_u64() << 0) | (__v_408.as_canonical_u64() << 8)) | (__v_409.as_canonical_u64() << 16)) | (__v_410.as_canonical_u64() << 24)))) + u128::from(((((__v_101.as_canonical_u64() << 0) | (__v_102.as_canonical_u64() << 8)) | (__v_103.as_canonical_u64() << 16)) | (__v_104.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_411: G = G::from_u8(__u32_bytes[0]); let __v_412: G = G::from_u8(__u32_bytes[1]); let __v_413: G = G::from_u8(__u32_bytes[2]); let __v_414: G = G::from_u8(__u32_bytes[3]); let __v_415: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_411; let __vj = __v_412; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_413; let __vj = __v_414; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_416: G = (__v_415 - __v_134); let __v_417: G = (__v_415 - __v_136); let __v_418: G = (__v_416 * __v_417); let __v_419: G = (__v_415 * __v_418); if (__v_419 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_419.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_391), (&__v_411)) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_392), (&__v_412)) } else { aiur::execute::bytes2_xor_value(__v_392, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_389), (&__v_413)) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __v_423: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_390), (&__v_414)) } else { aiur::execute::bytes2_xor_value(__v_390, __v_414, record) }; let __u32_sum: u128 = (u128::from(((((__v_393.as_canonical_u64() << 0) | (__v_394.as_canonical_u64() << 8)) | (__v_395.as_canonical_u64() << 16)) | (__v_396.as_canonical_u64() << 24))) + u128::from(((((__v_421.as_canonical_u64() << 0) | (__v_422.as_canonical_u64() << 8)) | (__v_423.as_canonical_u64() << 16)) | (__v_420.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_424: G = G::from_u8(__u32_bytes[0]); let __v_425: G = G::from_u8(__u32_bytes[1]); let __v_426: G = G::from_u8(__u32_bytes[2]); let __v_427: G = G::from_u8(__u32_bytes[3]); let __v_428: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_424; let __vj = __v_425; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_426; let __vj = __v_427; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_429: G = (__v_428 * __v_428); if (__v_429 != __v_428) { return Err(ExecError::AssertEqMismatch { lhs: __v_429.as_canonical_u64(), rhs: __v_428.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_407), (&__v_424)) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_430: G = __b2_out.0; let __v_431: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_408), (&__v_425)) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_432: G = __b2_out.0; let __v_433: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_409), (&__v_426)) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_434: G = __b2_out.0; let __v_435: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_410), (&__v_427)) } else { aiur::execute::bytes2_xor_split7_value(__v_410, __v_427, record) }; let __v_436: G = __b2_out.0; let __v_437: G = __b2_out.1; let __v_438: G = (__v_430 + __v_433); let __v_439: G = (__v_432 + __v_435); let __v_440: G = (__v_434 + __v_437); let __v_441: G = (__v_436 + __v_431); let __u32_sum: u128 = ((u128::from(((((__v_225.as_canonical_u64() << 0) | (__v_226.as_canonical_u64() << 8)) | (__v_227.as_canonical_u64() << 16)) | (__v_228.as_canonical_u64() << 24))) + u128::from(((((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8)) | (__v_316.as_canonical_u64() << 16)) | (__v_317.as_canonical_u64() << 24)))) + u128::from(((((__v_105.as_canonical_u64() << 0) | (__v_106.as_canonical_u64() << 8)) | (__v_107.as_canonical_u64() << 16)) | (__v_108.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_442: G = G::from_u8(__u32_bytes[0]); let __v_443: G = G::from_u8(__u32_bytes[1]); let __v_444: G = G::from_u8(__u32_bytes[2]); let __v_445: G = G::from_u8(__u32_bytes[3]); let __v_446: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_442; let __vj = __v_443; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_444; let __vj = __v_445; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_447: G = (__v_446 - __v_134); let __v_448: G = (__v_446 - __v_136); let __v_449: G = (__v_447 * __v_448); let __v_450: G = (__v_446 * __v_449); if (__v_450 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_450.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_173), (&__v_442)) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_174), (&__v_443)) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_175), (&__v_444)) } else { aiur::execute::bytes2_xor_value(__v_175, __v_444, record) }; let __v_454: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_172), (&__v_445)) } else { aiur::execute::bytes2_xor_value(__v_172, __v_445, record) }; let __u32_sum: u128 = (u128::from(((((__v_362.as_canonical_u64() << 0) | (__v_363.as_canonical_u64() << 8)) | (__v_364.as_canonical_u64() << 16)) | (__v_365.as_canonical_u64() << 24))) + u128::from(((((__v_453.as_canonical_u64() << 0) | (__v_454.as_canonical_u64() << 8)) | (__v_451.as_canonical_u64() << 16)) | (__v_452.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_455: G = G::from_u8(__u32_bytes[0]); let __v_456: G = G::from_u8(__u32_bytes[1]); let __v_457: G = G::from_u8(__u32_bytes[2]); let __v_458: G = G::from_u8(__u32_bytes[3]); let __v_459: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_455; let __vj = __v_456; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_457; let __vj = __v_458; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_460: G = (__v_459 * __v_459); if (__v_460 != __v_459) { return Err(ExecError::AssertEqMismatch { lhs: __v_460.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_314), (&__v_455)) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_461: G = __b2_out.0; let __v_462: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_315), (&__v_456)) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_463: G = __b2_out.0; let __v_464: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_316), (&__v_457)) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_465: G = __b2_out.0; let __v_466: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_317), (&__v_458)) } else { aiur::execute::bytes2_xor_split4_value(__v_317, __v_458, record) }; let __v_467: G = __b2_out.0; let __v_468: G = __b2_out.1; let __v_469: G = (__v_463 + __v_466); let __v_470: G = (__v_465 + __v_468); let __v_471: G = (__v_467 + __v_462); let __v_472: G = (__v_461 + __v_464); let __u32_sum: u128 = ((u128::from(((((__v_442.as_canonical_u64() << 0) | (__v_443.as_canonical_u64() << 8)) | (__v_444.as_canonical_u64() << 16)) | (__v_445.as_canonical_u64() << 24))) + u128::from(((((__v_469.as_canonical_u64() << 0) | (__v_470.as_canonical_u64() << 8)) | (__v_471.as_canonical_u64() << 16)) | (__v_472.as_canonical_u64() << 24)))) + u128::from(((((__v_109.as_canonical_u64() << 0) | (__v_110.as_canonical_u64() << 8)) | (__v_111.as_canonical_u64() << 16)) | (__v_112.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_473: G = G::from_u8(__u32_bytes[0]); let __v_474: G = G::from_u8(__u32_bytes[1]); let __v_475: G = G::from_u8(__u32_bytes[2]); let __v_476: G = G::from_u8(__u32_bytes[3]); let __v_477: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_473; let __vj = __v_474; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_475; let __vj = __v_476; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_478: G = (__v_477 - __v_134); let __v_479: G = (__v_477 - __v_136); let __v_480: G = (__v_478 * __v_479); let __v_481: G = (__v_477 * __v_480); if (__v_481 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_481.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_453), (&__v_473)) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_454), (&__v_474)) } else { aiur::execute::bytes2_xor_value(__v_454, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_451), (&__v_475)) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __v_485: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_452), (&__v_476)) } else { aiur::execute::bytes2_xor_value(__v_452, __v_476, record) }; let __u32_sum: u128 = (u128::from(((((__v_455.as_canonical_u64() << 0) | (__v_456.as_canonical_u64() << 8)) | (__v_457.as_canonical_u64() << 16)) | (__v_458.as_canonical_u64() << 24))) + u128::from(((((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8)) | (__v_485.as_canonical_u64() << 16)) | (__v_482.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_486: G = G::from_u8(__u32_bytes[0]); let __v_487: G = G::from_u8(__u32_bytes[1]); let __v_488: G = G::from_u8(__u32_bytes[2]); let __v_489: G = G::from_u8(__u32_bytes[3]); let __v_490: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_486; let __vj = __v_487; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_488; let __vj = __v_489; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_491: G = (__v_490 * __v_490); if (__v_491 != __v_490) { return Err(ExecError::AssertEqMismatch { lhs: __v_491.as_canonical_u64(), rhs: __v_490.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_469), (&__v_486)) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_492: G = __b2_out.0; let __v_493: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_470), (&__v_487)) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_494: G = __b2_out.0; let __v_495: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_471), (&__v_488)) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_496: G = __b2_out.0; let __v_497: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_472), (&__v_489)) } else { aiur::execute::bytes2_xor_split7_value(__v_472, __v_489, record) }; let __v_498: G = __b2_out.0; let __v_499: G = __b2_out.1; let __v_500: G = (__v_492 + __v_495); let __v_501: G = (__v_494 + __v_497); let __v_502: G = (__v_496 + __v_499); let __v_503: G = (__v_498 + __v_493); let __u32_sum: u128 = ((u128::from(((((__v_287.as_canonical_u64() << 0) | (__v_288.as_canonical_u64() << 8)) | (__v_289.as_canonical_u64() << 16)) | (__v_290.as_canonical_u64() << 24))) + u128::from(((((__v_376.as_canonical_u64() << 0) | (__v_377.as_canonical_u64() << 8)) | (__v_378.as_canonical_u64() << 16)) | (__v_379.as_canonical_u64() << 24)))) + u128::from(((((__v_113.as_canonical_u64() << 0) | (__v_114.as_canonical_u64() << 8)) | (__v_115.as_canonical_u64() << 16)) | (__v_116.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_504: G = G::from_u8(__u32_bytes[0]); let __v_505: G = G::from_u8(__u32_bytes[1]); let __v_506: G = G::from_u8(__u32_bytes[2]); let __v_507: G = G::from_u8(__u32_bytes[3]); let __v_508: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_504; let __vj = __v_505; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_506; let __vj = __v_507; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_509: G = (__v_508 - __v_134); let __v_510: G = (__v_508 - __v_136); let __v_511: G = (__v_509 * __v_510); let __v_512: G = (__v_508 * __v_511); if (__v_512 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_235), (&__v_504)) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_236), (&__v_505)) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_237), (&__v_506)) } else { aiur::execute::bytes2_xor_value(__v_237, __v_506, record) }; let __v_516: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_234), (&__v_507)) } else { aiur::execute::bytes2_xor_value(__v_234, __v_507, record) }; let __u32_sum: u128 = (u128::from(((((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8)) | (__v_178.as_canonical_u64() << 16)) | (__v_179.as_canonical_u64() << 24))) + u128::from(((((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8)) | (__v_513.as_canonical_u64() << 16)) | (__v_514.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_517: G = G::from_u8(__u32_bytes[0]); let __v_518: G = G::from_u8(__u32_bytes[1]); let __v_519: G = G::from_u8(__u32_bytes[2]); let __v_520: G = G::from_u8(__u32_bytes[3]); let __v_521: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_517; let __vj = __v_518; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_519; let __vj = __v_520; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_522: G = (__v_521 * __v_521); if (__v_522 != __v_521) { return Err(ExecError::AssertEqMismatch { lhs: __v_522.as_canonical_u64(), rhs: __v_521.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_376), (&__v_517)) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_523: G = __b2_out.0; let __v_524: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_377), (&__v_518)) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_525: G = __b2_out.0; let __v_526: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_378), (&__v_519)) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_527: G = __b2_out.0; let __v_528: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_379), (&__v_520)) } else { aiur::execute::bytes2_xor_split4_value(__v_379, __v_520, record) }; let __v_529: G = __b2_out.0; let __v_530: G = __b2_out.1; let __v_531: G = (__v_525 + __v_528); let __v_532: G = (__v_527 + __v_530); let __v_533: G = (__v_529 + __v_524); let __v_534: G = (__v_523 + __v_526); let __u32_sum: u128 = ((u128::from(((((__v_504.as_canonical_u64() << 0) | (__v_505.as_canonical_u64() << 8)) | (__v_506.as_canonical_u64() << 16)) | (__v_507.as_canonical_u64() << 24))) + u128::from(((((__v_531.as_canonical_u64() << 0) | (__v_532.as_canonical_u64() << 8)) | (__v_533.as_canonical_u64() << 16)) | (__v_534.as_canonical_u64() << 24)))) + u128::from(((((__v_117.as_canonical_u64() << 0) | (__v_118.as_canonical_u64() << 8)) | (__v_119.as_canonical_u64() << 16)) | (__v_120.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_535: G = G::from_u8(__u32_bytes[0]); let __v_536: G = G::from_u8(__u32_bytes[1]); let __v_537: G = G::from_u8(__u32_bytes[2]); let __v_538: G = G::from_u8(__u32_bytes[3]); let __v_539: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_535; let __vj = __v_536; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_537; let __vj = __v_538; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_540: G = (__v_539 - __v_134); let __v_541: G = (__v_539 - __v_136); let __v_542: G = (__v_540 * __v_541); let __v_543: G = (__v_539 * __v_542); if (__v_543 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_515), (&__v_535)) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_516), (&__v_536)) } else { aiur::execute::bytes2_xor_value(__v_516, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_513), (&__v_537)) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __v_547: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_514), (&__v_538)) } else { aiur::execute::bytes2_xor_value(__v_514, __v_538, record) }; let __u32_sum: u128 = (u128::from(((((__v_517.as_canonical_u64() << 0) | (__v_518.as_canonical_u64() << 8)) | (__v_519.as_canonical_u64() << 16)) | (__v_520.as_canonical_u64() << 24))) + u128::from(((((__v_545.as_canonical_u64() << 0) | (__v_546.as_canonical_u64() << 8)) | (__v_547.as_canonical_u64() << 16)) | (__v_544.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_548: G = G::from_u8(__u32_bytes[0]); let __v_549: G = G::from_u8(__u32_bytes[1]); let __v_550: G = G::from_u8(__u32_bytes[2]); let __v_551: G = G::from_u8(__u32_bytes[3]); let __v_552: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_548; let __vj = __v_549; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_550; let __vj = __v_551; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_553: G = (__v_552 * __v_552); if (__v_553 != __v_552) { return Err(ExecError::AssertEqMismatch { lhs: __v_553.as_canonical_u64(), rhs: __v_552.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_531), (&__v_548)) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_554: G = __b2_out.0; let __v_555: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_532), (&__v_549)) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_556: G = __b2_out.0; let __v_557: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_533), (&__v_550)) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_558: G = __b2_out.0; let __v_559: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_534), (&__v_551)) } else { aiur::execute::bytes2_xor_split7_value(__v_534, __v_551, record) }; let __v_560: G = __b2_out.0; let __v_561: G = __b2_out.1; let __v_562: G = (__v_554 + __v_557); let __v_563: G = (__v_556 + __v_559); let __v_564: G = (__v_558 + __v_561); let __v_565: G = (__v_560 + __v_555); let __u32_sum: u128 = ((u128::from(((((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8)) | (__v_351.as_canonical_u64() << 16)) | (__v_352.as_canonical_u64() << 24))) + u128::from(((((__v_190.as_canonical_u64() << 0) | (__v_191.as_canonical_u64() << 8)) | (__v_192.as_canonical_u64() << 16)) | (__v_193.as_canonical_u64() << 24)))) + u128::from(((((__v_121.as_canonical_u64() << 0) | (__v_122.as_canonical_u64() << 8)) | (__v_123.as_canonical_u64() << 16)) | (__v_124.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_566: G = G::from_u8(__u32_bytes[0]); let __v_567: G = G::from_u8(__u32_bytes[1]); let __v_568: G = G::from_u8(__u32_bytes[2]); let __v_569: G = G::from_u8(__u32_bytes[3]); let __v_570: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_566; let __vj = __v_567; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_568; let __vj = __v_569; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_571: G = (__v_570 - __v_134); let __v_572: G = (__v_570 - __v_136); let __v_573: G = (__v_571 * __v_572); let __v_574: G = (__v_570 * __v_573); if (__v_574 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_574.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_297), (&__v_566)) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_298), (&__v_567)) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_299), (&__v_568)) } else { aiur::execute::bytes2_xor_value(__v_299, __v_568, record) }; let __v_578: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_296), (&__v_569)) } else { aiur::execute::bytes2_xor_value(__v_296, __v_569, record) }; let __u32_sum: u128 = (u128::from(((((__v_238.as_canonical_u64() << 0) | (__v_239.as_canonical_u64() << 8)) | (__v_240.as_canonical_u64() << 16)) | (__v_241.as_canonical_u64() << 24))) + u128::from(((((__v_577.as_canonical_u64() << 0) | (__v_578.as_canonical_u64() << 8)) | (__v_575.as_canonical_u64() << 16)) | (__v_576.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_579: G = G::from_u8(__u32_bytes[0]); let __v_580: G = G::from_u8(__u32_bytes[1]); let __v_581: G = G::from_u8(__u32_bytes[2]); let __v_582: G = G::from_u8(__u32_bytes[3]); let __v_583: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_579; let __vj = __v_580; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_581; let __vj = __v_582; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_584: G = (__v_583 * __v_583); if (__v_584 != __v_583) { return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_583.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_190), (&__v_579)) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_585: G = __b2_out.0; let __v_586: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_191), (&__v_580)) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_587: G = __b2_out.0; let __v_588: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_192), (&__v_581)) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_589: G = __b2_out.0; let __v_590: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_193), (&__v_582)) } else { aiur::execute::bytes2_xor_split4_value(__v_193, __v_582, record) }; let __v_591: G = __b2_out.0; let __v_592: G = __b2_out.1; let __v_593: G = (__v_587 + __v_590); let __v_594: G = (__v_589 + __v_592); let __v_595: G = (__v_591 + __v_586); let __v_596: G = (__v_585 + __v_588); let __u32_sum: u128 = ((u128::from(((((__v_566.as_canonical_u64() << 0) | (__v_567.as_canonical_u64() << 8)) | (__v_568.as_canonical_u64() << 16)) | (__v_569.as_canonical_u64() << 24))) + u128::from(((((__v_593.as_canonical_u64() << 0) | (__v_594.as_canonical_u64() << 8)) | (__v_595.as_canonical_u64() << 16)) | (__v_596.as_canonical_u64() << 24)))) + u128::from(((((__v_125.as_canonical_u64() << 0) | (__v_126.as_canonical_u64() << 8)) | (__v_127.as_canonical_u64() << 16)) | (__v_128.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_597: G = G::from_u8(__u32_bytes[0]); let __v_598: G = G::from_u8(__u32_bytes[1]); let __v_599: G = G::from_u8(__u32_bytes[2]); let __v_600: G = G::from_u8(__u32_bytes[3]); let __v_601: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_597; let __vj = __v_598; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_599; let __vj = __v_600; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_602: G = (__v_601 - __v_134); let __v_603: G = (__v_601 - __v_136); let __v_604: G = (__v_602 * __v_603); let __v_605: G = (__v_601 * __v_604); if (__v_605 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_605.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_577), (&__v_597)) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_578), (&__v_598)) } else { aiur::execute::bytes2_xor_value(__v_578, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_575), (&__v_599)) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __v_609: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_576), (&__v_600)) } else { aiur::execute::bytes2_xor_value(__v_576, __v_600, record) }; let __u32_sum: u128 = (u128::from(((((__v_579.as_canonical_u64() << 0) | (__v_580.as_canonical_u64() << 8)) | (__v_581.as_canonical_u64() << 16)) | (__v_582.as_canonical_u64() << 24))) + u128::from(((((__v_607.as_canonical_u64() << 0) | (__v_608.as_canonical_u64() << 8)) | (__v_609.as_canonical_u64() << 16)) | (__v_606.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_610: G = G::from_u8(__u32_bytes[0]); let __v_611: G = G::from_u8(__u32_bytes[1]); let __v_612: G = G::from_u8(__u32_bytes[2]); let __v_613: G = G::from_u8(__u32_bytes[3]); let __v_614: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_610; let __vj = __v_611; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_612; let __vj = __v_613; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_615: G = (__v_614 * __v_614); if (__v_615 != __v_614) { return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_614.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_593), (&__v_610)) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_616: G = __b2_out.0; let __v_617: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_594), (&__v_611)) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_618: G = __b2_out.0; let __v_619: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_595), (&__v_612)) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_620: G = __b2_out.0; let __v_621: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_596), (&__v_613)) } else { aiur::execute::bytes2_xor_split7_value(__v_596, __v_613, record) }; let __v_622: G = __b2_out.0; let __v_623: G = __b2_out.1; let __v_624: G = (__v_616 + __v_619); let __v_625: G = (__v_618 + __v_621); let __v_626: G = (__v_620 + __v_623); let __v_627: G = (__v_622 + __v_617); let __v_628: G = (__v_0 + __v_134); let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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(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_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_34] = [__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[34].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_35: usize = 19; +const IN_35: usize = 19; +const OUT_35: usize = 1; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if ((!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_20: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_20]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if ((!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_20: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_20]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_9]; 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_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_42] = { let __args: [G; IN_42] = [__v_9, __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_28: G = __r_arr[0]; 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_8, __v_28]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if ((!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_30: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_30]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_9]; 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_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_42] = { let __args: [G; IN_42] = [__v_9, __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_28: G = __r_arr[0]; 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_8, __v_28]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if ((!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_30: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_30]; record.function_queries[35].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_35] = { let __args: [G; IN_35] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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(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_38: G = __r_arr[0]; 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_8, __v_38]; 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_39: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if ((!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_40: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_40]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_19: G = G::from_u64(5); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if ((!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_20: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_20]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_19: G = G::from_u64(6); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if ((!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_20: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_20]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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_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_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, __v_18]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if ((!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_29: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_29]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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(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_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_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, __v_18]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if ((!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_29: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_29]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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(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_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_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, __v_18]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if ((!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_29: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_29]; record.function_queries[35].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_35] = { let __args: [G; IN_35] = [__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(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_79: G = __r_arr[0]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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(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_80: G = __r_arr[0]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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(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_81: G = __r_arr[0]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_4, __v_5, __v_81]; 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_82: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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(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_83: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_83]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 11u64 => { let __v_19: G = G::from_u64(11); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if ((!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_20: G = __r_arr[0]; let __ret: [G; OUT_35] = [__v_20]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_36: usize = 10; +const IN_36: usize = 10; const OUT_36: usize = 1; -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]; 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_36] = [__v_20]; record.function_queries[36].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_36] = [__v_20]; record.function_queries[36].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_9]; 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_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_41] = { let __args: [G; IN_41] = [__v_9, __v_18]; 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_28: G = __r_arr[0]; 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_28]; 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_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_36] = [__v_30]; record.function_queries[36].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_9]; 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_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_41] = { let __args: [G; IN_41] = [__v_9, __v_18]; 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_28: G = __r_arr[0]; 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_28]; 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_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_36] = [__v_30]; record.function_queries[36].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_36] = { let __args: [G; IN_36] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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(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_38: G = __r_arr[0]; 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_38]; 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_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_36] = [__v_40]; record.function_queries[36].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_36] = [__v_20]; record.function_queries[36].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_36] = [__v_20]; record.function_queries[36].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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_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_49] = { let __args: [G; IN_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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(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_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_36] = [__v_29]; record.function_queries[36].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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_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_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, __v_18]; 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_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_36] = [__v_29]; record.function_queries[36].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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(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_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_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, __v_18]; 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_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_36] = [__v_29]; record.function_queries[36].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_36] = { let __args: [G; IN_36] = [__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(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_79: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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(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_80: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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(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_81: G = __r_arr[0]; let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_4, __v_5, __v_81]; 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_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_36] = [__v_83]; record.function_queries[36].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_36] = [__v_20]; record.function_queries[36].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +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]; match __v_8.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_36] = [__v_9]; record.function_queries[36].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_36] = { let __args: [G; IN_36] = [__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(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_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_36] = [__v_14]; record.function_queries[36].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_37: usize = 10; const IN_37: usize = 10; const OUT_37: usize = 1; -fn aiur_fn_37(inp: [G; IN_37], 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]; match __v_8.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_37] = [__v_9]; record.function_queries[37].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_37] = { let __args: [G; IN_37] = [__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(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 = { 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_37] = [__v_14]; record.function_queries[37].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_38: usize = 9; -const IN_38: usize = 9; +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 = (__v_7 + __v_8); let __v_11: G = (__v_6 + __v_10); let __v_12: G = (__v_5 + __v_11); let __v_13: G = (__v_4 + __v_12); let __v_14: G = (__v_3 + __v_13); let __v_15: G = (__v_2 + __v_14); 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_37] = [__v_22]; record.function_queries[37].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_40] = { let __args: [G; IN_40] = [__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(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_21: G = __r_arr[0]; let __ret: [G; OUT_37] = [__v_21]; record.function_queries[37].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_40] = { let __args: [G; IN_40] = [__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(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_19: G = __r_arr[0]; let __ret: [G; OUT_37] = [__v_19]; record.function_queries[37].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_38: usize = 10; +const IN_38: usize = 10; 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 __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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]; let __v_10: G = G::from_u64(128); let __v_11: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_0), (&__v_10)) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_10, record) }; match __v_9.as_canonical_u64() { 1u64 => { match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_38] = [__v_13]; record.function_queries[38].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(128); let __v_13: G = G::from_u64(1); let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; 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_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_38] = [__v_18]; record.function_queries[38].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(128); let __v_13: G = G::from_u64(1); let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; 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_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_38] = [__v_18]; record.function_queries[38].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_39: usize = 10; -const IN_39: usize = 10; +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 = (__v_7 + __v_8); let __v_11: G = (__v_6 + __v_10); let __v_12: G = (__v_5 + __v_11); let __v_13: G = (__v_4 + __v_12); let __v_14: G = (__v_3 + __v_13); let __v_15: G = (__v_2 + __v_14); 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_38] = [__v_22]; record.function_queries[38].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_40] = { let __args: [G; IN_40] = [__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(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_21: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_21]; record.function_queries[38].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_40] = { let __args: [G; IN_40] = [__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(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_19: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_19]; record.function_queries[38].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_39: usize = 9; +const IN_39: usize = 9; 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]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(32); let __v_12: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_1), (&__v_11)) } else { aiur::execute::bytes2_less_than_value(__v_1, __v_11, record) }; match __v_10.as_canonical_u64() { 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(64); let __v_14: G = (__v_0 * __v_13); let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __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_17]; record.function_queries[39].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(64); let __v_14: G = (__v_0 * __v_13); let __v_15: G = G::from_u64(32); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_10 - __v_16); let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; 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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __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_22]; record.function_queries[39].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(64); let __v_14: G = (__v_0 * __v_13); let __v_15: G = G::from_u64(32); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_10 - __v_16); let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; 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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __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_22]; 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; +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 = (__v_6 + __v_7); let __v_10: G = (__v_5 + __v_9); let __v_11: G = (__v_4 + __v_10); let __v_12: G = (__v_3 + __v_11); let __v_13: G = (__v_2 + __v_12); let __v_14: G = (__v_1 + __v_13); 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_39] = [__v_18]; record.function_queries[39].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_40] = { let __args: [G; IN_40] = [__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(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_19: G = __r_arr[0]; let __ret: [G; OUT_39] = [__v_19]; record.function_queries[39].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_40] = { let __args: [G; IN_40] = [__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(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_17: G = __r_arr[0]; let __ret: [G; OUT_39] = [__v_17]; record.function_queries[39].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_40: usize = 11; +const IN_40: usize = 11; 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 __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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); let __v_12: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_1), (&__v_11)) } else { aiur::execute::bytes2_less_than_value(__v_1, __v_11, record) }; match __v_10.as_canonical_u64() { 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(16); let __v_14: G = (__v_0 * __v_13); let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __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_17]; record.function_queries[40].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(16); let __v_14: G = (__v_0 * __v_13); let __v_15: G = G::from_u64(8); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_10 - __v_16); let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; 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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __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); }, } }, _ => { let __v_13: G = G::from_u64(16); let __v_14: G = (__v_0 * __v_13); let __v_15: G = G::from_u64(8); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_10 - __v_16); let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; 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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __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); }, } }) } -const INPUT_SIZE_41: usize = 2; -const IN_41: 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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = 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 = G::from_u64(1); let __v_33: G = (__v_31 - __v_32); let __v_34: G = (__v_3 + __v_33); let __v_35: G = G::from_u64(0); let __v_36: G = (__v_28 + __v_34); let __v_37: G = (__v_0 + __v_36); 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_40] = [__v_39]; record.function_queries[40].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_41] = { let __args: [G; IN_41] = [__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(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_30: G = __r_arr[0]; let __ret: [G; OUT_40] = [__v_30]; record.function_queries[40].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } +const INPUT_SIZE_41: usize = 11; +const IN_41: usize = 11; 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 __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_41] = [__v_1]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_11, __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_12: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_13: G = __r_arr[0]; let __ret: [G; OUT_41] = [__v_13]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 = inp[10]; match __v_1.as_canonical_u64() { 0u64 => { let __v_11: G = (__v_8 + __v_9); let __v_12: G = (__v_7 + __v_11); let __v_13: G = (__v_6 + __v_12); let __v_14: G = (__v_5 + __v_13); let __v_15: G = (__v_4 + __v_14); 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_36] = { let __args: [G; IN_36] = [__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(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_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_41] = [__v_19]; record.function_queries[41].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_41] = { let __args: [G; IN_41] = [__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(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_28: G = __r_arr[0]; let __ret: [G; OUT_41] = [__v_28]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 1u64 => { let __v_11: G = (__v_8 + __v_9); let __v_12: G = (__v_7 + __v_11); let __v_13: G = (__v_6 + __v_12); let __v_14: G = (__v_5 + __v_13); 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_36] = { let __args: [G; IN_36] = [__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(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_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_41] = [__v_20]; record.function_queries[41].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_41] = { let __args: [G; IN_41] = [__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(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_27: G = __r_arr[0]; let __ret: [G; OUT_41] = [__v_27]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __v_11: G = (__v_8 + __v_9); let __v_12: G = (__v_7 + __v_11); let __v_13: G = (__v_6 + __v_12); 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_36] = { let __args: [G; IN_36] = [__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(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_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_41] = [__v_19]; record.function_queries[41].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_41] = { let __args: [G; IN_41] = [__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(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_26: G = __r_arr[0]; let __ret: [G; OUT_41] = [__v_26]; record.function_queries[41].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_36] = { let __args: [G; IN_36] = [__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(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 = { 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_41] = [__v_16]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_42: usize = 2; const IN_42: usize = 2; 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]; 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_42] = [__v_6]; record.function_queries[42].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_43: usize = 3; -const IN_43: usize = 3; +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 __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_42] = [__v_1]; record.function_queries[42].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_11, __v_1]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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 __ret: [G; OUT_42] = [__v_13]; record.function_queries[42].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_43: usize = 2; +const IN_43: usize = 2; 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]; 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_42] = { let __args: [G; IN_42] = [__v_1, __v_2]; 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_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_43] = [__v_7]; record.function_queries[43].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_44: usize = 4; -const IN_44: usize = 4; +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_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_43] = [__v_6]; record.function_queries[43].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_44: usize = 3; +const IN_44: usize = 3; 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 = G::from_u64(0); let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __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_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_44] = [__v_6]; record.function_queries[44].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_45: usize = 6; -const IN_45: usize = 6; +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]; 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_43] = { let __args: [G; IN_43] = [__v_1, __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_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_44] = [__v_7]; record.function_queries[44].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_45: usize = 4; +const IN_45: usize = 4; 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 __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_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(16); let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_4]; 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_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_45] = [__v_12]; record.function_queries[45].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_46: usize = 18; -const IN_46: usize = 18; -const OUT_46: usize = 8; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_46] = { let __args: [G; IN_46] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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(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_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_17] = { let __args: [G; IN_17] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; 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_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_46] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[46].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_46] = [__v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; record.function_queries[46].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_45(inp: [G; IN_45], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; 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_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2]; 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_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_45] = [__v_6]; record.function_queries[45].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_46: usize = 6; +const IN_46: usize = 6; +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]; let __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_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(16); let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_4]; 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 = (__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_46] = [__v_12]; record.function_queries[46].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_47: usize = 18; const IN_47: usize = 18; const OUT_47: usize = 8; -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]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_47] = { let __args: [G; IN_47] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_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(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_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_17] = { let __args: [G; IN_17] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; 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_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_47] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[47].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_47] = [__v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; record.function_queries[47].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_47(inp: [G; IN_47], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_47] = { let __args: [G; IN_47] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_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(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_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_47] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[47].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_47] = [__v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; record.function_queries[47].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_48: usize = 18; const IN_48: usize = 18; const OUT_48: usize = 8; -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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_48] = { let __args: [G; IN_48] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_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(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_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_17] = { let __args: [G; IN_17] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; 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_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_48] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[48].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_48] = [__v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; record.function_queries[48].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_49: usize = 19; -const IN_49: usize = 19; -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 __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_36] = { let __args: [G; IN_36] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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(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_56: G = __r_arr[0]; let __ret: [G; OUT_49] = [__v_56]; record.function_queries[49].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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(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_19: G = __r_arr[0]; let __ret: [G; OUT_49] = [__v_19]; record.function_queries[49].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_48(inp: [G; IN_48], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_48] = { let __args: [G; IN_48] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_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(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_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_48] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[48].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_48] = [__v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; record.function_queries[48].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_49: usize = 18; +const IN_49: usize = 18; +const OUT_49: usize = 8; +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 __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_49] = { let __args: [G; IN_49] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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(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_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_49] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[49].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_49] = [__v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; record.function_queries[49].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_50: usize = 19; const IN_50: usize = 19; const OUT_50: usize = 1; -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]; 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_50] = { let __args: [G; IN_50] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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(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_56: G = __r_arr[0]; let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_1, __v_2, __v_3, __v_56]; 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_57: G = __r_arr[0]; let __ret: [G; OUT_50] = [__v_57]; record.function_queries[50].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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(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_19: G = __r_arr[0]; let __ret: [G; OUT_50] = [__v_19]; record.function_queries[50].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_50(inp: [G; IN_50], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_35] = { let __args: [G; IN_35] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_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(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_56: G = __r_arr[0]; let __ret: [G; OUT_50] = [__v_56]; record.function_queries[50].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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(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_19: G = __r_arr[0]; let __ret: [G; OUT_50] = [__v_19]; record.function_queries[50].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_51: usize = 19; const IN_51: usize = 19; const OUT_51: usize = 1; -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]; 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_51] = { let __args: [G; IN_51] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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(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_56: G = __r_arr[0]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_56]; 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_57: G = __r_arr[0]; let __ret: [G; OUT_51] = [__v_57]; record.function_queries[51].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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(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_19: G = __r_arr[0]; let __ret: [G; OUT_51] = [__v_19]; 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; +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]; 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_51] = { let __args: [G; IN_51] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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(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_56: G = __r_arr[0]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_1, __v_2, __v_3, __v_56]; 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_57: G = __r_arr[0]; let __ret: [G; OUT_51] = [__v_57]; record.function_queries[51].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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(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_19: G = __r_arr[0]; let __ret: [G; OUT_51] = [__v_19]; record.function_queries[51].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_52: usize = 19; +const IN_52: usize = 19; const OUT_52: usize = 1; -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 __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_52] = [__v_66]; record.function_queries[52].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_52(inp: [G; IN_52], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_52] = { let __args: [G; IN_52] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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(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_56: G = __r_arr[0]; let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_56]; 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_57: G = __r_arr[0]; let __ret: [G; OUT_52] = [__v_57]; record.function_queries[52].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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(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_19: G = __r_arr[0]; let __ret: [G; OUT_52] = [__v_19]; record.function_queries[52].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_53: usize = 2; const IN_53: usize = 2; 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]; 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_53] = [__v_2]; record.function_queries[53].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_53] = [__v_2]; record.function_queries[53].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(2); let __ret: [G; OUT_53] = [__v_2]; record.function_queries[53].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_53] = [__v_2]; record.function_queries[53].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(5); let __ret: [G; OUT_53] = [__v_2]; record.function_queries[53].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(6); let __ret: [G; OUT_53] = [__v_2]; record.function_queries[53].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_53] = [__v_2]; record.function_queries[53].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(9); let __ret: [G; OUT_53] = [__v_2]; record.function_queries[53].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(10); let __ret: [G; OUT_53] = [__v_2]; record.function_queries[53].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_54: usize = 9; -const IN_54: usize = 9; -const OUT_54: usize = 8; -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]; 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_54] = { let __args: [G; IN_54] = [__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(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_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_17] = { let __args: [G; IN_17] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!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_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_54] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_54] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_53(inp: [G; IN_53], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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_53] = [__v_66]; 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 = 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]; 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_54] = [__v_2]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_54] = [__v_2]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(2); let __ret: [G; OUT_54] = [__v_2]; record.function_queries[54].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_54] = [__v_2]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(5); let __ret: [G; OUT_54] = [__v_2]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(6); let __ret: [G; OUT_54] = [__v_2]; record.function_queries[54].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_54] = [__v_2]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(9); let __ret: [G; OUT_54] = [__v_2]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(10); let __ret: [G; OUT_54] = [__v_2]; record.function_queries[54].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_55: usize = 9; const IN_55: usize = 9; -const OUT_55: usize = 9; -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]; 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_55] = { let __args: [G; IN_55] = [__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(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_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_55] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[55].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_55] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[55].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_56: usize = 10; -const IN_56: usize = 10; -const OUT_56: usize = 1; -fn aiur_fn_56(inp: [G; IN_56], 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; 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_56] = [__v_11]; record.function_queries[56].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { 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]; 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 = __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_55] = { let __args: [G; IN_55] = [__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(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_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_56] = { let __args: [G; IN_56] = [__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(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_28: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_29: G = __r_arr[0]; let __ret: [G; OUT_56] = [__v_29]; record.function_queries[56].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_56] = { let __args: [G; IN_56] = [__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(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_30: G = __r_arr[0]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__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(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_31: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_32: G = __r_arr[0]; let __ret: [G; OUT_56] = [__v_32]; record.function_queries[56].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_56] = { let __args: [G; IN_56] = [__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(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_30: G = __r_arr[0]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__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(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_31: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_32: G = __r_arr[0]; let __ret: [G; OUT_56] = [__v_32]; record.function_queries[56].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(3); let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_11: G = __r_arr[0]; let __ret: [G; OUT_56] = [__v_11]; record.function_queries[56].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_57: usize = 2; -const IN_57: usize = 2; +const OUT_55: usize = 8; +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]; 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_55] = { let __args: [G; IN_55] = [__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(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_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_55] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[55].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_55] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; record.function_queries[55].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_56: usize = 9; +const IN_56: usize = 9; +const OUT_56: usize = 9; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; 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_56] = { let __args: [G; IN_56] = [__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(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 __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_56] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[56].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_56] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[56].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_57: usize = 10; +const IN_57: usize = 10; 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]; let __loaded: [G; 3] = { let __base = 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_57] = [__v_1]; record.function_queries[57].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_57] = { let __args: [G; IN_57] = [__v_4, __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_23: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __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(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_24: G = __r_arr[0]; let __ret: [G; OUT_57] = [__v_24]; record.function_queries[57].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; 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_57] = [__v_11]; record.function_queries[57].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { 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]; 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_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_56] = { let __args: [G; IN_56] = [__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(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 __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_57] = { let __args: [G; IN_57] = [__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(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_28: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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 __ret: [G; OUT_57] = [__v_29]; record.function_queries[57].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_57] = { let __args: [G; IN_57] = [__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(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_30: G = __r_arr[0]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__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(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_31: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_32: G = __r_arr[0]; let __ret: [G; OUT_57] = [__v_32]; record.function_queries[57].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_57] = { let __args: [G; IN_57] = [__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(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_30: G = __r_arr[0]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__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(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_31: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_32: G = __r_arr[0]; let __ret: [G; OUT_57] = [__v_32]; record.function_queries[57].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(3); let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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 __ret: [G; OUT_57] = [__v_11]; record.function_queries[57].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_58: usize = 2; const IN_58: usize = 2; const OUT_58: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_58] = [__v_1]; record.function_queries[58].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_58] = { let __args: [G; IN_58] = [__v_4, __v_1]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__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(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_15: G = __r_arr[0]; let __ret: [G; OUT_58] = [__v_15]; record.function_queries[58].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_58] = [__v_1]; record.function_queries[58].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_58] = { let __args: [G; IN_58] = [__v_4, __v_1]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __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(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_24: G = __r_arr[0]; let __ret: [G; OUT_58] = [__v_24]; record.function_queries[58].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_59: usize = 2; const IN_59: usize = 2; const OUT_59: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_59] = [__v_1]; record.function_queries[59].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_4, __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_5: G = __r_arr[0]; 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 __ret: [G; OUT_59] = [__v_6]; record.function_queries[59].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_59] = [__v_1]; record.function_queries[59].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_59] = { let __args: [G; IN_59] = [__v_4, __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_14: G = __r_arr[0]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__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(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_15: G = __r_arr[0]; let __ret: [G; OUT_59] = [__v_15]; record.function_queries[59].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_60: usize = 2; const IN_60: usize = 2; 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]; 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_60] = [__v_3]; record.function_queries[60].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_60] = [__v_4]; record.function_queries[60].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_60] = [__v_4]; record.function_queries[60].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_60] = [__v_4]; 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 = 13; -const IN_61: usize = 13; +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 __loaded: [G; 3] = { let __base = 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_60] = [__v_1]; record.function_queries[60].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_4, __v_1]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_60] = [__v_6]; record.function_queries[60].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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_53] = { let __args: [G; IN_53] = [__v_0, __v_1]; 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_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(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_51: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_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(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_52: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_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_61] = [__v_54]; record.function_queries[61].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_62: usize = 10; -const IN_62: usize = 10; +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]; 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_61] = [__v_3]; record.function_queries[61].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_61] = [__v_4]; record.function_queries[61].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_61] = [__v_4]; record.function_queries[61].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_61] = [__v_4]; record.function_queries[61].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_62: usize = 13; +const IN_62: usize = 13; 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; 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_36] = { let __args: [G; IN_36] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_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(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_28: G = __r_arr[0]; 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_28]; 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 __ret: [G; OUT_62] = [__v_29]; 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; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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_54] = { let __args: [G; IN_54] = [__v_0, __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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_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(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_51: G = __r_arr[0]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_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(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_52: G = __r_arr[0]; 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_52]; 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_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_62] = [__v_54]; record.function_queries[62].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_63: usize = 10; +const IN_63: usize = 10; 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; 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_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_12, __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_13: G = __r_arr[0]; let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_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_14: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_14]; 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 = 45; -const IN_64: usize = 45; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; 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_35] = { let __args: [G; IN_35] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_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(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_28: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_29]; record.function_queries[63].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_793] = { let __args: [G; IN_793] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(793, (&__args[..]))?) { [G::ZERO; OUT_793] } else { let (__hash, __hit) = record.function_queries[793].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[793].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[793].bump_multiplicity(__i); } let __ret: [G; OUT_793] = unsafe { (*(record.function_queries[793].output_at(__i).as_ptr() as *const [G; OUT_793])) }; __ret }, _ => { aiur_fn_793::(__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_63] = { let __args: [G; IN_63] = [__v_43, __v_44]; 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_75: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_76: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_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(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_77: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_78: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_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(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_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(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_38] = { let __args: [G; IN_38] = [__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(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_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_64] = [__v_83]; record.function_queries[64].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_65: usize = 11; -const IN_65: usize = 11; +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]; 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_64] = [__v_1]; record.function_queries[64].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_12, __v_1]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_64] = [__v_14]; record.function_queries[64].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_65: usize = 45; +const IN_65: usize = 45; 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]; 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_36] = { let __args: [G; IN_36] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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(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_30: G = __r_arr[0]; 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_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 = { 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_65] = [__v_32]; record.function_queries[65].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_65(inp: [G; IN_65], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_796] = { let __args: [G; IN_796] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(796, (&__args[..]))?) { [G::ZERO; OUT_796] } else { let (__hash, __hit) = record.function_queries[796].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[796].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[796].bump_multiplicity(__i); } let __ret: [G; OUT_796] = unsafe { (*(record.function_queries[796].output_at(__i).as_ptr() as *const [G; OUT_796])) }; __ret }, _ => { aiur_fn_796::(__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_64] = { let __args: [G; IN_64] = [__v_43, __v_44]; 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_75: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_76: G = __r_arr[0]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_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(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_77: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_78: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_79: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; 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_80: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_81: G = __r_arr[0]; 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_81]; 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_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_65] = [__v_83]; record.function_queries[65].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_66: usize = 11; const IN_66: usize = 11; 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]; 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_36] = { let __args: [G; IN_36] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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(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_29: G = __r_arr[0]; 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_29]; 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_60] = { let __args: [G; IN_60] = [__v_0, __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 __ret: [G; OUT_66] = [__v_31]; record.function_queries[66].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_67: usize = 35; -const IN_67: usize = 35; +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]; 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_35] = { let __args: [G; IN_35] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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(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_30: G = __r_arr[0]; 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_8, __v_30]; 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_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_66] = [__v_32]; record.function_queries[66].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_67: usize = 11; +const IN_67: usize = 11; 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_36] = { let __args: [G; IN_36] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_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(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_54: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_38] = { let __args: [G; IN_38] = [__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(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_38] = { let __args: [G; IN_38] = [__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(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_38] = { let __args: [G; IN_38] = [__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(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_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_67] = [__v_59]; 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; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; 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_35] = { let __args: [G; IN_35] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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(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_29: G = __r_arr[0]; 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_8, __v_29]; 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_30: G = __r_arr[0]; let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_0, __v_30]; 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_31: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_31]; record.function_queries[67].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_68: usize = 35; +const IN_68: usize = 35; 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 __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_68] = [__v_1]; record.function_queries[68].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_37, __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_38: G = __r_arr[0]; let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; 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_39: G = __r_arr[0]; let __ret: [G; OUT_68] = [__v_39]; record.function_queries[68].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_69: usize = 28; -const IN_69: usize = 28; +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]; 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_35] = { let __args: [G; IN_35] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_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(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_54: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_56: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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 __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_8, __v_57]; 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_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_68] = [__v_59]; record.function_queries[68].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_69: usize = 2; +const IN_69: usize = 2; const OUT_69: usize = 1; -fn aiur_fn_69(inp: [G; IN_69], 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]; 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_788] = { let __args: [G; IN_788] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(788, (&__args[..]))?) { [G::ZERO; OUT_788] } else { let (__hash, __hit) = record.function_queries[788].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[788].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { (*(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788])) }; __ret }, _ => { aiur_fn_788::(__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_68] = { let __args: [G; IN_68] = [__v_26, __v_27]; 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_55: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_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(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_57: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_58: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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_59: G = __r_arr[0]; 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_59]; 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_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_69] = [__v_61]; record.function_queries[69].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_70: usize = 10; -const IN_70: usize = 10; +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 __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_69] = [__v_1]; record.function_queries[69].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_37, __v_1]; 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_38: G = __r_arr[0]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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(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_39: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_39]; record.function_queries[69].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_70: usize = 28; +const IN_70: usize = 28; 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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; 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_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 __ret: [G; OUT_70] = [__v_11]; record.function_queries[70].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_71: usize = 18; -const IN_71: usize = 18; +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]; 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_791] = { let __args: [G; IN_791] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(791, (&__args[..]))?) { [G::ZERO; OUT_791] } else { let (__hash, __hit) = record.function_queries[791].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[791].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { (*(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791])) }; __ret }, _ => { aiur_fn_791::(__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_69] = { let __args: [G; IN_69] = [__v_26, __v_27]; 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_55: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_56: G = __r_arr[0]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_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(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_57: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_58: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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_59: G = __r_arr[0]; 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_8, __v_59]; 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_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_70] = [__v_61]; record.function_queries[70].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_71: usize = 10; +const IN_71: usize = 10; 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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__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_18: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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 __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_19]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_20]; record.function_queries[71].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_72: usize = 46; -const IN_72: usize = 46; +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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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_11: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_11]; record.function_queries[71].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_72: usize = 18; +const IN_72: usize = 18; 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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_61] = { let __args: [G; IN_61] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; 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_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_72] = [__v_48]; record.function_queries[72].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_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_11, __v_12, __v_13, __v_14, __v_15, __v_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(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_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_72] = [__v_49]; record.function_queries[72].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_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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(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_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_72] = [__v_49]; record.function_queries[72].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_73: usize = 2; -const IN_73: usize = 2; +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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_53] = { let __args: [G; IN_53] = [__v_16, __v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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(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 __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_20]; record.function_queries[72].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_73: usize = 46; +const IN_73: usize = 46; 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 __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_73] = [__v_1]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_48, __v_1]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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(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_50: G = __r_arr[0]; let __ret: [G; OUT_73] = [__v_50]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_74: usize = 46; -const IN_74: usize = 46; +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 __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_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; 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_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_73] = [__v_48]; record.function_queries[73].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_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_11, __v_12, __v_13, __v_14, __v_15, __v_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(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_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_73] = [__v_49]; record.function_queries[73].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_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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(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_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_73] = [__v_49]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_74: usize = 2; +const IN_74: usize = 2; 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]; 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_61] = { let __args: [G; IN_61] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; 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_46: G = __r_arr[0]; let __ret: [G; OUT_74] = [__v_46]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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(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_46: G = __r_arr[0]; let __ret: [G; OUT_74] = [__v_46]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { 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_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_74] = [__v_46]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; 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_46: G = __r_arr[0]; let __ret: [G; OUT_74] = [__v_46]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_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(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_46: G = __r_arr[0]; let __ret: [G; OUT_74] = [__v_46]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { 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_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_74] = [__v_46]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { 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_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_74] = [__v_46]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { 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_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_74] = [__v_46]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_75: usize = 2; -const IN_75: usize = 2; +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 __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_74] = [__v_1]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_48, __v_1]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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(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_50: G = __r_arr[0]; let __ret: [G; OUT_74] = [__v_50]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_75: usize = 46; +const IN_75: usize = 46; 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 __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_0]; 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_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_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_10: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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 __ret: [G; OUT_75] = [__v_11]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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]; 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_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; 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_46: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_46]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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(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_75] = [__v_46]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; 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_46: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_46]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__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(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_46: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_46]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_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(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_46: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_46]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__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(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_46: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_46]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__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(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_46: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_46]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__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(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_46: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_46]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_76: usize = 2; const IN_76: usize = 2; 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 __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_0]; 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_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_59] = { let __args: [G; IN_59] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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 __ret: [G; OUT_76] = [__v_11]; record.function_queries[76].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__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_58] = { let __args: [G; IN_58] = [__v_0, __v_1]; 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 __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_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_11: G = __r_arr[0]; let __ret: [G; OUT_76] = [__v_11]; record.function_queries[76].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } 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 __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_0]; 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_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_58] = { let __args: [G; IN_58] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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(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 __ret: [G; OUT_77] = [__v_11]; record.function_queries[77].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_78: usize = 49; -const IN_78: usize = 49; +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 __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__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_60] = { let __args: [G; IN_60] = [__v_0, __v_1]; 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_10: G = __r_arr[0]; 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_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_11: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_11]; record.function_queries[77].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_78: usize = 2; +const IN_78: usize = 2; 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]; 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_77] = { let __args: [G; IN_77] = [__v_47, __v_48]; 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_46, __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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_45, __v_50]; 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_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_73] = { let __args: [G; IN_73] = [__v_1, __v_51]; 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_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_78] = [__v_62]; record.function_queries[78].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_74] = { let __args: [G; IN_74] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_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_78] = [__v_55]; record.function_queries[78].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_74] = { let __args: [G; IN_74] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_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_78] = [__v_56]; record.function_queries[78].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_74] = { let __args: [G; IN_74] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_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_78] = [__v_56]; record.function_queries[78].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_74] = { let __args: [G; IN_74] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_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_78] = [__v_56]; record.function_queries[78].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_74] = { let __args: [G; IN_74] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_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_78] = [__v_56]; record.function_queries[78].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_74] = { let __args: [G; IN_74] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_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_78] = [__v_56]; record.function_queries[78].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_74] = { let __args: [G; IN_74] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_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_78] = [__v_56]; record.function_queries[78].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_74] = { let __args: [G; IN_74] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_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_78] = [__v_56]; 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 = 1; -const IN_79: usize = 1; -const OUT_79: usize = 2; -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(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_79] = [__v_2, __v_3]; record.function_queries[79].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_80: usize = 2; -const IN_80: usize = 2; -const OUT_80: usize = 9; -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 __v_2: G = G::from_u64(0); let __ret: [G; OUT_80] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_0]; record.function_queries[80].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_80] = { let __args: [G; IN_80] = [__v_4, __v_6]; 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_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_80] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; record.function_queries[80].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_81: usize = 1; -const IN_81: 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 __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__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_59] = { let __args: [G; IN_59] = [__v_0, __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_10: G = __r_arr[0]; 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_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_11: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_11]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_79: usize = 49; +const IN_79: usize = 49; +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 __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_78] = { let __args: [G; IN_78] = [__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_46, __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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_45, __v_50]; 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_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(795, (&__args[..]))?) { [G::ZERO; OUT_795] } else { let (__hash, __hit) = record.function_queries[795].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[795].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[795].bump_multiplicity(__i); } let __ret: [G; OUT_795] = unsafe { (*(record.function_queries[795].output_at(__i).as_ptr() as *const [G; OUT_795])) }; __ret }, _ => { aiur_fn_795::(__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_74] = { let __args: [G; IN_74] = [__v_1, __v_51]; 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_61: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if ((!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_62: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_62]; record.function_queries[79].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_75] = { let __args: [G; IN_75] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_54: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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(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_55: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_55]; record.function_queries[79].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_75] = { let __args: [G; IN_75] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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(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_56: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_56]; record.function_queries[79].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_75] = { let __args: [G; IN_75] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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(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_56: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_56]; record.function_queries[79].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_75] = { let __args: [G; IN_75] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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(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_56: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_56]; record.function_queries[79].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_75] = { let __args: [G; IN_75] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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(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_56: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_56]; record.function_queries[79].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_75] = { let __args: [G; IN_75] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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(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_56: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_56]; record.function_queries[79].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_75] = { let __args: [G; IN_75] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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(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_56: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_56]; record.function_queries[79].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_75] = { let __args: [G; IN_75] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(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_55: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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(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_56: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_56]; record.function_queries[79].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_80: usize = 1; +const IN_80: usize = 1; +const OUT_80: usize = 2; +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 __loaded: [G; 3] = { let __base = 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_80] = [__v_2, __v_3]; record.function_queries[80].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_81: usize = 2; +const IN_81: usize = 2; const OUT_81: usize = 9; -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 __loaded: [G; 3] = { let __base = 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_5); let __v_14: G = G::from_u64(4); let __v_15: G = (__v_14 * __v_6); let __v_16: G = G::from_u64(8); let __v_17: G = (__v_16 * __v_7); let __v_18: G = G::from_u64(16); let __v_19: G = (__v_18 * __v_8); let __v_20: G = G::from_u64(32); let __v_21: G = (__v_20 * __v_9); let __v_22: G = G::from_u64(64); let __v_23: G = (__v_22 * __v_10); let __v_24: G = (__v_21 + __v_23); let __v_25: G = (__v_19 + __v_24); let __v_26: G = (__v_17 + __v_25); let __v_27: G = (__v_15 + __v_26); let __v_28: G = (__v_13 + __v_27); let __v_29: G = (__v_4 + __v_28); match __v_11.as_canonical_u64() { 0u64 => { let __v_30: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_3]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(1); let __v_31: G = (__v_29 + __v_30); let __v_32: G = G::from_u64(9); 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) }; if (__v_33 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("tag0: payload width exceeds 8 bytes".to_string()) }); } let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_3, __v_31]; 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_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 __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; 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_43: G = __r_arr[0]; if (__v_43 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("nonminimal tag0 width".to_string()) }); } let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_31.as_canonical_u64() { 1u64 => { let __v_44: G = G::from_u64(128); let __v_45: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_34), (&__v_44)) } else { aiur::execute::bytes2_less_than_value(__v_34, __v_44, record) }; let __v_46: G = G::from_u64(0); if (__v_45 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("nonminimal tag0 value".to_string()) }); } break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __ret: [G; OUT_81] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_0]; record.function_queries[81].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_81] = { let __args: [G; IN_81] = [__v_4, __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_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_81] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_82: usize = 1; const IN_82: usize = 1; const OUT_82: usize = 10; -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(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 = G::from_u64(4); let __v_17: G = (__v_16 * __v_6); let __v_18: G = G::from_u64(8); let __v_19: G = (__v_18 * __v_7); let __v_20: G = G::from_u64(16); let __v_21: G = (__v_20 * __v_8); let __v_22: G = (__v_19 + __v_21); let __v_23: G = (__v_17 + __v_22); let __v_24: G = (__v_15 + __v_23); let __v_25: G = (__v_4 + __v_24); match __v_9.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_82] = [__v_14, __v_25, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_3]; record.function_queries[82].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(1); let __v_27: G = (__v_25 + __v_26); let __v_28: G = G::from_u64(9); let __v_29: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_27), (&__v_28)) } else { aiur::execute::bytes2_less_than_value(__v_27, __v_28, record) }; if (__v_29 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) }); } let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_3, __v_27]; 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_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_6] = { let __args: [G; IN_6] = [__v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_39: G = __r_arr[0]; if (__v_39 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("nonminimal tag2 width".to_string()) }); } let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_27.as_canonical_u64() { 1u64 => { let __v_40: G = G::from_u64(32); let __v_41: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_30), (&__v_40)) } else { aiur::execute::bytes2_less_than_value(__v_30, __v_40, record) }; let __v_42: G = G::from_u64(0); if (__v_41 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("nonminimal tag2 value".to_string()) }); } break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __ret: [G; OUT_82] = [__v_14, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; record.function_queries[82].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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(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 = G::from_u64(4); let __v_15: G = (__v_14 * __v_10); let __v_16: G = G::from_u64(8); let __v_17: G = (__v_16 * __v_11); let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_13 + __v_18); let __v_20: G = (__v_8 + __v_19); let __v_21: G = (__v_12 * __v_5); let __v_22: G = (__v_14 * __v_6); let __v_23: G = (__v_21 + __v_22); let __v_24: G = (__v_4 + __v_23); match __v_7.as_canonical_u64() { 0u64 => { let __v_25: G = G::from_u64(0); let __ret: [G; OUT_82] = [__v_20, __v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_3]; record.function_queries[82].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_25: G = G::from_u64(4); let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_24, __v_25, __v_3]; 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_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_82] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; record.function_queries[82].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_83: usize = 1; const IN_83: usize = 1; const OUT_83: usize = 10; -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 __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 = G::from_u64(4); let __v_15: G = (__v_14 * __v_10); let __v_16: G = G::from_u64(8); let __v_17: G = (__v_16 * __v_11); let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_13 + __v_18); let __v_20: G = (__v_8 + __v_19); let __v_21: G = (__v_12 * __v_5); let __v_22: G = (__v_14 * __v_6); let __v_23: G = (__v_21 + __v_22); let __v_24: G = (__v_4 + __v_23); match __v_7.as_canonical_u64() { 0u64 => { let __v_25: G = G::from_u64(0); let __ret: [G; OUT_83] = [__v_20, __v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_3]; record.function_queries[83].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_25: G = G::from_u64(1); let __v_26: G = (__v_24 + __v_25); let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_3, __v_26]; 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_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 __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; 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_36: G = __r_arr[0]; if (__v_36 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("nonminimal tag4 width".to_string()) }); } let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_26.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(8); let __v_38: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_27), (&__v_37)) } else { aiur::execute::bytes2_less_than_value(__v_27, __v_37, record) }; let __v_39: G = G::from_u64(0); if (__v_38 != __v_39) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("nonminimal tag4 value".to_string()) }); } break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __ret: [G; OUT_83] = [__v_20, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; 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 = 9; -const IN_84: usize = 9; -const OUT_84: usize = 2; -fn aiur_fn_84(inp: [G; IN_84], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_84] = [__v_11, __v_0]; record.function_queries[84].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; 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 __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_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_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_84] = { let __args: [G; IN_84] = [__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(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_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_84] = [__v_30, __v_28]; record.function_queries[84].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_85: usize = 10; -const IN_85: usize = 10; -const OUT_85: usize = 2; -fn aiur_fn_85(inp: [G; IN_85], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __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_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_85] = [__v_0, __v_1]; record.function_queries[85].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_1]; 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 = 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_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_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_85] = { let __args: [G; IN_85] = [__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(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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_24, __v_25]; record.function_queries[85].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } -const INPUT_SIZE_86: usize = 2; -const IN_86: usize = 2; -const OUT_86: usize = 2; -fn aiur_fn_86(inp: [G; IN_86], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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_86] = [__v_2, __v_3]; record.function_queries[86].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_87: usize = 4; -const IN_87: usize = 4; -const OUT_87: usize = 3; -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 = 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_86] = { let __args: [G; IN_86] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_87] = [__v_7, __v_8, __v_9]; record.function_queries[87].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_88: usize = 1; -const IN_88: usize = 1; -const OUT_88: usize = 4; -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_79] = { let __args: [G; IN_79] = [__v_0]; 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_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 = (__v_8 + __v_11); let __v_13: G = (__v_7 + __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: Some("reserved binder contract bits".to_string()) }); } let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_3, __v_4, __v_5, __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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __ret: [G; OUT_88] = [__v_15, __v_16, __v_17, __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 = 6; -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_79] = { let __args: [G; IN_79] = [__v_0]; 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_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_87] = { let __args: [G; IN_87] = [__v_3, __v_4, __v_5, __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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_8]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_89] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; record.function_queries[89].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { 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_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_90] = [__v_10, __v_11]; record.function_queries[90].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_90] = [__v_10, __v_11]; record.function_queries[90].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 0u64 => { 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_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_92] = { let __args: [G; IN_92] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; 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 = __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_90] = { let __args: [G; IN_90] = [__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(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_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_90] = [__v_28, __v_25]; 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 = 9; -const IN_91: usize = 9; -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 __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { 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_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_91] = [__v_10, __v_11]; record.function_queries[91].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_91] = [__v_10, __v_11]; record.function_queries[91].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 0u64 => { 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_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_92] = { let __args: [G; IN_92] = [__v_15]; 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 __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_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_91] = { let __args: [G; IN_91] = [__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(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_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_91] = [__v_30, __v_27]; record.function_queries[91].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +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 __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 = G::from_u64(4); let __v_17: G = (__v_16 * __v_6); let __v_18: G = G::from_u64(8); let __v_19: G = (__v_18 * __v_7); let __v_20: G = G::from_u64(16); let __v_21: G = (__v_20 * __v_8); let __v_22: G = (__v_19 + __v_21); let __v_23: G = (__v_17 + __v_22); let __v_24: G = (__v_15 + __v_23); let __v_25: G = (__v_4 + __v_24); match __v_9.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_83] = [__v_14, __v_25, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_3]; record.function_queries[83].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_26: G = G::from_u64(16); let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_25, __v_26, __v_3]; 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_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_83] = [__v_14, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[83].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_84: usize = 1; +const IN_84: usize = 1; +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 __loaded: [G; 3] = { let __base = 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_84] = [__v_2, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_3]; record.function_queries[84].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_85] = { let __args: [G; IN_85] = [__v_7, __v_8, __v_3]; 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_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_84] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; record.function_queries[84].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_85: usize = 3; +const IN_85: usize = 3; +const OUT_85: usize = 9; +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 = 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_85] = [__v_9, __v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_6]; record.function_queries[85].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_86] = { let __args: [G; IN_86] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_85] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; record.function_queries[85].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_86: usize = 3; +const IN_86: usize = 3; +const OUT_86: usize = 9; +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 = 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_81] = { let __args: [G; IN_81] = [__v_2, __v_5]; 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_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_86] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_14]; record.function_queries[86].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(3); let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2, __v_5]; 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_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_86] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_14]; record.function_queries[86].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(4); let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2, __v_5]; 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_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_86] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_14]; record.function_queries[86].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_5: G = G::from_u64(8); let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2, __v_5]; 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_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_86] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_14]; record.function_queries[86].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_87: usize = 9; +const IN_87: usize = 9; +const OUT_87: usize = 2; +fn aiur_fn_87(inp: [G; IN_87], 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 __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_87] = [__v_11, __v_0]; record.function_queries[87].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_87] = { let __args: [G; IN_87] = [__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(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_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_87] = [__v_30, __v_28]; record.function_queries[87].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +const INPUT_SIZE_88: usize = 10; +const IN_88: usize = 10; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __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_88] = [__v_0, __v_1]; record.function_queries[88].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_1]; 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 = 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_88] = { let __args: [G; IN_88] = [__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(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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __ret: [G; OUT_88] = [__v_24, __v_25]; record.function_queries[88].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } +const INPUT_SIZE_89: usize = 2; +const IN_89: usize = 2; +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 __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_89] = [__v_2, __v_3]; record.function_queries[89].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_90: usize = 4; +const IN_90: usize = 4; +const OUT_90: usize = 3; +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 = 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_89] = { let __args: [G; IN_89] = [__v_2, __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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_90] = [__v_7, __v_8, __v_9]; record.function_queries[90].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_91: usize = 1; +const IN_91: usize = 1; +const OUT_91: usize = 4; +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_80] = { let __args: [G; IN_80] = [__v_0]; 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_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 = (__v_8 + __v_11); let __v_13: G = (__v_7 + __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: Some("reserved binder contract bits".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_3, __v_4, __v_5, __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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __ret: [G; OUT_91] = [__v_15, __v_16, __v_17, __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_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 = __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_92] = [__v_12, __v_10]; record.function_queries[92].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_92] = [__v_13, __v_10]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; 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_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_84] = { let __args: [G; IN_84] = [__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(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_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_92] = [__v_24, __v_21]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; 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_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_84] = { let __args: [G; IN_84] = [__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(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_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_92] = [__v_24, __v_21]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; 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_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 = 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_92] = [__v_23, __v_21]; record.function_queries[92].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_92] = [__v_13, __v_10]; record.function_queries[92].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_92] = [__v_13, __v_10]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_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_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_85] = { let __args: [G; IN_85] = [__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(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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __ret: [G; OUT_92] = [__v_35, __v_36]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__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(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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __ret: [G; OUT_92] = [__v_33, __v_34]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 8u64 => { let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_90] = { let __args: [G; IN_90] = [__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(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 __ret: [G; OUT_92] = [__v_13, __v_14]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_91] = { let __args: [G; IN_91] = [__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(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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_92] = [__v_13, __v_14]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__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(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 __ret: [G; OUT_92] = [__v_11, __v_12]; record.function_queries[92].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_92] = [__v_13, __v_10]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const OUT_92: usize = 6; +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_80] = { let __args: [G; IN_80] = [__v_0]; 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_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_90] = { let __args: [G; IN_90] = [__v_3, __v_4, __v_5, __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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_8]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_92] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_93: usize = 9; const IN_93: usize = 9; const OUT_93: usize = 2; -fn aiur_fn_93(inp: [G; IN_93], 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 = inp[4]; let __v_5: G = 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_7 + __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_4 + __v_11); let __v_13: G = (__v_3 + __v_12); let __v_14: G = (__v_2 + __v_13); 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_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_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_92] = { let __args: [G; IN_92] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_35]; 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_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_93] = [__v_40, __v_37]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_94: usize = 17; -const IN_94: usize = 17; -const OUT_94: usize = 9; -fn aiur_fn_94(inp: [G; IN_94], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_7] = { let __args: [G; IN_7] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_94] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[94].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_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_94] = { let __args: [G; IN_94] = [__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(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_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_94] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; record.function_queries[94].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } +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 = inp[4]; let __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_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 __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_93] = [__v_10, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_93] = [__v_10, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 0u64 => { 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_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_95] = { let __args: [G; IN_95] = [__v_13]; 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_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_93] = { let __args: [G; IN_93] = [__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(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_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_93] = [__v_28, __v_25]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +const INPUT_SIZE_94: usize = 9; +const IN_94: usize = 9; +const OUT_94: usize = 2; +fn aiur_fn_94(inp: [G; IN_94], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_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 __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_94] = [__v_10, __v_11]; record.function_queries[94].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_94] = [__v_10, __v_11]; record.function_queries[94].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 0u64 => { 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_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_95] = { let __args: [G; IN_95] = [__v_15]; 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_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_94] = { let __args: [G; IN_94] = [__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(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_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_94] = [__v_30, __v_27]; record.function_queries[94].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } const INPUT_SIZE_95: usize = 1; const IN_95: usize = 1; -const OUT_95: usize = 10; -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_82] = { let __args: [G; IN_82] = [__v_0]; 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_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_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_95] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_10]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_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_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(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 __ret: [G; OUT_95] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; record.function_queries[95].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_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 __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_20]; 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_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_95] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { 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 __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_20]; 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_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_95] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(4); let __ret: [G; OUT_95] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_96: usize = 1; -const IN_96: usize = 1; +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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; 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_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_95] = [__v_12, __v_10]; record.function_queries[95].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_95] = [__v_13, __v_10]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __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, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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_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_95] = [__v_24, __v_21]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __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, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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_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_95] = [__v_24, __v_21]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __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 = 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_95] = [__v_23, __v_21]; record.function_queries[95].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_95] = [__v_13, __v_10]; record.function_queries[95].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_95] = [__v_13, __v_10]; record.function_queries[95].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_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_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_88] = { let __args: [G; IN_88] = [__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(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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_35, __v_36]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__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(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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_33, __v_34]; record.function_queries[95].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_93] = { let __args: [G; IN_93] = [__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(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 __ret: [G; OUT_95] = [__v_13, __v_14]; record.function_queries[95].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_94] = { let __args: [G; IN_94] = [__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(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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_13, __v_14]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_11, __v_12]; record.function_queries[95].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_95] = [__v_13, __v_10]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_96] = [__v_97, __v_96]; record.function_queries[96].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_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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_97] = [__v_11, __v_0]; record.function_queries[97].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; 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_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_97] = { let __args: [G; IN_97] = [__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(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_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_97] = [__v_23, __v_21]; 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 = 9; -const IN_98: usize = 9; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_98] = [__v_11, __v_0]; record.function_queries[98].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 __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_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_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_98] = { let __args: [G; IN_98] = [__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(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_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_98] = [__v_32, __v_29]; record.function_queries[98].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_99: usize = 9; -const IN_99: usize = 9; +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 __v_9: G = (__v_7 + __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_4 + __v_11); let __v_13: G = (__v_3 + __v_12); let __v_14: G = (__v_2 + __v_13); 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_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_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_95] = { let __args: [G; IN_95] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_35]; 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_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_96] = [__v_40, __v_37]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_97: usize = 17; +const IN_97: usize = 17; +const OUT_97: usize = 9; +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 __v_9: G = inp[9]; 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_97] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[97].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_97] = { let __args: [G; IN_97] = [__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(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 = __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_97] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; record.function_queries[97].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } +const INPUT_SIZE_98: usize = 1; +const IN_98: usize = 1; +const OUT_98: usize = 10; +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_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 = __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_98] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_10]; record.function_queries[98].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_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_97] = { let __args: [G; IN_97] = [__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(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_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_98] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; record.function_queries[98].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_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_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_98] = { let __args: [G; IN_98] = [__v_20]; 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_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_98] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; record.function_queries[98].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { 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_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_98] = { let __args: [G; IN_98] = [__v_20]; 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_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_98] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; record.function_queries[98].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(4); let __ret: [G; OUT_98] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __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 = 1; +const IN_99: usize = 1; 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 __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_99] = [__v_11, __v_0]; record.function_queries[99].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_0]; 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 __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_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_99] = { let __args: [G; IN_99] = [__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(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_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_99] = [__v_23, __v_21]; record.function_queries[99].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_100: usize = 1; -const IN_100: usize = 1; +fn aiur_fn_99(inp: [G; IN_99], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = 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_99] = [__v_97, __v_96]; record.function_queries[99].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_100: usize = 9; +const IN_100: usize = 9; 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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; 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_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_97] = { let __args: [G; IN_97] = [__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(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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_100] = [__v_10, __v_11]; 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; +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 __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_100] = [__v_11, __v_0]; record.function_queries[100].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 __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_100] = { let __args: [G; IN_100] = [__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(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_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_100] = [__v_23, __v_21]; record.function_queries[100].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +const INPUT_SIZE_101: usize = 9; +const IN_101: usize = 9; const OUT_101: usize = 2; -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_81] = { let __args: [G; IN_81] = [__v_0]; 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_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_99] = { let __args: [G; IN_99] = [__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(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 __ret: [G; OUT_101] = [__v_10, __v_11]; record.function_queries[101].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_102: usize = 1; -const IN_102: usize = 1; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_101] = [__v_11, __v_0]; record.function_queries[101].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 __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_101] = { let __args: [G; IN_101] = [__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(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_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_101] = [__v_32, __v_29]; record.function_queries[101].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +const INPUT_SIZE_102: usize = 9; +const IN_102: usize = 9; 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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; 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_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, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_102] = [__v_10, __v_11]; record.function_queries[102].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_102(inp: [G; IN_102], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_102] = [__v_11, __v_0]; record.function_queries[102].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_0]; 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 __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_102] = { let __args: [G; IN_102] = [__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(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_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_102] = [__v_23, __v_21]; record.function_queries[102].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } const INPUT_SIZE_103: usize = 1; const IN_103: usize = 1; 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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_103] = [__v_1, __v_1]; record.function_queries[103].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_103] = [__v_1, __v_2]; record.function_queries[103].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_103] = [__v_1, __v_2]; record.function_queries[103].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_103] = [__v_1, __v_2]; record.function_queries[103].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_103] = [__v_1, __v_1]; record.function_queries[103].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_103] = [__v_1, __v_2]; record.function_queries[103].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_103] = [__v_1, __v_2]; record.function_queries[103].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_103] = [__v_1, __v_2]; record.function_queries[103].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_103] = [__v_1, __v_1]; record.function_queries[103].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_103(inp: [G; IN_103], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __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_100] = { let __args: [G; IN_100] = [__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(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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_103] = [__v_10, __v_11]; record.function_queries[103].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_104: usize = 1; const IN_104: usize = 1; -const OUT_104: usize = 13; -fn aiur_fn_104(inp: [G; IN_104], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; 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_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_92] = { let __args: [G; IN_92] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_15]; 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_104] = [__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[104].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __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, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_104] = [__v_10, __v_11]; record.function_queries[104].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_105: usize = 1; const IN_105: usize = 1; -const OUT_105: usize = 10; -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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; 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_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 __ret: [G; OUT_105] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; record.function_queries[105].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_106: usize = 9; -const IN_106: 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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __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_101] = { let __args: [G; IN_101] = [__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(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 __ret: [G; OUT_105] = [__v_10, __v_11]; 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 = 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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_106] = [__v_11, __v_0]; record.function_queries[106].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; 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 __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 __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_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_106] = { let __args: [G; IN_106] = [__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(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_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_106] = [__v_32, __v_30]; record.function_queries[106].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_106] = [__v_1, __v_1]; record.function_queries[106].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_106] = [__v_1, __v_2]; record.function_queries[106].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_106] = [__v_1, __v_2]; record.function_queries[106].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_106] = [__v_1, __v_2]; record.function_queries[106].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_106] = [__v_1, __v_1]; record.function_queries[106].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_106] = [__v_1, __v_2]; record.function_queries[106].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_106] = [__v_1, __v_2]; record.function_queries[106].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_106] = [__v_1, __v_2]; record.function_queries[106].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_106] = [__v_1, __v_1]; record.function_queries[106].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_107: usize = 1; const IN_107: usize = 1; -const OUT_107: usize = 45; -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_79] = { let __args: [G; IN_79] = [__v_0]; 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_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_81] = { let __args: [G; IN_81] = [__v_2]; 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_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_81] = { let __args: [G; IN_81] = [__v_22]; 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_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_81] = { let __args: [G; IN_81] = [__v_31]; 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_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_81] = { let __args: [G; IN_81] = [__v_40]; 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_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_81] = { let __args: [G; IN_81] = [__v_49]; 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_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_92] = { let __args: [G; IN_92] = [__v_58]; 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_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_60]; 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_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_106] = { let __args: [G; IN_106] = [__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(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_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __ret: [G; OUT_107] = [__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[107].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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_80] = { let __args: [G; IN_80] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_15]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_107] = [__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[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 = 0; -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 = 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_108] = []; 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 = 11; -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_79] = { let __args: [G; IN_79] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; 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_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_92] = { let __args: [G; IN_92] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_109] = [__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[109].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const OUT_108: usize = 10; +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_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __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 __ret: [G; OUT_108] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; record.function_queries[108].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_109: usize = 9; +const IN_109: usize = 9; +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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_109] = [__v_11, __v_0]; record.function_queries[109].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_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 __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_109] = { let __args: [G; IN_109] = [__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(109, (&__args[..]))?) { [G::ZERO; OUT_109] } else { let (__hash, __hit) = record.function_queries[109].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[109].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { (*(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109])) }; __ret }, _ => { aiur_fn_109::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __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_109] = [__v_32, __v_30]; record.function_queries[109].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } const INPUT_SIZE_110: usize = 1; const IN_110: usize = 1; -const OUT_110: usize = 1; -fn aiur_fn_110(inp: [G; IN_110], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_110] = [__v_1]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_110] = [__v_1]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_110] = [__v_1]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_110] = [__v_1]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const OUT_110: usize = 45; +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_80] = { let __args: [G; IN_80] = [__v_0]; 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_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_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_84] = { let __args: [G; IN_84] = [__v_22]; 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_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_84] = { let __args: [G; IN_84] = [__v_31]; 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_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_84] = { let __args: [G; IN_84] = [__v_40]; 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_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_84] = { let __args: [G; IN_84] = [__v_49]; 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_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_95] = { let __args: [G; IN_95] = [__v_58]; 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_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_60]; 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_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_109] = { let __args: [G; IN_109] = [__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(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_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __ret: [G; OUT_110] = [__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[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 = 11; -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_79] = { let __args: [G; IN_79] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; 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_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_92] = { let __args: [G; IN_92] = [__v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_111] = [__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[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const OUT_111: usize = 0; +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 = 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_111] = []; record.function_queries[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_112: usize = 1; const IN_112: usize = 1; -const OUT_112: usize = 35; -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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; 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_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_81] = { let __args: [G; IN_81] = [__v_11]; 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_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_81] = { let __args: [G; IN_81] = [__v_20]; 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_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_81] = { let __args: [G; IN_81] = [__v_29]; 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_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_92] = { let __args: [G; IN_92] = [__v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __ret: [G; OUT_112] = [__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[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_113: usize = 9; -const IN_113: usize = 9; -const OUT_113: usize = 2; -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 __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_113] = [__v_11, __v_0]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __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_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_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_113] = { let __args: [G; IN_113] = [__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(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_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_113] = [__v_56, __v_54]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +const OUT_112: usize = 11; +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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __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_95] = { let __args: [G; IN_95] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_112] = [__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[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_113: usize = 1; +const IN_113: usize = 1; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_113] = [__v_1]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_113] = [__v_1]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_113] = [__v_1]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_113] = [__v_1]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_114: usize = 1; const IN_114: usize = 1; -const OUT_114: usize = 28; -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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __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_81] = { let __args: [G; IN_81] = [__v_2]; 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_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_81] = { let __args: [G; IN_81] = [__v_19]; 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_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_81] = { let __args: [G; IN_81] = [__v_28]; 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_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_92] = { let __args: [G; IN_92] = [__v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_39]; 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_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_113] = { let __args: [G; IN_113] = [__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(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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_114] = [__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[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const OUT_114: usize = 11; +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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_114] = [__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[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 = 10; -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_81] = { let __args: [G; IN_81] = [__v_0]; 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_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_96] = { let __args: [G; IN_96] = [__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 __ret: [G; OUT_115] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; 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 = 18; -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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; 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_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_81] = { let __args: [G; IN_81] = [__v_9]; 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 __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_96] = { let __args: [G; IN_96] = [__v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_116] = [__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[116].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const OUT_115: usize = 35; +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_80] = { let __args: [G; IN_80] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __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_84] = { let __args: [G; IN_84] = [__v_11]; 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_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_84] = { let __args: [G; IN_84] = [__v_20]; 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_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_84] = { let __args: [G; IN_84] = [__v_29]; 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_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_95] = { let __args: [G; IN_95] = [__v_38]; 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_39: G = __r_arr[0]; let __v_40: 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, __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[115].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_116: usize = 9; +const IN_116: usize = 9; +const OUT_116: usize = 2; +fn aiur_fn_116(inp: [G; IN_116], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_116] = [__v_11, __v_0]; record.function_queries[116].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; 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 __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_116] = { let __args: [G; IN_116] = [__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(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_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_116] = [__v_56, __v_54]; record.function_queries[116].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } const INPUT_SIZE_117: usize = 1; const IN_117: usize = 1; -const OUT_117: usize = 46; -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_79] = { let __args: [G; IN_79] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_2]; 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_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_117] = [__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[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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 = __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_117] = [__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[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; 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_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_117] = [__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[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_118: usize = 9; -const IN_118: usize = 9; -const OUT_118: usize = 2; -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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_118] = [__v_11, __v_0]; record.function_queries[118].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0]; 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_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_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_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_118] = { let __args: [G; IN_118] = [__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(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_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_118] = [__v_67, __v_65]; record.function_queries[118].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_119: usize = 2; -const IN_119: usize = 2; -const OUT_119: usize = 46; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; 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_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_119] = [__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[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; 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_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_119] = [__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[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { 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_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_119] = [__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[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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_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_119] = [__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[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { 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_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_119] = [__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[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { 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 = G::from_u64(5); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_119] = [__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[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { 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 = G::from_u64(6); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_119] = [__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[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { 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 = G::from_u64(7); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_119] = [__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[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_120: usize = 10; -const IN_120: usize = 10; +const OUT_117: usize = 28; +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_80] = { let __args: [G; IN_80] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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 __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_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_84] = { let __args: [G; IN_84] = [__v_19]; 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_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_84] = { let __args: [G; IN_84] = [__v_28]; 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_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_95] = { let __args: [G; IN_95] = [__v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_39]; 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_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_116] = { let __args: [G; IN_116] = [__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(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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_117] = [__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[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 = 10; +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_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __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_99] = { let __args: [G; IN_99] = [__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 __ret: [G; OUT_118] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; record.function_queries[118].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_119: usize = 1; +const IN_119: usize = 1; +const OUT_119: usize = 18; +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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_9]; let __cu = unconstrained; 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 __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_99] = { let __args: [G; IN_99] = [__v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_119] = [__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[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_120: usize = 1; +const IN_120: usize = 1; const OUT_120: usize = 46; -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 __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_118] = { let __args: [G; IN_118] = [__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(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 = G::from_u64(8); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_120] = [__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[120].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: tag4 size exceeds a single byte".to_string()) }); } let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_9]; 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 __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_120] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_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[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_121: usize = 1; -const IN_121: usize = 1; -const OUT_121: usize = 49; -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_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 = __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_118] = { let __args: [G; IN_118] = [__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(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_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: tag4 size exceeds a single byte".to_string()) }); } let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __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_81] = { let __args: [G; IN_81] = [__v_56]; 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_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_97] = { let __args: [G; IN_97] = [__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(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_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_67]; 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_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_99] = { let __args: [G; IN_99] = [__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(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_77: G = __r_arr[0]; let __v_78: G = __r_arr[1]; let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_78]; 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_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_98] = { let __args: [G; IN_98] = [__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(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_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; let __ret: [G; OUT_121] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_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[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 = 2; -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 __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_122] = { let __args: [G; IN_122] = [__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 __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_6, __v_3]; 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 __ret: [G; OUT_122] = [__v_5, __v_7]; record.function_queries[122].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_122] = [__v_0, __v_6]; 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 = 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 __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_123] = [__v_14]; record.function_queries[123].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_16] = { let __args: [G; IN_16] = [__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(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_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_123] = [__v_23]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_10]; 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_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_123] = [__v_24]; 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 = 3; -const IN_124: usize = 3; -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 __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_124] = [__v_1]; record.function_queries[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1]; 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 __ret: [G; OUT_124] = [__v_13]; record.function_queries[124].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_124] = [__v_0]; record.function_queries[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_23: G = __r_arr[0]; let __ret: [G; OUT_124] = [__v_23]; record.function_queries[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 0u64 => { 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, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; 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_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_16] = { let __args: [G; IN_16] = [__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(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_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_124] = { let __args: [G; IN_124] = [__v_12, __v_22, __v_42]; 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_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_124] = [__v_44]; record.function_queries[124].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_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 __v_2: G = G::from_u64(0); let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_125] = [__v_3]; record.function_queries[125].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_126: usize = 16; -const IN_126: usize = 16; -const OUT_126: usize = 9; -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]; 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_126] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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_80] = { let __args: [G; IN_80] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; 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_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_120] = [__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[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__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 = __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_120] = [__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[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { 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 = __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_120] = [__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[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_121: usize = 9; +const IN_121: usize = 9; +const OUT_121: usize = 2; +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 = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_121] = [__v_11, __v_0]; record.function_queries[121].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, (&__args[..]))?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { (*(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120])) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_121] = { let __args: [G; IN_121] = [__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(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_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_121] = [__v_67, __v_65]; record.function_queries[121].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +const INPUT_SIZE_122: usize = 2; +const IN_122: usize = 2; +const OUT_122: usize = 46; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; 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_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_122] = [__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[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { 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 = __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_122] = [__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[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; 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_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_122] = [__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[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { 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 __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_122] = [__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[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__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_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_122] = [__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[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; 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_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_122] = [__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[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; 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_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_122] = [__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[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; 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_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_122] = [__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[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_123: usize = 10; +const IN_123: usize = 10; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; 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_121] = { let __args: [G; IN_121] = [__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(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_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_123] = [__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[123].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_122] = { let __args: [G; IN_122] = [__v_1, __v_9]; 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 __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_123] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_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[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_124: usize = 1; +const IN_124: usize = 1; +const OUT_124: usize = 49; +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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; 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_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_121] = { let __args: [G; IN_121] = [__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(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_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_122] = { let __args: [G; IN_122] = [__v_2, __v_10]; 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 = __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_84] = { let __args: [G; IN_84] = [__v_56]; 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_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_100] = { let __args: [G; IN_100] = [__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(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_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_67]; 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_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_102] = { let __args: [G; IN_102] = [__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(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_77: G = __r_arr[0]; let __v_78: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_78]; 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_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_101] = { let __args: [G; IN_101] = [__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(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_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; let __ret: [G; OUT_124] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_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[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_125: usize = 1; +const IN_125: usize = 1; +const OUT_125: usize = 2; +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 __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_125] = { let __args: [G; IN_125] = [__v_2]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_6, __v_3]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_125] = [__v_5, __v_7]; record.function_queries[125].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_125] = [__v_0, __v_6]; record.function_queries[125].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_126: usize = 1; +const IN_126: usize = 1; +const OUT_126: usize = 1; +fn aiur_fn_126(inp: [G; IN_126], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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_126] = [__v_14]; record.function_queries[126].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_126] = [__v_23]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10]; 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_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_126] = [__v_24]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_127: usize = 3; const IN_127: usize = 3; -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 __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_127] = [__v_24, __v_2]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_127] = [__v_25, __v_2]; record.function_queries[127].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_127] = [__v_25, __v_24]; record.function_queries[127].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_127] = [__v_0, __v_23]; record.function_queries[127].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_126] = { let __args: [G; IN_126] = [__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(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_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_127] = { let __args: [G; IN_127] = [__v_12, __v_34, __v_33]; 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_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_127] = [__v_37, __v_36]; 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_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(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_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_126] = { let __args: [G; IN_126] = [__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(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_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_127] = { let __args: [G; IN_127] = [__v_12, __v_22, __v_42]; 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_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_127] = [__v_45, __v_44]; record.function_queries[127].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_128: usize = 1; -const IN_128: 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 __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_127] = [__v_1]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1]; 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 __ret: [G; OUT_127] = [__v_13]; record.function_queries[127].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_127] = [__v_0]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_23: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_23]; record.function_queries[127].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_127] = { let __args: [G; IN_127] = [__v_12, __v_22, __v_42]; 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_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_127] = [__v_44]; record.function_queries[127].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_128: usize = 2; +const IN_128: usize = 2; 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 __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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_128] = [__v_1]; 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 = 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 __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_129] = [__v_12, __v_13]; record.function_queries[129].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_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_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_129] = [__v_15, __v_13]; 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 = 1; -const IN_130: usize = 1; -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 __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_130] = [__v_12]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_10]; 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_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_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_130] = [__v_24]; record.function_queries[130].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_130] = [__v_26]; record.function_queries[130].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_130] = [__v_23]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_131: usize = 2; -const IN_131: usize = 2; +fn aiur_fn_128(inp: [G; IN_128], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_128] = [__v_3]; record.function_queries[128].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_129: usize = 16; +const IN_129: usize = 16; +const OUT_129: usize = 9; +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 __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_129] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; record.function_queries[129].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_130: usize = 3; +const IN_130: usize = 3; +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 __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_130] = [__v_24, __v_2]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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_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_130] = [__v_25, __v_2]; record.function_queries[130].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_130] = [__v_25, __v_24]; record.function_queries[130].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_130] = [__v_0, __v_23]; record.function_queries[130].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_129] = { let __args: [G; IN_129] = [__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(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 __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_130] = { let __args: [G; IN_130] = [__v_12, __v_34, __v_33]; 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_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_130] = [__v_37, __v_36]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 0u64 => { let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__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(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 = __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_129] = { let __args: [G; IN_129] = [__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(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_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 = __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_130] = [__v_45, __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 = 1; +const IN_131: usize = 1; 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_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2]; 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_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_131] = [__v_6]; record.function_queries[131].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_131] = [__v_5]; record.function_queries[131].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.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 __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_132] = [__v_13]; record.function_queries[132].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_132] = [__v_13]; record.function_queries[132].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_131] = [__v_1]; record.function_queries[131].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_132: usize = 1; +const IN_132: usize = 1; +const OUT_132: usize = 2; +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 __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_132] = [__v_12, __v_13]; record.function_queries[132].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_132] = { let __args: [G; IN_132] = [__v_10]; 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_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_132] = [__v_15, __v_13]; record.function_queries[132].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_133: usize = 1; const IN_133: usize = 1; 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 = 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_131] = { let __args: [G; IN_131] = [__v_0, __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_5: G = __r_arr[0]; let __ret: [G; OUT_133] = [__v_5]; record.function_queries[133].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __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_133] = [__v_12]; record.function_queries[133].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_10]; 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_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_133] = [__v_24]; record.function_queries[133].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_133] = [__v_26]; record.function_queries[133].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_133] = [__v_23]; record.function_queries[133].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_134: usize = 2; const IN_134: usize = 2; -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 = 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_134] = [__v_0, __v_1]; record.function_queries[134].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_134] = { let __args: [G; IN_134] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_134] = [__v_8, __v_9]; record.function_queries[134].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_135: usize = 16; -const IN_135: usize = 16; -const OUT_135: usize = 16; -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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 = G::from_u64(65536); let __v_45: G = (__v_16 * __v_37); let __v_46: G = (__v_44 * __v_38); let __v_47: G = (__v_45 + __v_46); let __v_48: G = (__v_36 + __v_47); let __v_49: G = (__v_44 * __v_48); let __v_50: G = (__v_43 + __v_49); let __v_51: G = (__v_34 + __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_53 + __v_48); let __v_55: G = (__v_52 + __v_54); let __gb: [u8; 8] = __v_55.as_canonical_u64().to_le_bytes(); let __v_56: G = G::from_u8(__gb[0]); let __v_57: G = G::from_u8(__gb[1]); let __v_58: G = G::from_u8(__gb[2]); let __v_59: G = G::from_u8(__gb[3]); let __v_60: G = G::from_u8(__gb[4]); let __v_61: G = G::from_u8(__gb[5]); let __v_62: G = G::from_u8(__gb[6]); let __v_63: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_56; let __vj = __v_57; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } 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_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_64: G = (__v_16 * __v_57); let __v_65: G = (__v_16 * __v_59); let __v_66: G = (__v_44 * __v_60); let __v_67: G = (__v_65 + __v_66); let __v_68: G = (__v_58 + __v_67); let __v_69: G = (__v_44 * __v_68); let __v_70: G = (__v_64 + __v_69); let __v_71: G = (__v_56 + __v_70); if (__v_55 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_72: G = (__v_18 * __v_28); let __v_73: G = (__v_22 * __v_24); let __v_74: G = (__v_26 * __v_20); let __v_75: G = (__v_74 + __v_68); let __v_76: G = (__v_73 + __v_75); let __v_77: G = (__v_72 + __v_76); let __gb: [u8; 8] = __v_77.as_canonical_u64().to_le_bytes(); let __v_78: G = G::from_u8(__gb[0]); let __v_79: G = G::from_u8(__gb[1]); let __v_80: G = G::from_u8(__gb[2]); let __v_81: G = G::from_u8(__gb[3]); let __v_82: G = G::from_u8(__gb[4]); let __v_83: G = G::from_u8(__gb[5]); let __v_84: G = G::from_u8(__gb[6]); let __v_85: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_78; let __vj = __v_79; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_80; let __vj = __v_81; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_82; let __vj = __v_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_86: G = (__v_16 * __v_79); let __v_87: G = (__v_16 * __v_81); let __v_88: G = (__v_44 * __v_82); let __v_89: G = (__v_87 + __v_88); let __v_90: G = (__v_80 + __v_89); let __v_91: G = (__v_44 * __v_90); let __v_92: G = (__v_86 + __v_91); let __v_93: G = (__v_78 + __v_92); if (__v_77 != __v_93) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_93.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_94: G = (__v_18 * __v_32); let __v_95: G = (__v_22 * __v_28); let __v_96: G = (__v_26 * __v_24); let __v_97: G = (__v_30 * __v_20); let __v_98: G = (__v_97 + __v_90); let __v_99: G = (__v_96 + __v_98); let __v_100: G = (__v_95 + __v_99); let __v_101: G = (__v_94 + __v_100); let __gb: [u8; 8] = __v_101.as_canonical_u64().to_le_bytes(); let __v_102: G = G::from_u8(__gb[0]); let __v_103: G = G::from_u8(__gb[1]); let __v_104: G = G::from_u8(__gb[2]); let __v_105: G = G::from_u8(__gb[3]); let __v_106: G = G::from_u8(__gb[4]); let __v_107: G = G::from_u8(__gb[5]); let __v_108: G = G::from_u8(__gb[6]); let __v_109: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_102; let __vj = __v_103; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } 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_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_110: G = (__v_16 * __v_103); let __v_111: G = (__v_16 * __v_105); let __v_112: G = (__v_44 * __v_106); let __v_113: G = (__v_111 + __v_112); let __v_114: G = (__v_104 + __v_113); let __v_115: G = (__v_44 * __v_114); let __v_116: G = (__v_110 + __v_115); let __v_117: G = (__v_102 + __v_116); if (__v_101 != __v_117) { return Err(ExecError::AssertEqMismatch { lhs: __v_101.as_canonical_u64(), rhs: __v_117.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_118: G = (__v_22 * __v_32); let __v_119: G = (__v_26 * __v_28); let __v_120: G = (__v_30 * __v_24); let __v_121: G = (__v_120 + __v_114); let __v_122: G = (__v_119 + __v_121); let __v_123: G = (__v_118 + __v_122); let __gb: [u8; 8] = __v_123.as_canonical_u64().to_le_bytes(); let __v_124: G = G::from_u8(__gb[0]); let __v_125: G = G::from_u8(__gb[1]); let __v_126: G = G::from_u8(__gb[2]); let __v_127: G = G::from_u8(__gb[3]); let __v_128: G = G::from_u8(__gb[4]); let __v_129: G = G::from_u8(__gb[5]); let __v_130: G = G::from_u8(__gb[6]); let __v_131: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_124; let __vj = __v_125; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_126; let __vj = __v_127; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_128; 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_132: G = (__v_16 * __v_125); let __v_133: G = (__v_16 * __v_127); let __v_134: G = (__v_44 * __v_128); let __v_135: G = (__v_133 + __v_134); let __v_136: G = (__v_126 + __v_135); let __v_137: G = (__v_44 * __v_136); let __v_138: G = (__v_132 + __v_137); let __v_139: G = (__v_124 + __v_138); if (__v_123 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_140: G = (__v_26 * __v_32); let __v_141: G = (__v_30 * __v_28); let __v_142: G = (__v_141 + __v_136); let __v_143: G = (__v_140 + __v_142); let __gb: [u8; 8] = __v_143.as_canonical_u64().to_le_bytes(); let __v_144: G = G::from_u8(__gb[0]); let __v_145: G = G::from_u8(__gb[1]); let __v_146: G = G::from_u8(__gb[2]); let __v_147: G = G::from_u8(__gb[3]); let __v_148: G = G::from_u8(__gb[4]); let __v_149: G = G::from_u8(__gb[5]); let __v_150: G = G::from_u8(__gb[6]); let __v_151: G = G::from_u8(__gb[7]); 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)); } if (!unconstrained) { let __vi = __v_148; 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_152: G = (__v_16 * __v_145); let __v_153: G = (__v_16 * __v_147); let __v_154: G = (__v_44 * __v_148); let __v_155: G = (__v_153 + __v_154); let __v_156: G = (__v_146 + __v_155); let __v_157: G = (__v_44 * __v_156); let __v_158: G = (__v_152 + __v_157); let __v_159: G = (__v_144 + __v_158); if (__v_143 != __v_159) { return Err(ExecError::AssertEqMismatch { lhs: __v_143.as_canonical_u64(), rhs: __v_159.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_160: G = (__v_30 * __v_32); let __v_161: G = (__v_160 + __v_156); let __gb: [u8; 8] = __v_161.as_canonical_u64().to_le_bytes(); let __v_162: G = G::from_u8(__gb[0]); let __v_163: G = G::from_u8(__gb[1]); let __v_164: G = G::from_u8(__gb[2]); let __v_165: G = G::from_u8(__gb[3]); let __v_166: G = G::from_u8(__gb[4]); let __v_167: G = G::from_u8(__gb[5]); let __v_168: G = G::from_u8(__gb[6]); let __v_169: G = G::from_u8(__gb[7]); 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)); } if (!unconstrained) { let __vi = __v_166; 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_170: G = (__v_16 * __v_163); let __v_171: G = (__v_16 * __v_165); let __v_172: G = (__v_44 * __v_166); let __v_173: G = (__v_171 + __v_172); let __v_174: G = (__v_164 + __v_173); let __v_175: G = (__v_44 * __v_174); let __v_176: G = (__v_170 + __v_175); let __v_177: G = (__v_162 + __v_176); if (__v_161 != __v_177) { return Err(ExecError::AssertEqMismatch { lhs: __v_161.as_canonical_u64(), rhs: __v_177.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } if (__v_166 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_166.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_135] = [__v_34, __v_35, __v_56, __v_57, __v_78, __v_79, __v_102, __v_103, __v_124, __v_125, __v_144, __v_145, __v_162, __v_163, __v_164, __v_165]; record.function_queries[135].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const OUT_134: usize = 1; +fn aiur_fn_134(inp: [G; IN_134], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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 __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_134] = [__v_6]; record.function_queries[134].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_5]; record.function_queries[134].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.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 __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __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_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_135] = [__v_13]; record.function_queries[135].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_135] = [__v_13]; record.function_queries[135].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_136: usize = 1; const IN_136: usize = 1; -const OUT_136: usize = 5; -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 __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 = G::from_u64(65536); let __v_13: G = (__v_10 * __v_4); let __v_14: G = (__v_12 * __v_5); let __v_15: G = (__v_13 + __v_14); let __v_16: G = (__v_3 + __v_15); let __v_17: G = (__v_12 * __v_16); let __v_18: G = (__v_11 + __v_17); let __v_19: G = (__v_1 + __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_136] = [__v_1, __v_2, __v_3, __v_4, __v_5]; record.function_queries[136].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = 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_134] = { let __args: [G; IN_134] = [__v_0, __v_4]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_136] = [__v_5]; record.function_queries[136].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_137: usize = 2; const IN_137: usize = 2; -const OUT_137: usize = 1; -fn aiur_fn_137(inp: [G; IN_137], 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(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_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_3, __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_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); }) } -const INPUT_SIZE_138: usize = 4; -const IN_138: usize = 4; -const OUT_138: usize = 1; -fn aiur_fn_138(inp: [G; IN_138], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_138] = [__v_2]; record.function_queries[138].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__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(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_140] = { let __args: [G; IN_140] = [__v_15, __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_16: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __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 __v_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_13, __v_1, __v_17, __v_19]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_20]; record.function_queries[138].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_139: usize = 17; -const IN_139: usize = 17; -const OUT_139: usize = 1; -fn aiur_fn_139(inp: [G; IN_139], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_7] = { let __args: [G; IN_7] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_139] = [__v_29]; record.function_queries[139].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_139] = [__v_31]; record.function_queries[139].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_135] = { let __args: [G; IN_135] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; 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_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_16] = { let __args: [G; IN_16] = [__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(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_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_139] = { let __args: [G; IN_139] = [__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(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_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_139] = [__v_54]; record.function_queries[139].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(0); let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; 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_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_139] = { let __args: [G; IN_139] = [__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(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_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_139] = [__v_62]; record.function_queries[139].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } +const OUT_137: usize = 2; +fn aiur_fn_137(inp: [G; IN_137], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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_137] = [__v_0, __v_1]; record.function_queries[137].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_137] = { let __args: [G; IN_137] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_137] = [__v_8, __v_9]; record.function_queries[137].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_138: usize = 16; +const IN_138: usize = 16; +const OUT_138: usize = 16; +fn aiur_fn_138(inp: [G; IN_138], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 = G::from_u64(65536); let __v_45: G = (__v_16 * __v_37); let __v_46: G = (__v_44 * __v_38); let __v_47: G = (__v_45 + __v_46); let __v_48: G = (__v_36 + __v_47); let __v_49: G = (__v_44 * __v_48); let __v_50: G = (__v_43 + __v_49); let __v_51: G = (__v_34 + __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_53 + __v_48); let __v_55: G = (__v_52 + __v_54); let __gb: [u8; 8] = __v_55.as_canonical_u64().to_le_bytes(); let __v_56: G = G::from_u8(__gb[0]); let __v_57: G = G::from_u8(__gb[1]); let __v_58: G = G::from_u8(__gb[2]); let __v_59: G = G::from_u8(__gb[3]); let __v_60: G = G::from_u8(__gb[4]); let __v_61: G = G::from_u8(__gb[5]); let __v_62: G = G::from_u8(__gb[6]); let __v_63: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_56; let __vj = __v_57; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } 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_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_64: G = (__v_16 * __v_57); let __v_65: G = (__v_16 * __v_59); let __v_66: G = (__v_44 * __v_60); let __v_67: G = (__v_65 + __v_66); let __v_68: G = (__v_58 + __v_67); let __v_69: G = (__v_44 * __v_68); let __v_70: G = (__v_64 + __v_69); let __v_71: G = (__v_56 + __v_70); if (__v_55 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_72: G = (__v_18 * __v_28); let __v_73: G = (__v_22 * __v_24); let __v_74: G = (__v_26 * __v_20); let __v_75: G = (__v_74 + __v_68); let __v_76: G = (__v_73 + __v_75); let __v_77: G = (__v_72 + __v_76); let __gb: [u8; 8] = __v_77.as_canonical_u64().to_le_bytes(); let __v_78: G = G::from_u8(__gb[0]); let __v_79: G = G::from_u8(__gb[1]); let __v_80: G = G::from_u8(__gb[2]); let __v_81: G = G::from_u8(__gb[3]); let __v_82: G = G::from_u8(__gb[4]); let __v_83: G = G::from_u8(__gb[5]); let __v_84: G = G::from_u8(__gb[6]); let __v_85: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_78; let __vj = __v_79; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_80; let __vj = __v_81; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_82; let __vj = __v_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_86: G = (__v_16 * __v_79); let __v_87: G = (__v_16 * __v_81); let __v_88: G = (__v_44 * __v_82); let __v_89: G = (__v_87 + __v_88); let __v_90: G = (__v_80 + __v_89); let __v_91: G = (__v_44 * __v_90); let __v_92: G = (__v_86 + __v_91); let __v_93: G = (__v_78 + __v_92); if (__v_77 != __v_93) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_93.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_94: G = (__v_18 * __v_32); let __v_95: G = (__v_22 * __v_28); let __v_96: G = (__v_26 * __v_24); let __v_97: G = (__v_30 * __v_20); let __v_98: G = (__v_97 + __v_90); let __v_99: G = (__v_96 + __v_98); let __v_100: G = (__v_95 + __v_99); let __v_101: G = (__v_94 + __v_100); let __gb: [u8; 8] = __v_101.as_canonical_u64().to_le_bytes(); let __v_102: G = G::from_u8(__gb[0]); let __v_103: G = G::from_u8(__gb[1]); let __v_104: G = G::from_u8(__gb[2]); let __v_105: G = G::from_u8(__gb[3]); let __v_106: G = G::from_u8(__gb[4]); let __v_107: G = G::from_u8(__gb[5]); let __v_108: G = G::from_u8(__gb[6]); let __v_109: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_102; let __vj = __v_103; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } 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_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_110: G = (__v_16 * __v_103); let __v_111: G = (__v_16 * __v_105); let __v_112: G = (__v_44 * __v_106); let __v_113: G = (__v_111 + __v_112); let __v_114: G = (__v_104 + __v_113); let __v_115: G = (__v_44 * __v_114); let __v_116: G = (__v_110 + __v_115); let __v_117: G = (__v_102 + __v_116); if (__v_101 != __v_117) { return Err(ExecError::AssertEqMismatch { lhs: __v_101.as_canonical_u64(), rhs: __v_117.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_118: G = (__v_22 * __v_32); let __v_119: G = (__v_26 * __v_28); let __v_120: G = (__v_30 * __v_24); let __v_121: G = (__v_120 + __v_114); let __v_122: G = (__v_119 + __v_121); let __v_123: G = (__v_118 + __v_122); let __gb: [u8; 8] = __v_123.as_canonical_u64().to_le_bytes(); let __v_124: G = G::from_u8(__gb[0]); let __v_125: G = G::from_u8(__gb[1]); let __v_126: G = G::from_u8(__gb[2]); let __v_127: G = G::from_u8(__gb[3]); let __v_128: G = G::from_u8(__gb[4]); let __v_129: G = G::from_u8(__gb[5]); let __v_130: G = G::from_u8(__gb[6]); let __v_131: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_124; let __vj = __v_125; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_126; let __vj = __v_127; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_128; 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_132: G = (__v_16 * __v_125); let __v_133: G = (__v_16 * __v_127); let __v_134: G = (__v_44 * __v_128); let __v_135: G = (__v_133 + __v_134); let __v_136: G = (__v_126 + __v_135); let __v_137: G = (__v_44 * __v_136); let __v_138: G = (__v_132 + __v_137); let __v_139: G = (__v_124 + __v_138); if (__v_123 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_140: G = (__v_26 * __v_32); let __v_141: G = (__v_30 * __v_28); let __v_142: G = (__v_141 + __v_136); let __v_143: G = (__v_140 + __v_142); let __gb: [u8; 8] = __v_143.as_canonical_u64().to_le_bytes(); let __v_144: G = G::from_u8(__gb[0]); let __v_145: G = G::from_u8(__gb[1]); let __v_146: G = G::from_u8(__gb[2]); let __v_147: G = G::from_u8(__gb[3]); let __v_148: G = G::from_u8(__gb[4]); let __v_149: G = G::from_u8(__gb[5]); let __v_150: G = G::from_u8(__gb[6]); let __v_151: G = G::from_u8(__gb[7]); 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)); } if (!unconstrained) { let __vi = __v_148; 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_152: G = (__v_16 * __v_145); let __v_153: G = (__v_16 * __v_147); let __v_154: G = (__v_44 * __v_148); let __v_155: G = (__v_153 + __v_154); let __v_156: G = (__v_146 + __v_155); let __v_157: G = (__v_44 * __v_156); let __v_158: G = (__v_152 + __v_157); let __v_159: G = (__v_144 + __v_158); if (__v_143 != __v_159) { return Err(ExecError::AssertEqMismatch { lhs: __v_143.as_canonical_u64(), rhs: __v_159.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_160: G = (__v_30 * __v_32); let __v_161: G = (__v_160 + __v_156); let __gb: [u8; 8] = __v_161.as_canonical_u64().to_le_bytes(); let __v_162: G = G::from_u8(__gb[0]); let __v_163: G = G::from_u8(__gb[1]); let __v_164: G = G::from_u8(__gb[2]); let __v_165: G = G::from_u8(__gb[3]); let __v_166: G = G::from_u8(__gb[4]); let __v_167: G = G::from_u8(__gb[5]); let __v_168: G = G::from_u8(__gb[6]); let __v_169: G = G::from_u8(__gb[7]); 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)); } if (!unconstrained) { let __vi = __v_166; 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_170: G = (__v_16 * __v_163); let __v_171: G = (__v_16 * __v_165); let __v_172: G = (__v_44 * __v_166); let __v_173: G = (__v_171 + __v_172); let __v_174: G = (__v_164 + __v_173); let __v_175: G = (__v_44 * __v_174); let __v_176: G = (__v_170 + __v_175); let __v_177: G = (__v_162 + __v_176); if (__v_161 != __v_177) { return Err(ExecError::AssertEqMismatch { lhs: __v_161.as_canonical_u64(), rhs: __v_177.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } if (__v_166 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_166.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_138] = [__v_34, __v_35, __v_56, __v_57, __v_78, __v_79, __v_102, __v_103, __v_124, __v_125, __v_144, __v_145, __v_162, __v_163, __v_164, __v_165]; 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 = 5; +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 __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 = G::from_u64(65536); let __v_13: G = (__v_10 * __v_4); let __v_14: G = (__v_12 * __v_5); let __v_15: G = (__v_13 + __v_14); let __v_16: G = (__v_3 + __v_15); let __v_17: G = (__v_12 * __v_16); let __v_18: G = (__v_11 + __v_17); let __v_19: G = (__v_1 + __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_139] = [__v_1, __v_2, __v_3, __v_4, __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 = 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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_140] = [__v_0]; record.function_queries[140].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_140] = { let __args: [G; IN_140] = [__v_3, __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_6: G = __r_arr[0]; let __ret: [G; OUT_140] = [__v_6]; record.function_queries[140].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_141: usize = 1; -const IN_141: 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 = 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_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_3, __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_5: G = __r_arr[0]; let __ret: [G; OUT_140] = [__v_5]; record.function_queries[140].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_141: usize = 4; +const IN_141: usize = 4; 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 __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0]; 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_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_141] = [__v_12]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(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 = 2; -const IN_142: usize = 2; -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 __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_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 __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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_5: 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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 __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_8: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_8, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0]; 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_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_141] = { let __args: [G; IN_141] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_5]; 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_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_142] = [__v_5, __v_7]; record.function_queries[142].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_7]; 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 __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_13, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(132, (&__args[..]))?) { [G::ZERO; OUT_132] } else { let (__hash, __hit) = record.function_queries[132].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[132].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { (*(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132])) }; __ret }, _ => { aiur_fn_132::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_142] = [__v_5, __v_7]; record.function_queries[142].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }) } +fn aiur_fn_141(inp: [G; IN_141], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __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_141] = [__v_2]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__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(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_15: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_15, __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_16: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2, __v_16]; 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_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_141] = { let __args: [G; IN_141] = [__v_13, __v_1, __v_17, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_20]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_142: usize = 17; +const IN_142: usize = 17; +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]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_142] = [__v_29]; record.function_queries[142].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_142] = [__v_31]; record.function_queries[142].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_138] = { let __args: [G; IN_138] = [__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(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]; 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_142] = { let __args: [G; IN_142] = [__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(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_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_142] = [__v_54]; record.function_queries[142].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_142] = { let __args: [G; IN_142] = [__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(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_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_142] = [__v_62]; record.function_queries[142].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } 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 __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __ret: [G; OUT_143] = [__v_2]; record.function_queries[143].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_144: usize = 2; -const IN_144: 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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_143] = [__v_0]; record.function_queries[143].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_143] = { let __args: [G; IN_143] = [__v_3, __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_6: G = __r_arr[0]; let __ret: [G; OUT_143] = [__v_6]; record.function_queries[143].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_144: usize = 1; +const IN_144: usize = 1; const OUT_144: usize = 1; -fn aiur_fn_144(inp: [G; IN_144], 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 __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __ret: [G; OUT_144] = [__v_3]; record.function_queries[144].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_144(inp: [G; IN_144], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0]; 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_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_144] = [__v_12]; record.function_queries[144].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(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 = 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]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_145] = [__v_0]; record.function_queries[145].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __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_3: G = __r_arr[0]; let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_145] = [__v_4]; record.function_queries[145].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const OUT_145: usize = 2; +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 __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_131] = { let __args: [G; IN_131] = [__v_2]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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_5: G = __r_arr[0]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__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_6: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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 __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_8: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_8, __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_9: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0]; 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_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_144] = { let __args: [G; IN_144] = [__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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_5]; 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_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_145] = [__v_5, __v_7]; record.function_queries[145].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_7]; 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 __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_13, __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_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_145] = [__v_5, __v_7]; record.function_queries[145].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.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]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_146] = [__v_6]; record.function_queries[146].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_142] = { let __args: [G; IN_142] = [__v_1, __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 __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_0]; 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]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_8]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__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_13: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_9]; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_146] = [__v_13]; record.function_queries[146].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_15]; record.function_queries[146].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_147: usize = 16; -const IN_147: usize = 16; -const OUT_147: usize = 8; -fn aiur_fn_147(inp: [G; IN_147], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; 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_147] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[147].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_148: usize = 16; -const IN_148: usize = 16; -const OUT_148: usize = 8; -fn aiur_fn_148(inp: [G; IN_148], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; 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_148] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[148].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_149: usize = 16; -const IN_149: usize = 16; -const OUT_149: usize = 8; -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]; 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_149] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; 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 __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_150] = [__v_13]; record.function_queries[150].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_150] = [__v_23]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__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(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]; 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_150] = { let __args: [G; IN_150] = [__v_11, __v_21]; 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_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_150] = [__v_32]; record.function_queries[150].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_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 __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_151] = [__v_1]; record.function_queries[151].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_151] = [__v_0]; record.function_queries[151].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__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(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_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_151] = { let __args: [G; IN_151] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __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_151] = [__v_32]; record.function_queries[151].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_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 __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_152] = [__v_1]; record.function_queries[152].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_152] = [__v_0]; record.function_queries[152].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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(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 __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_152] = { let __args: [G; IN_152] = [__v_11, __v_21]; 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_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_152] = [__v_32]; record.function_queries[152].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __ret: [G; OUT_146] = [__v_2]; record.function_queries[146].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __ret: [G; OUT_147] = [__v_3]; 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 = 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 __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_148] = [__v_0]; record.function_queries[148].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __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_3: G = __r_arr[0]; let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_4]; record.function_queries[148].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.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_144] = { let __args: [G; IN_144] = [__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_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_149] = [__v_6]; record.function_queries[149].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_145] = { let __args: [G; IN_145] = [__v_1, __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 __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_0]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_8]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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_13: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_9]; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_149] = [__v_13]; record.function_queries[149].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_149] = [__v_15]; record.function_queries[149].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_150: usize = 16; +const IN_150: usize = 16; +const OUT_150: usize = 8; +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]; 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_150] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_151: usize = 16; +const IN_151: usize = 16; +const OUT_151: usize = 8; +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]; 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_151] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[151].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_152: usize = 16; +const IN_152: usize = 16; +const OUT_152: usize = 8; +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]; 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_152] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[152].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_153: usize = 2; const IN_153: usize = 2; const OUT_153: usize = 1; -fn aiur_fn_153(inp: [G; IN_153], 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 = 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_146] = { let __args: [G; IN_146] = [__v_6, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_153] = [__v_8]; record.function_queries[153].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_153(inp: [G; IN_153], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __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_153] = [__v_13]; record.function_queries[153].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_153] = [__v_23]; record.function_queries[153].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__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(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_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_153] = { let __args: [G; IN_153] = [__v_11, __v_21]; 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_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_153] = [__v_32]; record.function_queries[153].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_154: usize = 2; const IN_154: usize = 2; 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 = 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_146] = { let __args: [G; IN_146] = [__v_6, __v_1]; 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_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_154] = [__v_8]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_155: usize = 0; -const IN_155: usize = 0; +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 __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_154] = [__v_1]; record.function_queries[154].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_154] = [__v_0]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__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(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __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_154] = { let __args: [G; IN_154] = [__v_11, __v_21]; 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 __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_154] = [__v_32]; record.function_queries[154].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_155: usize = 2; +const IN_155: usize = 2; 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 = G::from_u64(238); let __v_1: G = G::from_u64(178); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(38); let __v_4: G = G::from_u64(143); let __v_5: G = G::from_u64(246); let __v_6: G = G::from_u64(208); let __v_7: G = G::from_u64(233); let __v_8: G = G::from_u64(118); let __v_9: G = G::from_u64(77); let __v_10: G = G::from_u64(153); let __v_11: G = G::from_u64(64); let __v_12: G = G::from_u64(184); let __v_13: G = G::from_u64(27); let __v_14: G = G::from_u64(182); let __v_15: G = G::from_u64(75); let __v_16: G = G::from_u64(159); let __v_17: G = G::from_u64(19); let __v_18: G = G::from_u64(88); let __v_19: G = G::from_u64(210); let __v_20: G = G::from_u64(148); let __v_21: G = G::from_u64(255); let __v_22: G = G::from_u64(152); let __v_23: G = G::from_u64(23); let __v_24: G = G::from_u64(26); let __v_25: G = G::from_u64(70); let __v_26: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_2, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_4, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_2, __v_20, __v_24, __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 __ret: [G; OUT_155] = [__v_26]; record.function_queries[155].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_156: usize = 0; -const IN_156: usize = 0; +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 __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_155] = [__v_1]; record.function_queries[155].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_155] = [__v_0]; record.function_queries[155].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__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(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 __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_155] = { let __args: [G; IN_155] = [__v_11, __v_21]; 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_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_155] = [__v_32]; record.function_queries[155].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_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 = G::from_u64(66); let __v_1: G = G::from_u64(214); let __v_2: G = G::from_u64(237); let __v_3: G = G::from_u64(49); let __v_4: G = G::from_u64(83); let __v_5: G = G::from_u64(111); let __v_6: G = G::from_u64(9); let __v_7: G = G::from_u64(88); let __v_8: G = G::from_u64(23); let __v_9: G = G::from_u64(29); let __v_10: G = G::from_u64(201); let __v_11: G = G::from_u64(115); let __v_12: G = G::from_u64(56); let __v_13: G = G::from_u64(8); let __v_14: G = G::from_u64(172); let __v_15: G = G::from_u64(133); let __v_16: G = G::from_u64(131); let __v_17: G = G::from_u64(34); let __v_18: G = G::from_u64(55); let __v_19: G = G::from_u64(70); let __v_20: G = G::from_u64(235); let __v_21: G = G::from_u64(202); let __v_22: G = G::from_u64(120); let __v_23: G = G::from_u64(219); let __v_24: G = G::from_u64(227); let __v_25: G = G::from_u64(137); let __v_26: G = G::from_u64(182); let __v_27: G = G::from_u64(33); let __v_28: G = G::from_u64(166); let __v_29: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_5, __v_9, __v_10, __v_11, __v_12, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_4, __v_27, __v_28]; 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_156] = [__v_29]; record.function_queries[156].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_157: usize = 0; -const IN_157: usize = 0; +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 = 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_149] = { let __args: [G; IN_149] = [__v_6, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __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 __ret: [G; OUT_156] = [__v_8]; record.function_queries[156].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_157: usize = 2; +const IN_157: usize = 2; const OUT_157: usize = 1; -fn aiur_fn_157(inp: [G; IN_157], 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 = G::from_u64(118); let __v_1: G = G::from_u64(175); let __v_2: G = G::from_u64(162); let __v_3: G = G::from_u64(84); let __v_4: G = G::from_u64(168); let __v_5: G = G::from_u64(187); let __v_6: G = G::from_u64(242); let __v_7: G = G::from_u64(172); let __v_8: G = G::from_u64(67); let __v_9: G = G::from_u64(39); let __v_10: G = G::from_u64(215); let __v_11: G = G::from_u64(185); let __v_12: G = G::from_u64(75); let __v_13: G = G::from_u64(224); let __v_14: G = G::from_u64(198); let __v_15: G = G::from_u64(59); let __v_16: G = G::from_u64(8); let __v_17: G = G::from_u64(131); let __v_18: G = G::from_u64(107); let __v_19: G = G::from_u64(95); let __v_20: G = G::from_u64(115); let __v_21: G = G::from_u64(132); let __v_22: G = G::from_u64(206); let __v_23: G = G::from_u64(153); let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(136); let __v_26: G = G::from_u64(173); let __v_27: G = G::from_u64(176); let __v_28: G = G::from_u64(161); let __v_29: G = G::from_u64(211); let __v_30: G = G::from_u64(207); let __v_31: 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_10, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_157] = [__v_31]; record.function_queries[157].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = 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_149] = { let __args: [G; IN_149] = [__v_6, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __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_8: G = __r_arr[0]; let __ret: [G; OUT_157] = [__v_8]; record.function_queries[157].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_158: usize = 0; const IN_158: usize = 0; const OUT_158: usize = 1; -fn aiur_fn_158(inp: [G; IN_158], 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 = G::from_u64(10); let __v_1: G = G::from_u64(153); let __v_2: G = G::from_u64(244); let __v_3: G = G::from_u64(156); let __v_4: G = G::from_u64(199); let __v_5: G = G::from_u64(58); let __v_6: G = G::from_u64(185); let __v_7: G = G::from_u64(39); let __v_8: G = G::from_u64(131); let __v_9: G = G::from_u64(9); let __v_10: G = G::from_u64(46); let __v_11: G = G::from_u64(113); let __v_12: G = G::from_u64(32); let __v_13: G = G::from_u64(97); let __v_14: G = G::from_u64(50); let __v_15: G = G::from_u64(37); let __v_16: G = G::from_u64(103); let __v_17: G = G::from_u64(11); let __v_18: G = G::from_u64(171); let __v_19: G = G::from_u64(137); let __v_20: G = G::from_u64(214); let __v_21: G = G::from_u64(53); let __v_22: G = G::from_u64(51); let __v_23: G = G::from_u64(209); let __v_24: G = G::from_u64(173); let __v_25: G = G::from_u64(239); let __v_26: G = G::from_u64(200); let __v_27: G = G::from_u64(118); let __v_28: G = G::from_u64(24); let __v_29: G = G::from_u64(47); let __v_30: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_2, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_6, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_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_158] = [__v_30]; record.function_queries[158].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_158(inp: [G; IN_158], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(238); let __v_1: G = G::from_u64(178); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(38); let __v_4: G = G::from_u64(143); let __v_5: G = G::from_u64(246); let __v_6: G = G::from_u64(208); let __v_7: G = G::from_u64(233); let __v_8: G = G::from_u64(118); let __v_9: G = G::from_u64(77); let __v_10: G = G::from_u64(153); let __v_11: G = G::from_u64(64); let __v_12: G = G::from_u64(184); let __v_13: G = G::from_u64(27); let __v_14: G = G::from_u64(182); let __v_15: G = G::from_u64(75); let __v_16: G = G::from_u64(159); let __v_17: G = G::from_u64(19); let __v_18: G = G::from_u64(88); let __v_19: G = G::from_u64(210); let __v_20: G = G::from_u64(148); let __v_21: G = G::from_u64(255); let __v_22: G = G::from_u64(152); let __v_23: G = G::from_u64(23); let __v_24: G = G::from_u64(26); let __v_25: G = G::from_u64(70); let __v_26: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_2, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_4, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_2, __v_20, __v_24, __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 __ret: [G; OUT_158] = [__v_26]; record.function_queries[158].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_159: usize = 0; const IN_159: usize = 0; const OUT_159: usize = 1; -fn aiur_fn_159(inp: [G; IN_159], 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 = G::from_u64(247); let __v_1: G = G::from_u64(19); let __v_2: G = G::from_u64(13); let __v_3: G = G::from_u64(88); let __v_4: G = G::from_u64(100); let __v_5: G = G::from_u64(225); let __v_6: G = G::from_u64(186); let __v_7: G = G::from_u64(119); let __v_8: G = G::from_u64(176); let __v_9: G = G::from_u64(246); let __v_10: G = G::from_u64(167); let __v_11: G = G::from_u64(51); let __v_12: G = G::from_u64(143); let __v_13: G = G::from_u64(146); let __v_14: G = G::from_u64(21); let __v_15: G = G::from_u64(156); let __v_16: G = G::from_u64(53); let __v_17: G = G::from_u64(189); let __v_18: G = G::from_u64(81); let __v_19: G = G::from_u64(71); let __v_20: G = G::from_u64(224); let __v_21: G = G::from_u64(254); let __v_22: G = G::from_u64(188); let __v_23: G = G::from_u64(241); let __v_24: G = G::from_u64(235); let __v_25: G = G::from_u64(237); let __v_26: G = G::from_u64(69); let __v_27: G = G::from_u64(110); let __v_28: G = G::from_u64(56); let __v_29: G = G::from_u64(204); 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_25, __v_26, __v_27, __v_18, __v_16, __v_28, __v_29]; 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_159] = [__v_30]; record.function_queries[159].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(66); let __v_1: G = G::from_u64(214); let __v_2: G = G::from_u64(237); let __v_3: G = G::from_u64(49); let __v_4: G = G::from_u64(83); let __v_5: G = G::from_u64(111); let __v_6: G = G::from_u64(9); let __v_7: G = G::from_u64(88); let __v_8: G = G::from_u64(23); let __v_9: G = G::from_u64(29); let __v_10: G = G::from_u64(201); let __v_11: G = G::from_u64(115); let __v_12: G = G::from_u64(56); let __v_13: G = G::from_u64(8); let __v_14: G = G::from_u64(172); let __v_15: G = G::from_u64(133); let __v_16: G = G::from_u64(131); let __v_17: G = G::from_u64(34); let __v_18: G = G::from_u64(55); let __v_19: G = G::from_u64(70); let __v_20: G = G::from_u64(235); let __v_21: G = G::from_u64(202); let __v_22: G = G::from_u64(120); let __v_23: G = G::from_u64(219); let __v_24: G = G::from_u64(227); let __v_25: G = G::from_u64(137); let __v_26: G = G::from_u64(182); let __v_27: G = G::from_u64(33); let __v_28: G = G::from_u64(166); let __v_29: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_5, __v_9, __v_10, __v_11, __v_12, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_4, __v_27, __v_28]; 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_159] = [__v_29]; record.function_queries[159].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_160: usize = 0; const IN_160: usize = 0; const OUT_160: usize = 1; -fn aiur_fn_160(inp: [G; IN_160], 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 = G::from_u64(157); let __v_1: G = G::from_u64(176); let __v_2: G = G::from_u64(23); let __v_3: G = G::from_u64(126); let __v_4: G = G::from_u64(78); let __v_5: G = G::from_u64(139); let __v_6: G = G::from_u64(106); let __v_7: G = G::from_u64(14); let __v_8: G = G::from_u64(115); let __v_9: G = G::from_u64(35); let __v_10: G = G::from_u64(6); let __v_11: G = G::from_u64(149); let __v_12: G = G::from_u64(9); let __v_13: G = G::from_u64(194); let __v_14: G = G::from_u64(69); let __v_15: G = G::from_u64(125); let __v_16: G = G::from_u64(233); let __v_17: G = G::from_u64(89); let __v_18: G = G::from_u64(138); let __v_19: G = G::from_u64(56); let __v_20: G = G::from_u64(231); let __v_21: G = G::from_u64(47); let __v_22: G = G::from_u64(254); let __v_23: G = G::from_u64(25); let __v_24: G = G::from_u64(173); let __v_25: G = G::from_u64(52); let __v_26: G = G::from_u64(97); let __v_27: G = G::from_u64(114); let __v_28: G = G::from_u64(86); let __v_29: G = G::from_u64(225); let __v_30: G = G::from_u64(13); let __v_31: 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_3, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_160] = [__v_31]; record.function_queries[160].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(50); let __v_1: G = G::from_u64(68); let __v_2: G = G::from_u64(104); let __v_3: G = G::from_u64(115); let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(215); let __v_6: G = G::from_u64(121); let __v_7: G = G::from_u64(236); let __v_8: G = G::from_u64(117); let __v_9: G = G::from_u64(114); let __v_10: G = G::from_u64(116); let __v_11: G = G::from_u64(118); let __v_12: G = G::from_u64(29); let __v_13: G = G::from_u64(144); let __v_14: G = G::from_u64(61); let __v_15: G = G::from_u64(239); let __v_16: G = G::from_u64(62); let __v_17: G = G::from_u64(179); let __v_18: G = G::from_u64(19); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(119); let __v_21: G = G::from_u64(123); let __v_22: G = G::from_u64(112); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(203); let __v_25: G = G::from_u64(216); let __v_26: G = G::from_u64(84); let __v_27: G = G::from_u64(73); let __v_28: G = G::from_u64(111); let __v_29: 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_0, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_15, __v_27, __v_28, __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_160] = [__v_29]; record.function_queries[160].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_161: usize = 0; const IN_161: usize = 0; const OUT_161: usize = 1; -fn aiur_fn_161(inp: [G; IN_161], 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 = G::from_u64(133); let __v_1: G = G::from_u64(98); let __v_2: G = G::from_u64(19); let __v_3: G = G::from_u64(135); let __v_4: G = G::from_u64(239); let __v_5: G = G::from_u64(48); let __v_6: G = G::from_u64(39); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(141); let __v_9: G = G::from_u64(131); let __v_10: G = G::from_u64(82); let __v_11: G = G::from_u64(243); let __v_12: G = G::from_u64(204); let __v_13: G = G::from_u64(20); let __v_14: G = G::from_u64(97); let __v_15: G = G::from_u64(4); let __v_16: G = G::from_u64(29); let __v_17: G = G::from_u64(31); let __v_18: G = G::from_u64(217); let __v_19: G = G::from_u64(30); let __v_20: G = G::from_u64(40); let __v_21: G = G::from_u64(232); let __v_22: G = G::from_u64(127); let __v_23: G = G::from_u64(102); let __v_24: G = G::from_u64(156); let __v_25: G = G::from_u64(192); let __v_26: G = G::from_u64(74); let __v_27: G = G::from_u64(94); let __v_28: G = G::from_u64(234); let __v_29: 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_3, __v_11, __v_12, __v_13, __v_14, __v_4, __v_15, __v_16, __v_4, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_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_161] = [__v_29]; record.function_queries[161].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_161(inp: [G; IN_161], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(10); let __v_1: G = G::from_u64(153); let __v_2: G = G::from_u64(244); let __v_3: G = G::from_u64(156); let __v_4: G = G::from_u64(199); let __v_5: G = G::from_u64(58); let __v_6: G = G::from_u64(185); let __v_7: G = G::from_u64(39); let __v_8: G = G::from_u64(131); let __v_9: G = G::from_u64(9); let __v_10: G = G::from_u64(46); let __v_11: G = G::from_u64(113); let __v_12: G = G::from_u64(32); let __v_13: G = G::from_u64(97); let __v_14: G = G::from_u64(50); let __v_15: G = G::from_u64(37); let __v_16: G = G::from_u64(103); let __v_17: G = G::from_u64(11); let __v_18: G = G::from_u64(171); let __v_19: G = G::from_u64(137); let __v_20: G = G::from_u64(214); let __v_21: G = G::from_u64(53); let __v_22: G = G::from_u64(51); let __v_23: G = G::from_u64(209); let __v_24: G = G::from_u64(173); let __v_25: G = G::from_u64(239); let __v_26: G = G::from_u64(200); let __v_27: G = G::from_u64(118); let __v_28: G = G::from_u64(24); let __v_29: G = G::from_u64(47); let __v_30: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_2, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_6, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_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_161] = [__v_30]; record.function_queries[161].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_162: usize = 0; const IN_162: usize = 0; const OUT_162: usize = 1; -fn aiur_fn_162(inp: [G; IN_162], 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 = G::from_u64(176); let __v_1: G = G::from_u64(84); let __v_2: G = G::from_u64(89); let __v_3: G = G::from_u64(98); let __v_4: G = G::from_u64(61); let __v_5: G = G::from_u64(35); let __v_6: G = G::from_u64(41); let __v_7: G = G::from_u64(157); let __v_8: G = G::from_u64(58); let __v_9: G = G::from_u64(132); let __v_10: G = G::from_u64(158); let __v_11: G = G::from_u64(183); let __v_12: G = G::from_u64(251); let __v_13: G = G::from_u64(117); let __v_14: G = G::from_u64(186); let __v_15: G = G::from_u64(219); let __v_16: G = G::from_u64(193); let __v_17: G = G::from_u64(122); let __v_18: G = G::from_u64(28); let __v_19: G = G::from_u64(217); let __v_20: G = G::from_u64(238); let __v_21: G = G::from_u64(86); let __v_22: G = G::from_u64(12); let __v_23: G = G::from_u64(21); let __v_24: G = G::from_u64(6); let __v_25: G = G::from_u64(127); let __v_26: G = G::from_u64(189); let __v_27: G = G::from_u64(152); let __v_28: G = G::from_u64(92); let __v_29: G = G::from_u64(108); let __v_30: G = G::from_u64(234); let __v_31: 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_1, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_162] = [__v_31]; record.function_queries[162].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(247); let __v_1: G = G::from_u64(19); let __v_2: G = G::from_u64(13); let __v_3: G = G::from_u64(88); let __v_4: G = G::from_u64(100); let __v_5: G = G::from_u64(225); let __v_6: G = G::from_u64(186); let __v_7: G = G::from_u64(119); let __v_8: G = G::from_u64(176); let __v_9: G = G::from_u64(246); let __v_10: G = G::from_u64(167); let __v_11: G = G::from_u64(51); let __v_12: G = G::from_u64(143); let __v_13: G = G::from_u64(146); let __v_14: G = G::from_u64(21); let __v_15: G = G::from_u64(156); let __v_16: G = G::from_u64(53); let __v_17: G = G::from_u64(189); let __v_18: G = G::from_u64(81); let __v_19: G = G::from_u64(71); let __v_20: G = G::from_u64(224); let __v_21: G = G::from_u64(254); let __v_22: G = G::from_u64(188); let __v_23: G = G::from_u64(241); let __v_24: G = G::from_u64(235); let __v_25: G = G::from_u64(237); let __v_26: G = G::from_u64(69); let __v_27: G = G::from_u64(110); let __v_28: G = G::from_u64(56); let __v_29: G = G::from_u64(204); 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_25, __v_26, __v_27, __v_18, __v_16, __v_28, __v_29]; 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_162] = [__v_30]; record.function_queries[162].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_163: usize = 0; const IN_163: usize = 0; const OUT_163: usize = 1; -fn aiur_fn_163(inp: [G; IN_163], 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 = G::from_u64(103); let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(215); let __v_3: G = G::from_u64(101); let __v_4: G = G::from_u64(255); let __v_5: G = G::from_u64(16); let __v_6: G = G::from_u64(191); let __v_7: G = G::from_u64(163); let __v_8: G = G::from_u64(166); let __v_9: G = G::from_u64(195); let __v_10: G = G::from_u64(71); let __v_11: G = G::from_u64(223); let __v_12: G = G::from_u64(21); let __v_13: G = G::from_u64(25); let __v_14: G = G::from_u64(78); let __v_15: G = G::from_u64(13); let __v_16: G = G::from_u64(184); let __v_17: G = G::from_u64(98); let __v_18: G = G::from_u64(238); let __v_19: G = G::from_u64(37); let __v_20: G = G::from_u64(181); let __v_21: G = G::from_u64(79); let __v_22: G = G::from_u64(165); let __v_23: G = G::from_u64(159); let __v_24: G = G::from_u64(124); let __v_25: G = G::from_u64(242); let __v_26: G = G::from_u64(81); let __v_27: G = G::from_u64(153); let __v_28: G = G::from_u64(126); let __v_29: 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_19, __v_22, __v_23, __v_24, __v_25, __v_13, __v_26, __v_7, __v_27, __v_28]; 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_163] = [__v_29]; record.function_queries[163].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(182); let __v_1: G = G::from_u64(102); let __v_2: G = G::from_u64(146); let __v_3: G = G::from_u64(91); let __v_4: G = G::from_u64(16); let __v_5: G = G::from_u64(71); let __v_6: G = G::from_u64(63); let __v_7: G = G::from_u64(190); let __v_8: G = G::from_u64(26); let __v_9: G = G::from_u64(118); let __v_10: G = G::from_u64(48); let __v_11: G = G::from_u64(236); let __v_12: G = G::from_u64(73); let __v_13: G = G::from_u64(111); let __v_14: G = G::from_u64(224); let __v_15: G = G::from_u64(125); let __v_16: G = G::from_u64(121); let __v_17: G = G::from_u64(156); let __v_18: G = G::from_u64(82); let __v_19: G = G::from_u64(72); let __v_20: G = G::from_u64(177); let __v_21: G = G::from_u64(226); let __v_22: G = G::from_u64(47); let __v_23: G = G::from_u64(202); let __v_24: G = G::from_u64(95); let __v_25: G = G::from_u64(228); let __v_26: G = G::from_u64(197); let __v_27: G = G::from_u64(12); let __v_28: 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_1, __v_15, __v_20, __v_21, __v_10, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_0]; 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_163] = [__v_28]; record.function_queries[163].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_164: usize = 0; const IN_164: usize = 0; const OUT_164: usize = 1; -fn aiur_fn_164(inp: [G; IN_164], 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 = G::from_u64(226); let __v_1: G = G::from_u64(156); let __v_2: G = G::from_u64(250); let __v_3: G = G::from_u64(121); let __v_4: G = G::from_u64(33); let __v_5: G = G::from_u64(187); let __v_6: G = G::from_u64(87); let __v_7: G = G::from_u64(244); let __v_8: G = G::from_u64(120); let __v_9: G = G::from_u64(43); let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(28); let __v_12: G = G::from_u64(151); let __v_13: G = G::from_u64(117); let __v_14: G = G::from_u64(150); let __v_15: G = G::from_u64(164); let __v_16: G = G::from_u64(224); let __v_17: G = G::from_u64(78); let __v_18: G = G::from_u64(148); let __v_19: G = G::from_u64(247); let __v_20: G = G::from_u64(176); let __v_21: G = G::from_u64(85); let __v_22: G = G::from_u64(254); let __v_23: G = G::from_u64(40); let __v_24: G = G::from_u64(20); let __v_25: G = G::from_u64(252); let __v_26: G = G::from_u64(72); let __v_27: G = G::from_u64(222); let __v_28: G = G::from_u64(144); let __v_29: G = G::from_u64(231); 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_2, __v_16, __v_17, __v_18, __v_19, __v_20, __v_3, __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(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_164] = [__v_30]; record.function_queries[164].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(124); let __v_1: G = G::from_u64(96); let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(61); let __v_4: G = G::from_u64(22); let __v_5: G = G::from_u64(226); let __v_6: G = G::from_u64(240); let __v_7: G = G::from_u64(239); let __v_8: G = G::from_u64(93); let __v_9: G = G::from_u64(118); let __v_10: G = G::from_u64(78); let __v_11: G = G::from_u64(26); let __v_12: G = G::from_u64(183); let __v_13: G = G::from_u64(146); let __v_14: G = G::from_u64(57); let __v_15: G = G::from_u64(104); let __v_16: G = G::from_u64(212); let __v_17: G = G::from_u64(92); let __v_18: G = G::from_u64(56); let __v_19: G = G::from_u64(129); let __v_20: G = G::from_u64(134); let __v_21: G = G::from_u64(221); let __v_22: G = G::from_u64(246); let __v_23: G = G::from_u64(200); let __v_24: G = G::from_u64(60); let __v_25: G = G::from_u64(40); let __v_26: G = G::from_u64(36); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(122); let __v_29: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_1, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_3, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_6, __v_26, __v_27, __v_28]; 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_164] = [__v_29]; record.function_queries[164].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_165: usize = 0; const IN_165: usize = 0; const OUT_165: usize = 1; -fn aiur_fn_165(inp: [G; IN_165], 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 = G::from_u64(156); let __v_1: G = G::from_u64(149); let __v_2: G = G::from_u64(45); let __v_3: G = G::from_u64(69); let __v_4: G = G::from_u64(163); let __v_5: G = G::from_u64(189); let __v_6: G = G::from_u64(67); let __v_7: G = G::from_u64(22); let __v_8: G = G::from_u64(21); let __v_9: G = G::from_u64(41); let __v_10: G = G::from_u64(252); let __v_11: G = G::from_u64(251); let __v_12: G = G::from_u64(94); let __v_13: G = G::from_u64(39); let __v_14: G = G::from_u64(107); let __v_15: G = G::from_u64(234); let __v_16: G = G::from_u64(176); let __v_17: G = G::from_u64(207); let __v_18: G = G::from_u64(79); let __v_19: G = G::from_u64(214); let __v_20: G = G::from_u64(74); let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(186); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(194); let __v_25: G = G::from_u64(199); let __v_26: G = G::from_u64(205); let __v_27: G = G::from_u64(118); let __v_28: G = G::from_u64(203); let __v_29: G = G::from_u64(143); let __v_30: G = G::from_u64(84); let __v_31: 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_4, __v_27, __v_28, __v_29, __v_30]; 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_165] = [__v_31]; record.function_queries[165].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(157); let __v_1: G = G::from_u64(255); let __v_2: G = G::from_u64(148); let __v_3: G = G::from_u64(158); let __v_4: G = G::from_u64(77); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(130); let __v_7: G = G::from_u64(57); let __v_8: G = G::from_u64(50); let __v_9: G = G::from_u64(19); let __v_10: G = G::from_u64(4); let __v_11: G = G::from_u64(42); let __v_12: G = G::from_u64(54); let __v_13: G = G::from_u64(166); let __v_14: G = G::from_u64(154); let __v_15: G = G::from_u64(244); let __v_16: G = G::from_u64(183); let __v_17: G = G::from_u64(26); let __v_18: G = G::from_u64(88); let __v_19: G = G::from_u64(112); let __v_20: G = G::from_u64(144); let __v_21: G = G::from_u64(150); let __v_22: G = G::from_u64(234); let __v_23: G = G::from_u64(163); let __v_24: G = G::from_u64(222); let __v_25: G = G::from_u64(81); let __v_26: G = G::from_u64(48); let __v_27: G = G::from_u64(186); let __v_28: G = G::from_u64(224); let __v_29: G = G::from_u64(175); let __v_30: G = G::from_u64(132); let __v_31: G = G::from_u64(243); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_165] = [__v_32]; record.function_queries[165].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_166: usize = 0; const IN_166: usize = 0; const OUT_166: usize = 1; -fn aiur_fn_166(inp: [G; IN_166], 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 = G::from_u64(11); let __v_1: G = G::from_u64(21); let __v_2: G = G::from_u64(100); let __v_3: G = G::from_u64(222); let __v_4: G = G::from_u64(166); let __v_5: G = G::from_u64(255); let __v_6: G = G::from_u64(205); let __v_7: G = G::from_u64(32); let __v_8: G = G::from_u64(78); let __v_9: G = G::from_u64(188); let __v_10: G = G::from_u64(209); let __v_11: G = G::from_u64(170); let __v_12: G = G::from_u64(105); let __v_13: G = G::from_u64(210); let __v_14: G = G::from_u64(158); let __v_15: G = G::from_u64(230); let __v_16: G = G::from_u64(243); let __v_17: G = G::from_u64(172); let __v_18: G = G::from_u64(204); let __v_19: G = G::from_u64(216); let __v_20: G = G::from_u64(123); let __v_21: G = G::from_u64(70); let __v_22: G = G::from_u64(103); let __v_23: G = G::from_u64(69); let __v_24: G = G::from_u64(86); let __v_25: G = G::from_u64(156); let __v_26: G = G::from_u64(200); let __v_27: G = G::from_u64(179); let __v_28: 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_10, __v_21, __v_5, __v_22, __v_23, __v_24, __v_17, __v_25, __v_26, __v_18, __v_27]; 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_166] = [__v_28]; record.function_queries[166].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_166(inp: [G; IN_166], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(25); let __v_1: G = G::from_u64(200); let __v_2: G = G::from_u64(118); let __v_3: G = G::from_u64(73); let __v_4: G = G::from_u64(249); let __v_5: G = G::from_u64(161); let __v_6: G = G::from_u64(120); let __v_7: G = G::from_u64(9); let __v_8: G = G::from_u64(242); let __v_9: G = G::from_u64(72); let __v_10: G = G::from_u64(190); let __v_11: G = G::from_u64(255); let __v_12: G = G::from_u64(123); let __v_13: G = G::from_u64(195); let __v_14: G = G::from_u64(127); let __v_15: G = G::from_u64(86); let __v_16: G = G::from_u64(159); let __v_17: G = G::from_u64(84); let __v_18: G = G::from_u64(142); let __v_19: G = G::from_u64(36); let __v_20: G = G::from_u64(169); let __v_21: G = G::from_u64(141); let __v_22: G = G::from_u64(138); let __v_23: G = G::from_u64(124); let __v_24: G = G::from_u64(221); let __v_25: G = G::from_u64(213); let __v_26: G = G::from_u64(184); let __v_27: G = G::from_u64(46); let __v_28: G = G::from_u64(8); let __v_29: G = G::from_u64(229); let __v_30: G = G::from_u64(166); let __v_31: 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_26, __v_28, __v_29, __v_30]; 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_166] = [__v_31]; record.function_queries[166].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_167: usize = 0; const IN_167: usize = 0; const OUT_167: usize = 1; -fn aiur_fn_167(inp: [G; IN_167], 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 = G::from_u64(109); let __v_1: G = G::from_u64(53); let __v_2: G = G::from_u64(220); let __v_3: G = G::from_u64(67); let __v_4: G = G::from_u64(102); let __v_5: G = G::from_u64(15); let __v_6: G = G::from_u64(108); let __v_7: G = G::from_u64(80); let __v_8: G = G::from_u64(154); let __v_9: G = G::from_u64(19); let __v_10: G = G::from_u64(242); let __v_11: G = G::from_u64(130); let __v_12: G = G::from_u64(76); let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(126); let __v_15: G = G::from_u64(217); let __v_16: G = G::from_u64(176); let __v_17: G = G::from_u64(112); let __v_18: G = G::from_u64(160); let __v_19: G = G::from_u64(143); let __v_20: G = G::from_u64(5); let __v_21: G = G::from_u64(240); let __v_22: G = G::from_u64(165); let __v_23: G = G::from_u64(244); let __v_24: G = G::from_u64(106); let __v_25: G = G::from_u64(117); let __v_26: G = G::from_u64(146); let __v_27: G = G::from_u64(121); let __v_28: G = G::from_u64(125); let __v_29: 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_8, __v_16, __v_17, __v_18, __v_19, __v_20, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_7, __v_27, __v_28]; 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_167] = [__v_29]; record.function_queries[167].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_167(inp: [G; IN_167], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(19); let __v_1: G = G::from_u64(201); let __v_2: G = G::from_u64(126); let __v_3: G = G::from_u64(132); let __v_4: G = G::from_u64(251); let __v_5: G = G::from_u64(138); let __v_6: G = G::from_u64(195); let __v_7: G = G::from_u64(238); let __v_8: G = G::from_u64(129); let __v_9: G = G::from_u64(32); let __v_10: G = G::from_u64(233); let __v_11: G = G::from_u64(35); let __v_12: G = G::from_u64(214); let __v_13: G = G::from_u64(31); let __v_14: G = G::from_u64(202); let __v_15: G = G::from_u64(111); let __v_16: G = G::from_u64(107); let __v_17: G = G::from_u64(185); let __v_18: G = G::from_u64(36); let __v_19: G = G::from_u64(30); let __v_20: G = G::from_u64(170); let __v_21: G = G::from_u64(93); let __v_22: G = G::from_u64(53); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(165); let __v_25: G = G::from_u64(220); let __v_26: G = G::from_u64(229); let __v_27: G = G::from_u64(66); let __v_28: G = G::from_u64(17); let __v_29: 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_2, __v_16, __v_17, __v_18, __v_19, __v_6, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_20, __v_28]; 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_167] = [__v_29]; record.function_queries[167].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_168: usize = 0; const IN_168: usize = 0; const OUT_168: usize = 1; -fn aiur_fn_168(inp: [G; IN_168], 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 = G::from_u64(38); let __v_1: G = G::from_u64(26); let __v_2: G = G::from_u64(229); let __v_3: G = G::from_u64(78); let __v_4: G = G::from_u64(219); let __v_5: G = G::from_u64(102); let __v_6: G = G::from_u64(233); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(120); let __v_9: G = G::from_u64(74); let __v_10: G = G::from_u64(100); let __v_11: G = G::from_u64(53); let __v_12: G = G::from_u64(11); let __v_13: G = G::from_u64(192); let __v_14: G = G::from_u64(30); let __v_15: G = G::from_u64(139); let __v_16: G = G::from_u64(63); let __v_17: G = G::from_u64(225); let __v_18: G = G::from_u64(51); let __v_19: G = G::from_u64(42); let __v_20: G = G::from_u64(71); let __v_21: G = G::from_u64(202); let __v_22: G = G::from_u64(234); let __v_23: G = G::from_u64(181); let __v_24: G = G::from_u64(142); let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(97); let __v_27: G = G::from_u64(223); let __v_28: G = G::from_u64(252); let __v_29: G = G::from_u64(126); let __v_30: G = G::from_u64(160); let __v_31: G = G::from_u64(8); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_168] = [__v_32]; record.function_queries[168].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_168(inp: [G; IN_168], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(83); let __v_1: G = G::from_u64(228); let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(245); let __v_4: G = G::from_u64(221); let __v_5: G = G::from_u64(60); let __v_6: G = G::from_u64(105); let __v_7: G = G::from_u64(59); let __v_8: G = G::from_u64(195); let __v_9: G = G::from_u64(181); let __v_10: G = G::from_u64(191); let __v_11: G = G::from_u64(174); let __v_12: G = G::from_u64(88); let __v_13: G = G::from_u64(43); let __v_14: G = G::from_u64(150); let __v_15: G = G::from_u64(236); let __v_16: G = G::from_u64(5); let __v_17: G = G::from_u64(175); let __v_18: G = G::from_u64(12); let __v_19: G = G::from_u64(238); let __v_20: G = G::from_u64(10); let __v_21: G = G::from_u64(70); let __v_22: G = G::from_u64(138); let __v_23: G = G::from_u64(182); let __v_24: G = G::from_u64(98); let __v_25: G = G::from_u64(197); let __v_26: G = G::from_u64(127); let __v_27: G = G::from_u64(223); let __v_28: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_0, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_2, __v_14, __v_15, __v_5, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_8, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; 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_168] = [__v_28]; record.function_queries[168].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_169: usize = 0; const IN_169: usize = 0; const OUT_169: usize = 1; -fn aiur_fn_169(inp: [G; IN_169], 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 = G::from_u64(135); let __v_1: G = G::from_u64(38); let __v_2: G = G::from_u64(100); let __v_3: G = G::from_u64(21); let __v_4: G = G::from_u64(152); let __v_5: G = G::from_u64(43); let __v_6: G = G::from_u64(189); let __v_7: G = G::from_u64(236); let __v_8: G = G::from_u64(80); let __v_9: G = G::from_u64(198); let __v_10: G = G::from_u64(29); let __v_11: G = G::from_u64(91); let __v_12: G = G::from_u64(115); let __v_13: G = G::from_u64(204); let __v_14: G = G::from_u64(12); let __v_15: G = G::from_u64(205); let __v_16: G = G::from_u64(92); let __v_17: G = G::from_u64(153); let __v_18: G = G::from_u64(116); let __v_19: G = G::from_u64(69); let __v_20: G = G::from_u64(122); let __v_21: G = G::from_u64(151); let __v_22: G = G::from_u64(36); let __v_23: G = G::from_u64(161); let __v_24: G = G::from_u64(46); let __v_25: G = G::from_u64(57); let __v_26: G = G::from_u64(211); let __v_27: G = G::from_u64(164); let __v_28: 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_7, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_17, __v_20, __v_21, __v_22, __v_23, __v_13, __v_16, __v_24, __v_25, __v_26, __v_27]; 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_169] = [__v_28]; record.function_queries[169].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_169(inp: [G; IN_169], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(208); let __v_1: G = G::from_u64(56); let __v_2: G = G::from_u64(13); let __v_3: G = G::from_u64(201); let __v_4: G = G::from_u64(182); let __v_5: G = G::from_u64(58); let __v_6: G = G::from_u64(254); let __v_7: G = G::from_u64(235); let __v_8: G = G::from_u64(50); let __v_9: G = G::from_u64(53); let __v_10: G = G::from_u64(167); let __v_11: G = G::from_u64(122); let __v_12: G = G::from_u64(222); let __v_13: G = G::from_u64(179); let __v_14: G = G::from_u64(85); let __v_15: G = G::from_u64(168); let __v_16: G = G::from_u64(181); let __v_17: G = G::from_u64(43); let __v_18: G = G::from_u64(7); let __v_19: G = G::from_u64(48); let __v_20: G = G::from_u64(151); let __v_21: G = G::from_u64(21); let __v_22: G = G::from_u64(149); let __v_23: G = G::from_u64(9); let __v_24: G = G::from_u64(55); let __v_25: G = G::from_u64(65); let __v_26: G = G::from_u64(236); let __v_27: G = G::from_u64(44); let __v_28: G = G::from_u64(109); let __v_29: G = G::from_u64(87); let __v_30: G = G::from_u64(205); let __v_31: G = G::from_u64(73); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_169] = [__v_32]; record.function_queries[169].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_170: usize = 0; const IN_170: usize = 0; const OUT_170: usize = 1; -fn aiur_fn_170(inp: [G; IN_170], 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 = G::from_u64(114); let __v_1: G = G::from_u64(77); let __v_2: G = G::from_u64(183); let __v_3: G = G::from_u64(151); let __v_4: G = G::from_u64(225); let __v_5: G = G::from_u64(129); let __v_6: G = G::from_u64(117); let __v_7: G = G::from_u64(69); let __v_8: G = G::from_u64(160); let __v_9: G = G::from_u64(131); let __v_10: G = G::from_u64(113); let __v_11: G = G::from_u64(67); let __v_12: G = G::from_u64(47); let __v_13: G = G::from_u64(209); let __v_14: G = G::from_u64(250); let __v_15: G = G::from_u64(100); let __v_16: G = G::from_u64(40); let __v_17: G = G::from_u64(163); let __v_18: G = G::from_u64(125); let __v_19: G = G::from_u64(207); let __v_20: G = G::from_u64(156); let __v_21: G = G::from_u64(22); let __v_22: G = G::from_u64(223); let __v_23: G = G::from_u64(126); let __v_24: G = G::from_u64(70); let __v_25: G = G::from_u64(72); let __v_26: G = G::from_u64(73); let __v_27: G = G::from_u64(219); let __v_28: G = G::from_u64(10); let __v_29: G = G::from_u64(172); 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_10, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_5, __v_29]; 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_170] = [__v_30]; record.function_queries[170].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(32); let __v_1: G = G::from_u64(154); let __v_2: G = G::from_u64(202); let __v_3: G = G::from_u64(98); let __v_4: G = G::from_u64(204); let __v_5: G = G::from_u64(31); let __v_6: G = G::from_u64(157); let __v_7: G = G::from_u64(210); let __v_8: G = G::from_u64(192); let __v_9: G = G::from_u64(169); let __v_10: G = G::from_u64(40); let __v_11: G = G::from_u64(205); let __v_12: G = G::from_u64(132); let __v_13: G = G::from_u64(215); let __v_14: G = G::from_u64(43); let __v_15: G = G::from_u64(180); let __v_16: G = G::from_u64(21); let __v_17: G = G::from_u64(112); let __v_18: G = G::from_u64(170); let __v_19: G = G::from_u64(151); let __v_20: G = G::from_u64(193); let __v_21: G = G::from_u64(253); let __v_22: G = G::from_u64(131); let __v_23: G = G::from_u64(62); let __v_24: G = G::from_u64(95); let __v_25: G = G::from_u64(255); let __v_26: G = G::from_u64(197); let __v_27: G = G::from_u64(103); let __v_28: G = G::from_u64(198); let __v_29: G = G::from_u64(64); 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_25, __v_26, __v_27, __v_20, __v_28, __v_29, __v_5]; 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_170] = [__v_30]; record.function_queries[170].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_171: usize = 0; const IN_171: usize = 0; const OUT_171: usize = 1; -fn aiur_fn_171(inp: [G; IN_171], 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 = G::from_u64(157); let __v_1: G = G::from_u64(226); let __v_2: G = G::from_u64(210); let __v_3: G = G::from_u64(198); let __v_4: G = G::from_u64(14); let __v_5: G = G::from_u64(125); let __v_6: G = G::from_u64(66); let __v_7: G = G::from_u64(26); let __v_8: G = G::from_u64(47); let __v_9: G = G::from_u64(223); let __v_10: G = G::from_u64(184); let __v_11: G = G::from_u64(112); let __v_12: G = G::from_u64(110); let __v_13: G = G::from_u64(145); let __v_14: G = G::from_u64(224); let __v_15: G = G::from_u64(230); let __v_16: G = G::from_u64(216); let __v_17: G = G::from_u64(87); let __v_18: G = G::from_u64(108); let __v_19: G = G::from_u64(59); let __v_20: G = G::from_u64(212); let __v_21: G = G::from_u64(192); let __v_22: G = G::from_u64(4); let __v_23: G = G::from_u64(5); let __v_24: G = G::from_u64(88); let __v_25: G = G::from_u64(117); let __v_26: G = G::from_u64(203); let __v_27: G = G::from_u64(155); let __v_28: G = G::from_u64(90); let __v_29: G = G::from_u64(38); 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_12, __v_21, __v_22, __v_23, __v_3, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_171] = [__v_30]; record.function_queries[171].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(1); let __v_1: G = G::from_u64(231); let __v_2: G = G::from_u64(199); let __v_3: G = G::from_u64(36); let __v_4: G = G::from_u64(80); let __v_5: G = G::from_u64(136); let __v_6: G = G::from_u64(151); let __v_7: G = G::from_u64(224); let __v_8: G = G::from_u64(30); let __v_9: G = G::from_u64(93); let __v_10: G = G::from_u64(11); let __v_11: G = G::from_u64(143); let __v_12: G = G::from_u64(114); let __v_13: G = G::from_u64(226); let __v_14: G = G::from_u64(207); let __v_15: G = G::from_u64(162); let __v_16: G = G::from_u64(96); let __v_17: G = G::from_u64(124); let __v_18: G = G::from_u64(234); let __v_19: G = G::from_u64(95); let __v_20: G = G::from_u64(240); let __v_21: G = G::from_u64(211); let __v_22: G = G::from_u64(82); let __v_23: G = G::from_u64(208); let __v_24: G = G::from_u64(8); let __v_25: G = G::from_u64(81); let __v_26: G = G::from_u64(42); let __v_27: G = G::from_u64(171); let __v_28: G = G::from_u64(47); let __v_29: G = G::from_u64(70); 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_23, __v_1, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_171] = [__v_30]; record.function_queries[171].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_172: usize = 0; const IN_172: usize = 0; const OUT_172: usize = 1; -fn aiur_fn_172(inp: [G; IN_172], 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 = G::from_u64(86); let __v_1: G = G::from_u64(106); let __v_2: G = G::from_u64(60); let __v_3: G = G::from_u64(34); let __v_4: G = G::from_u64(73); let __v_5: G = G::from_u64(188); let __v_6: G = G::from_u64(32); let __v_7: G = G::from_u64(118); let __v_8: G = G::from_u64(84); let __v_9: G = G::from_u64(61); let __v_10: G = G::from_u64(155); let __v_11: G = G::from_u64(197); let __v_12: G = G::from_u64(97); let __v_13: G = G::from_u64(168); let __v_14: G = G::from_u64(65); let __v_15: G = G::from_u64(246); let __v_16: G = G::from_u64(253); let __v_17: G = G::from_u64(53); let __v_18: G = G::from_u64(255); let __v_19: G = G::from_u64(181); let __v_20: G = G::from_u64(189); let __v_21: G = G::from_u64(187); let __v_22: G = G::from_u64(201); let __v_23: G = G::from_u64(145); let __v_24: G = G::from_u64(169); let __v_25: G = G::from_u64(198); let __v_26: G = G::from_u64(79); let __v_27: G = G::from_u64(236); let __v_28: G = G::from_u64(203); let __v_29: G = G::from_u64(213); let __v_30: G = G::from_u64(212); let __v_31: 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_11, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; 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_172] = [__v_31]; record.function_queries[172].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(162); let __v_1: G = G::from_u64(137); let __v_2: G = G::from_u64(88); let __v_3: G = G::from_u64(215); let __v_4: G = G::from_u64(71); let __v_5: G = G::from_u64(232); let __v_6: G = G::from_u64(123); let __v_7: G = G::from_u64(90); let __v_8: G = G::from_u64(96); let __v_9: G = G::from_u64(228); let __v_10: G = G::from_u64(250); let __v_11: G = G::from_u64(7); let __v_12: G = G::from_u64(239); let __v_13: G = G::from_u64(126); let __v_14: G = G::from_u64(216); let __v_15: G = G::from_u64(217); let __v_16: G = G::from_u64(73); let __v_17: G = G::from_u64(246); let __v_18: G = G::from_u64(154); let __v_19: G = G::from_u64(220); let __v_20: G = G::from_u64(188); let __v_21: G = G::from_u64(68); let __v_22: G = G::from_u64(175); let __v_23: G = G::from_u64(226); let __v_24: G = G::from_u64(149); let __v_25: G = G::from_u64(132); let __v_26: G = G::from_u64(130); let __v_27: G = G::from_u64(211); let __v_28: G = G::from_u64(238); let __v_29: G = G::from_u64(155); let __v_30: G = G::from_u64(51); let __v_31: G = G::from_u64(101); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_172] = [__v_32]; record.function_queries[172].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_173: usize = 0; const IN_173: usize = 0; const OUT_173: usize = 1; -fn aiur_fn_173(inp: [G; IN_173], 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 = G::from_u64(91); let __v_1: G = G::from_u64(164); let __v_2: G = G::from_u64(58); let __v_3: G = G::from_u64(195); let __v_4: G = G::from_u64(229); let __v_5: G = G::from_u64(210); let __v_6: G = G::from_u64(159); let __v_7: G = G::from_u64(206); let __v_8: G = G::from_u64(129); let __v_9: G = G::from_u64(241); let __v_10: G = G::from_u64(138); let __v_11: G = G::from_u64(24); let __v_12: G = G::from_u64(23); let __v_13: G = G::from_u64(39); let __v_14: G = G::from_u64(5); let __v_15: G = G::from_u64(126); let __v_16: G = G::from_u64(230); let __v_17: G = G::from_u64(116); let __v_18: G = G::from_u64(185); let __v_19: G = G::from_u64(182); let __v_20: G = G::from_u64(238); let __v_21: G = G::from_u64(80); let __v_22: G = G::from_u64(233); let __v_23: G = G::from_u64(70); let __v_24: G = G::from_u64(106); let __v_25: G = G::from_u64(134); let __v_26: G = G::from_u64(89); let __v_27: G = G::from_u64(59); let __v_28: G = G::from_u64(21); let __v_29: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_10, __v_13, __v_14, __v_3, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_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_173] = [__v_29]; record.function_queries[173].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_173(inp: [G; IN_173], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(62); let __v_1: G = G::from_u64(138); let __v_2: G = G::from_u64(173); let __v_3: G = G::from_u64(204); let __v_4: G = G::from_u64(97); let __v_5: G = G::from_u64(28); let __v_6: G = G::from_u64(77); let __v_7: G = G::from_u64(134); let __v_8: G = G::from_u64(119); let __v_9: G = G::from_u64(202); let __v_10: G = G::from_u64(223); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(199); let __v_13: G = G::from_u64(133); let __v_14: G = G::from_u64(6); let __v_15: G = G::from_u64(86); let __v_16: G = G::from_u64(29); let __v_17: G = G::from_u64(51); let __v_18: G = G::from_u64(115); let __v_19: G = G::from_u64(142); let __v_20: G = G::from_u64(227); let __v_21: G = G::from_u64(213); let __v_22: G = G::from_u64(113); let __v_23: G = G::from_u64(247); let __v_24: G = G::from_u64(164); let __v_25: G = G::from_u64(25); let __v_26: G = G::from_u64(110); let __v_27: G = G::from_u64(38); let __v_28: G = G::from_u64(5); let __v_29: G = G::from_u64(128); let __v_30: G = G::from_u64(201); let __v_31: G = G::from_u64(184); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_173] = [__v_32]; record.function_queries[173].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_174: usize = 0; const IN_174: usize = 0; const OUT_174: usize = 1; -fn aiur_fn_174(inp: [G; IN_174], 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 = G::from_u64(118); let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(125); let __v_3: G = G::from_u64(207); let __v_4: G = G::from_u64(139); let __v_5: G = G::from_u64(40); let __v_6: G = G::from_u64(92); let __v_7: G = G::from_u64(219); let __v_8: G = G::from_u64(214); let __v_9: G = G::from_u64(247); let __v_10: G = G::from_u64(121); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(34); let __v_13: G = G::from_u64(144); let __v_14: G = G::from_u64(254); let __v_15: G = G::from_u64(46); let __v_16: G = G::from_u64(106); let __v_17: G = G::from_u64(253); let __v_18: G = G::from_u64(28); let __v_19: G = G::from_u64(232); let __v_20: G = G::from_u64(130); let __v_21: G = G::from_u64(16); let __v_22: G = G::from_u64(167); let __v_23: G = G::from_u64(226); let __v_24: G = G::from_u64(239); let __v_25: G = G::from_u64(129); let __v_26: G = G::from_u64(216); let __v_27: G = G::from_u64(21); let __v_28: 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_12, __v_18, __v_19, __v_20, __v_21, __v_20, __v_22, __v_23, __v_24, __v_25, __v_19, __v_26, __v_27, __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 __ret: [G; OUT_174] = [__v_28]; record.function_queries[174].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_174(inp: [G; IN_174], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(3); let __v_1: G = G::from_u64(179); let __v_2: G = G::from_u64(160); let __v_3: G = G::from_u64(65); let __v_4: G = G::from_u64(40); let __v_5: G = G::from_u64(91); let __v_6: G = G::from_u64(15); let __v_7: G = G::from_u64(226); let __v_8: G = G::from_u64(2); let __v_9: G = G::from_u64(217); let __v_10: G = G::from_u64(11); let __v_11: G = G::from_u64(34); let __v_12: G = G::from_u64(125); let __v_13: G = G::from_u64(64); let __v_14: G = G::from_u64(92); let __v_15: G = G::from_u64(76); let __v_16: G = G::from_u64(236); let __v_17: G = G::from_u64(37); let __v_18: G = G::from_u64(45); let __v_19: G = G::from_u64(241); let __v_20: G = G::from_u64(139); let __v_21: G = G::from_u64(167); let __v_22: G = G::from_u64(97); let __v_23: G = G::from_u64(106); let __v_24: G = G::from_u64(205); let __v_25: G = G::from_u64(109); let __v_26: G = G::from_u64(174); let __v_27: G = G::from_u64(39); let __v_28: G = G::from_u64(146); let __v_29: G = G::from_u64(230); let __v_30: G = G::from_u64(114); let __v_31: G = G::from_u64(187); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_174] = [__v_32]; record.function_queries[174].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_175: usize = 0; const IN_175: usize = 0; const OUT_175: usize = 1; -fn aiur_fn_175(inp: [G; IN_175], 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 = G::from_u64(230); let __v_1: G = G::from_u64(255); let __v_2: G = G::from_u64(231); let __v_3: G = G::from_u64(135); let __v_4: G = G::from_u64(19); let __v_5: G = G::from_u64(212); let __v_6: G = G::from_u64(185); let __v_7: G = G::from_u64(116); let __v_8: G = G::from_u64(168); let __v_9: G = G::from_u64(45); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(83); let __v_12: G = G::from_u64(143); let __v_13: G = G::from_u64(26); let __v_14: G = G::from_u64(12); let __v_15: G = G::from_u64(245); let __v_16: G = G::from_u64(196); let __v_17: G = G::from_u64(178); let __v_18: G = G::from_u64(96); let __v_19: G = G::from_u64(240); let __v_20: G = G::from_u64(253); let __v_21: G = G::from_u64(153); let __v_22: G = G::from_u64(38); let __v_23: G = G::from_u64(79); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(59); let __v_26: G = G::from_u64(248); let __v_27: G = G::from_u64(71); let __v_28: G = G::from_u64(249); let __v_29: 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_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_22, __v_25, __v_13, __v_26, __v_27, __v_28]; 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_175] = [__v_29]; record.function_queries[175].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(55); let __v_1: G = G::from_u64(59); let __v_2: G = G::from_u64(125); let __v_3: G = G::from_u64(116); let __v_4: G = G::from_u64(246); let __v_5: G = G::from_u64(180); let __v_6: G = G::from_u64(13); let __v_7: G = G::from_u64(161); let __v_8: G = G::from_u64(27); let __v_9: G = G::from_u64(126); let __v_10: G = G::from_u64(215); let __v_11: G = G::from_u64(150); let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(164); let __v_14: G = G::from_u64(94); let __v_15: G = G::from_u64(199); let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(26); let __v_18: G = G::from_u64(136); let __v_19: G = G::from_u64(49); let __v_20: G = G::from_u64(183); let __v_21: G = G::from_u64(32); let __v_22: G = G::from_u64(181); let __v_23: G = G::from_u64(46); let __v_24: G = G::from_u64(254); let __v_25: G = G::from_u64(146); let __v_26: G = G::from_u64(232); let __v_27: G = G::from_u64(42); let __v_28: G = G::from_u64(61); let __v_29: G = G::from_u64(87); let __v_30: G = G::from_u64(240); let __v_31: 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_2, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; 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_175] = [__v_31]; record.function_queries[175].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_176: usize = 0; const IN_176: usize = 0; const OUT_176: usize = 1; -fn aiur_fn_176(inp: [G; IN_176], 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 = G::from_u64(192); let __v_1: G = G::from_u64(117); let __v_2: G = G::from_u64(237); let __v_3: G = G::from_u64(151); let __v_4: G = G::from_u64(111); let __v_5: G = G::from_u64(23); let __v_6: G = G::from_u64(2); let __v_7: G = G::from_u64(243); let __v_8: G = G::from_u64(100); let __v_9: G = G::from_u64(251); let __v_10: G = G::from_u64(11); let __v_11: G = G::from_u64(179); let __v_12: G = G::from_u64(74); let __v_13: G = G::from_u64(168); let __v_14: G = G::from_u64(187); let __v_15: G = G::from_u64(193); let __v_16: G = G::from_u64(102); let __v_17: G = G::from_u64(173); let __v_18: G = G::from_u64(172); let __v_19: G = G::from_u64(229); let __v_20: G = G::from_u64(115); let __v_21: G = G::from_u64(242); let __v_22: G = G::from_u64(206); let __v_23: G = G::from_u64(145); let __v_24: G = G::from_u64(75); let __v_25: G = G::from_u64(67); let __v_26: G = G::from_u64(220); let __v_27: G = G::from_u64(79); let __v_28: G = G::from_u64(171); let __v_29: G = G::from_u64(98); let __v_30: G = G::from_u64(25); let __v_31: 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_12, __v_28, __v_29, __v_30]; 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_176] = [__v_31]; record.function_queries[176].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_176(inp: [G; IN_176], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(91); let __v_1: G = G::from_u64(170); let __v_2: G = G::from_u64(240); let __v_3: G = G::from_u64(92); let __v_4: G = G::from_u64(150); let __v_5: G = G::from_u64(157); let __v_6: G = G::from_u64(44); let __v_7: G = G::from_u64(243); let __v_8: G = G::from_u64(119); let __v_9: G = G::from_u64(49); let __v_10: G = G::from_u64(33); let __v_11: G = G::from_u64(17); let __v_12: G = G::from_u64(190); let __v_13: G = G::from_u64(81); let __v_14: G = G::from_u64(187); let __v_15: G = G::from_u64(100); let __v_16: G = G::from_u64(198); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(193); let __v_19: G = G::from_u64(63); let __v_20: G = G::from_u64(161); let __v_21: G = G::from_u64(238); let __v_22: G = G::from_u64(114); let __v_23: G = G::from_u64(46); let __v_24: G = G::from_u64(146); let __v_25: G = G::from_u64(36); let __v_26: G = G::from_u64(59); let __v_27: G = G::from_u64(15); let __v_28: G = G::from_u64(27); let __v_29: G = G::from_u64(171); 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_15, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_8, __v_28, __v_29]; 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_176] = [__v_30]; record.function_queries[176].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_177: usize = 0; const IN_177: usize = 0; const OUT_177: usize = 1; -fn aiur_fn_177(inp: [G; IN_177], 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 = G::from_u64(198); let __v_1: G = G::from_u64(31); let __v_2: G = G::from_u64(173); let __v_3: G = G::from_u64(70); let __v_4: G = G::from_u64(161); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(219); let __v_7: G = G::from_u64(255); let __v_8: G = G::from_u64(89); let __v_9: G = G::from_u64(34); let __v_10: G = G::from_u64(49); let __v_11: G = G::from_u64(45); let __v_12: G = G::from_u64(79); let __v_13: G = G::from_u64(190); let __v_14: G = G::from_u64(110); let __v_15: G = G::from_u64(112); let __v_16: G = G::from_u64(78); let __v_17: G = G::from_u64(195); let __v_18: G = G::from_u64(44); let __v_19: G = G::from_u64(108); let __v_20: G = G::from_u64(111); let __v_21: G = G::from_u64(100); let __v_22: G = G::from_u64(179); let __v_23: G = G::from_u64(212); let __v_24: G = G::from_u64(129); let __v_25: G = G::from_u64(183); let __v_26: G = G::from_u64(140); let __v_27: G = G::from_u64(119); let __v_28: G = G::from_u64(207); let __v_29: G = G::from_u64(93); 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_0, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10, __v_29]; 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_177] = [__v_30]; record.function_queries[177].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_177(inp: [G; IN_177], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(169); let __v_2: G = G::from_u64(75); let __v_3: G = G::from_u64(251); let __v_4: G = G::from_u64(65); let __v_5: G = G::from_u64(53); let __v_6: G = G::from_u64(29); let __v_7: G = G::from_u64(77); let __v_8: G = G::from_u64(179); let __v_9: G = G::from_u64(97); let __v_10: G = G::from_u64(114); let __v_11: G = G::from_u64(195); let __v_12: G = G::from_u64(121); let __v_13: G = G::from_u64(165); let __v_14: G = G::from_u64(18); let __v_15: G = G::from_u64(240); let __v_16: G = G::from_u64(66); let __v_17: G = G::from_u64(25); let __v_18: G = G::from_u64(239); let __v_19: G = G::from_u64(33); let __v_20: G = G::from_u64(220); let __v_21: G = G::from_u64(84); let __v_22: G = G::from_u64(215); let __v_23: G = G::from_u64(21); let __v_24: G = G::from_u64(144); let __v_25: G = G::from_u64(150); let __v_26: G = G::from_u64(125); let __v_27: G = G::from_u64(78); let __v_28: G = G::from_u64(143); let __v_29: G = G::from_u64(145); let __v_30: G = G::from_u64(63); let __v_31: 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_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_177] = [__v_31]; record.function_queries[177].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_178: usize = 0; const IN_178: usize = 0; const OUT_178: usize = 1; -fn aiur_fn_178(inp: [G; IN_178], 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 = G::from_u64(203); let __v_1: G = G::from_u64(125); let __v_2: G = G::from_u64(204); let __v_3: G = G::from_u64(192); let __v_4: G = G::from_u64(32); let __v_5: G = G::from_u64(165); let __v_6: G = G::from_u64(48); let __v_7: G = G::from_u64(254); let __v_8: G = G::from_u64(215); let __v_9: G = G::from_u64(198); let __v_10: G = G::from_u64(34); let __v_11: G = G::from_u64(177); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(238); let __v_14: G = G::from_u64(82); let __v_15: G = G::from_u64(193); let __v_16: G = G::from_u64(7); let __v_17: G = G::from_u64(139); let __v_18: G = G::from_u64(80); let __v_19: G = G::from_u64(24); let __v_20: G = G::from_u64(21); let __v_21: G = G::from_u64(155); let __v_22: G = G::from_u64(164); let __v_23: G = G::from_u64(104); let __v_24: G = G::from_u64(47); let __v_25: G = G::from_u64(129); let __v_26: G = G::from_u64(126); let __v_27: G = G::from_u64(55); let __v_28: G = G::from_u64(118); let __v_29: G = G::from_u64(120); let __v_30: G = G::from_u64(158); let __v_31: G = G::from_u64(232); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_178] = [__v_32]; record.function_queries[178].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_178(inp: [G; IN_178], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(17); let __v_1: G = G::from_u64(171); let __v_2: G = G::from_u64(191); let __v_3: G = G::from_u64(152); let __v_4: G = G::from_u64(100); let __v_5: G = G::from_u64(129); let __v_6: G = G::from_u64(197); let __v_7: G = G::from_u64(58); let __v_8: G = G::from_u64(33); let __v_9: G = G::from_u64(200); let __v_10: G = G::from_u64(203); let __v_11: G = G::from_u64(238); let __v_12: G = G::from_u64(37); let __v_13: G = G::from_u64(174); let __v_14: G = G::from_u64(98); let __v_15: G = G::from_u64(56); let __v_16: G = G::from_u64(219); let __v_17: G = G::from_u64(236); let __v_18: G = G::from_u64(21); let __v_19: G = G::from_u64(249); let __v_20: G = G::from_u64(114); let __v_21: G = G::from_u64(149); let __v_22: G = G::from_u64(157); let __v_23: G = G::from_u64(8); let __v_24: G = G::from_u64(107); let __v_25: G = G::from_u64(239); let __v_26: G = G::from_u64(26); let __v_27: G = G::from_u64(25); let __v_28: G = G::from_u64(133); let __v_29: 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_8, __v_11, __v_12, __v_5, __v_13, __v_14, __v_15, __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_28]; 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_178] = [__v_29]; record.function_queries[178].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_179: usize = 0; const IN_179: usize = 0; const OUT_179: usize = 1; -fn aiur_fn_179(inp: [G; IN_179], 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 = G::from_u64(216); let __v_1: G = G::from_u64(166); let __v_2: G = G::from_u64(176); let __v_3: G = G::from_u64(90); let __v_4: G = G::from_u64(26); let __v_5: G = G::from_u64(78); let __v_6: G = G::from_u64(92); let __v_7: G = G::from_u64(173); let __v_8: G = G::from_u64(198); let __v_9: G = G::from_u64(156); let __v_10: G = G::from_u64(83); let __v_11: G = G::from_u64(121); let __v_12: G = G::from_u64(46); let __v_13: G = G::from_u64(142); let __v_14: G = G::from_u64(19); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(20); let __v_17: G = G::from_u64(116); let __v_18: G = G::from_u64(94); let __v_19: G = G::from_u64(118); let __v_20: G = G::from_u64(227); let __v_21: G = G::from_u64(43); let __v_22: G = G::from_u64(179); let __v_23: G = G::from_u64(10); let __v_24: G = G::from_u64(224); let __v_25: G = G::from_u64(39); let __v_26: G = G::from_u64(47); let __v_27: G = G::from_u64(160); let __v_28: G = G::from_u64(232); let __v_29: 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_9, __v_24, __v_25, __v_26, __v_27, __v_11, __v_28, __v_1]; 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_179] = [__v_29]; record.function_queries[179].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_179(inp: [G; IN_179], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(130); let __v_1: G = G::from_u64(77); let __v_2: G = G::from_u64(28); let __v_3: G = G::from_u64(83); let __v_4: G = G::from_u64(216); let __v_5: G = G::from_u64(193); let __v_6: G = G::from_u64(195); let __v_7: G = G::from_u64(207); let __v_8: G = G::from_u64(10); let __v_9: G = G::from_u64(39); let __v_10: G = G::from_u64(242); let __v_11: G = G::from_u64(70); let __v_12: G = G::from_u64(57); let __v_13: G = G::from_u64(236); let __v_14: G = G::from_u64(43); let __v_15: G = G::from_u64(225); let __v_16: G = G::from_u64(61); let __v_17: G = G::from_u64(74); let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(201); let __v_20: G = G::from_u64(147); let __v_21: G = G::from_u64(23); let __v_22: G = G::from_u64(21); let __v_23: G = G::from_u64(149); let __v_24: G = G::from_u64(237); let __v_25: G = G::from_u64(204); let __v_26: G = G::from_u64(246); let __v_27: G = G::from_u64(148); let __v_28: G = G::from_u64(151); let __v_29: G = G::from_u64(55); 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_13, __v_5, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_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_179] = [__v_30]; record.function_queries[179].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_180: usize = 0; const IN_180: usize = 0; const OUT_180: usize = 1; -fn aiur_fn_180(inp: [G; IN_180], 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 = G::from_u64(92); let __v_1: G = G::from_u64(21); let __v_2: G = G::from_u64(249); let __v_3: G = G::from_u64(142); let __v_4: G = G::from_u64(43); let __v_5: G = G::from_u64(217); let __v_6: G = G::from_u64(194); let __v_7: G = G::from_u64(87); let __v_8: G = G::from_u64(188); let __v_9: G = G::from_u64(223); let __v_10: G = G::from_u64(172); let __v_11: G = G::from_u64(98); let __v_12: G = G::from_u64(176); let __v_13: G = G::from_u64(4); let __v_14: G = G::from_u64(58); let __v_15: G = G::from_u64(46); let __v_16: G = G::from_u64(62); let __v_17: G = G::from_u64(189); let __v_18: G = G::from_u64(255); let __v_19: G = G::from_u64(139); let __v_20: G = G::from_u64(33); let __v_21: G = G::from_u64(15); let __v_22: G = G::from_u64(16); let __v_23: G = G::from_u64(75); let __v_24: G = G::from_u64(55); let __v_25: G = G::from_u64(57); let __v_26: G = G::from_u64(232); let __v_27: G = G::from_u64(12); let __v_28: 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_4, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_0, __v_24, __v_25, __v_26, __v_11, __v_10, __v_27]; 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_180] = [__v_28]; record.function_queries[180].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(217); let __v_1: G = G::from_u64(139); let __v_2: G = G::from_u64(237); let __v_3: G = G::from_u64(30); let __v_4: G = G::from_u64(20); let __v_5: G = G::from_u64(205); let __v_6: G = G::from_u64(160); let __v_7: G = G::from_u64(238); let __v_8: G = G::from_u64(164); let __v_9: G = G::from_u64(112); let __v_10: G = G::from_u64(165); let __v_11: G = G::from_u64(159); let __v_12: G = G::from_u64(247); let __v_13: G = G::from_u64(146); let __v_14: G = G::from_u64(108); let __v_15: G = G::from_u64(128); let __v_16: G = G::from_u64(235); let __v_17: G = G::from_u64(75); let __v_18: G = G::from_u64(199); let __v_19: G = G::from_u64(191); let __v_20: G = G::from_u64(189); let __v_21: G = G::from_u64(208); let __v_22: G = G::from_u64(195); let __v_23: G = G::from_u64(225); let __v_24: G = G::from_u64(77); let __v_25: G = G::from_u64(170); let __v_26: G = G::from_u64(92); let __v_27: G = G::from_u64(45); let __v_28: G = G::from_u64(215); let __v_29: 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_8, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_17, __v_25, __v_26, __v_27, __v_21, __v_28]; 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_180] = [__v_29]; record.function_queries[180].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_181: usize = 0; const IN_181: usize = 0; const OUT_181: usize = 1; -fn aiur_fn_181(inp: [G; IN_181], 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 = G::from_u64(63); let __v_1: G = G::from_u64(146); let __v_2: G = G::from_u64(114); let __v_3: G = G::from_u64(83); let __v_4: G = G::from_u64(36); let __v_5: G = G::from_u64(176); let __v_6: G = G::from_u64(159); let __v_7: G = G::from_u64(167); let __v_8: G = G::from_u64(92); let __v_9: G = G::from_u64(111); let __v_10: G = G::from_u64(205); let __v_11: G = G::from_u64(22); let __v_12: G = G::from_u64(218); let __v_13: G = G::from_u64(134); let __v_14: G = G::from_u64(54); let __v_15: G = G::from_u64(113); let __v_16: G = G::from_u64(66); let __v_17: G = G::from_u64(143); let __v_18: G = G::from_u64(243); let __v_19: G = G::from_u64(59); let __v_20: G = G::from_u64(125); let __v_21: G = G::from_u64(182); let __v_22: G = G::from_u64(103); let __v_23: G = G::from_u64(235); let __v_24: G = G::from_u64(118); let __v_25: G = G::from_u64(14); let __v_26: G = G::from_u64(28); let __v_27: G = G::from_u64(213); let __v_28: G = G::from_u64(3); let __v_29: G = G::from_u64(162); let __v_30: G = G::from_u64(188); let __v_31: G = G::from_u64(173); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_181] = [__v_32]; record.function_queries[181].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(136); let __v_1: G = G::from_u64(255); let __v_2: G = G::from_u64(52); let __v_3: G = G::from_u64(221); let __v_4: G = G::from_u64(66); let __v_5: G = G::from_u64(229); let __v_6: G = G::from_u64(119); let __v_7: G = G::from_u64(102); let __v_8: G = G::from_u64(190); let __v_9: G = G::from_u64(239); let __v_10: G = G::from_u64(194); let __v_11: G = G::from_u64(41); let __v_12: G = G::from_u64(216); let __v_13: G = G::from_u64(182); let __v_14: G = G::from_u64(45); let __v_15: G = G::from_u64(171); let __v_16: G = G::from_u64(186); let __v_17: G = G::from_u64(156); let __v_18: G = G::from_u64(106); let __v_19: G = G::from_u64(173); let __v_20: G = G::from_u64(204); let __v_21: G = G::from_u64(133); let __v_22: G = G::from_u64(200); let __v_23: G = G::from_u64(138); let __v_24: G = G::from_u64(214); let __v_25: G = G::from_u64(115); let __v_26: G = G::from_u64(35); let __v_27: G = G::from_u64(208); let __v_28: G = G::from_u64(43); let __v_29: G = G::from_u64(191); let __v_30: G = G::from_u64(33); let __v_31: 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_9, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_181] = [__v_31]; record.function_queries[181].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_182: usize = 0; const IN_182: usize = 0; const OUT_182: usize = 1; -fn aiur_fn_182(inp: [G; IN_182], 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 = G::from_u64(255); let __v_1: G = G::from_u64(211); let __v_2: G = G::from_u64(240); let __v_3: G = G::from_u64(42); let __v_4: G = G::from_u64(25); let __v_5: G = G::from_u64(253); let __v_6: G = G::from_u64(166); let __v_7: G = G::from_u64(73); let __v_8: G = G::from_u64(170); let __v_9: G = G::from_u64(86); let __v_10: G = G::from_u64(8); let __v_11: G = G::from_u64(237); let __v_12: G = G::from_u64(129); let __v_13: G = G::from_u64(141); let __v_14: G = G::from_u64(179); let __v_15: G = G::from_u64(130); let __v_16: G = G::from_u64(225); let __v_17: G = G::from_u64(96); let __v_18: G = G::from_u64(35); let __v_19: G = G::from_u64(27); let __v_20: G = G::from_u64(118); let __v_21: G = G::from_u64(213); let __v_22: G = G::from_u64(176); let __v_23: G = G::from_u64(145); let __v_24: G = G::from_u64(215); let __v_25: G = G::from_u64(221); let __v_26: G = G::from_u64(26); let __v_27: G = G::from_u64(91); let __v_28: G = G::from_u64(30); let __v_29: G = G::from_u64(197); 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_20, __v_24, __v_25, __v_26, __v_13, __v_27, __v_28, __v_29]; 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_182] = [__v_30]; record.function_queries[182].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_182(inp: [G; IN_182], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(27); let __v_1: G = G::from_u64(10); let __v_2: G = G::from_u64(205); let __v_3: G = G::from_u64(212); let __v_4: G = G::from_u64(8); let __v_5: G = G::from_u64(190); let __v_6: G = G::from_u64(91); let __v_7: G = G::from_u64(196); let __v_8: G = G::from_u64(172); let __v_9: G = G::from_u64(181); let __v_10: G = G::from_u64(240); let __v_11: G = G::from_u64(101); let __v_12: G = G::from_u64(39); let __v_13: G = G::from_u64(203); let __v_14: G = G::from_u64(98); let __v_15: G = G::from_u64(173); let __v_16: G = G::from_u64(146); let __v_17: G = G::from_u64(121); let __v_18: G = G::from_u64(46); let __v_19: G = G::from_u64(180); let __v_20: G = G::from_u64(41); let __v_21: G = G::from_u64(194); let __v_22: G = G::from_u64(179); let __v_23: G = G::from_u64(188); let __v_24: G = G::from_u64(182); let __v_25: G = G::from_u64(244); let __v_26: G = G::from_u64(113); let __v_27: G = G::from_u64(215); let __v_28: G = G::from_u64(148); let __v_29: G = G::from_u64(80); let __v_30: G = G::from_u64(133); let __v_31: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_182] = [__v_31]; record.function_queries[182].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_183: usize = 0; const IN_183: usize = 0; 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 = G::from_u64(104); let __v_1: G = G::from_u64(163); let __v_2: G = G::from_u64(100); let __v_3: G = G::from_u64(62); let __v_4: G = G::from_u64(198); let __v_5: G = G::from_u64(152); let __v_6: G = G::from_u64(22); let __v_7: G = G::from_u64(174); let __v_8: G = G::from_u64(193); let __v_9: G = G::from_u64(7); let __v_10: G = G::from_u64(48); let __v_11: G = G::from_u64(45); let __v_12: G = G::from_u64(219); let __v_13: G = G::from_u64(250); let __v_14: G = G::from_u64(5); let __v_15: G = G::from_u64(76); let __v_16: G = G::from_u64(235); let __v_17: G = G::from_u64(205); let __v_18: G = G::from_u64(115); let __v_19: G = G::from_u64(95); let __v_20: G = G::from_u64(126); let __v_21: G = G::from_u64(109); let __v_22: G = G::from_u64(136); let __v_23: G = G::from_u64(54); let __v_24: G = G::from_u64(56); let __v_25: G = G::from_u64(99); let __v_26: G = G::from_u64(26); let __v_27: G = G::from_u64(254); let __v_28: G = G::from_u64(101); let __v_29: 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_3, __v_8, __v_18, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_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_183] = [__v_29]; record.function_queries[183].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_183(inp: [G; IN_183], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(5); let __v_1: G = G::from_u64(187); let __v_2: G = G::from_u64(101); let __v_3: G = G::from_u64(126); let __v_4: G = G::from_u64(139); let __v_5: G = G::from_u64(157); let __v_6: G = G::from_u64(93); let __v_7: G = G::from_u64(194); let __v_8: G = G::from_u64(36); let __v_9: G = G::from_u64(231); let __v_10: G = G::from_u64(239); let __v_11: G = G::from_u64(61); let __v_12: G = G::from_u64(83); let __v_13: G = G::from_u64(229); let __v_14: G = G::from_u64(65); let __v_15: G = G::from_u64(206); let __v_16: G = G::from_u64(58); let __v_17: G = G::from_u64(109); let __v_18: G = G::from_u64(168); let __v_19: G = G::from_u64(209); let __v_20: G = G::from_u64(241); let __v_21: G = G::from_u64(177); let __v_22: G = G::from_u64(214); let __v_23: G = G::from_u64(16); let __v_24: G = G::from_u64(105); let __v_25: G = G::from_u64(163); let __v_26: G = G::from_u64(114); let __v_27: G = G::from_u64(102); let __v_28: G = G::from_u64(205); let __v_29: 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_12, __v_15, __v_16, __v_7, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_2, __v_27, __v_28]; 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_183] = [__v_29]; record.function_queries[183].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_184: usize = 0; const IN_184: usize = 0; 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 = G::from_u64(162); let __v_1: G = G::from_u64(154); let __v_2: G = G::from_u64(99); let __v_3: G = G::from_u64(97); let __v_4: G = G::from_u64(118); let __v_5: G = G::from_u64(207); let __v_6: G = G::from_u64(17); let __v_7: G = G::from_u64(53); let __v_8: G = G::from_u64(208); let __v_9: G = G::from_u64(119); let __v_10: G = G::from_u64(235); let __v_11: G = G::from_u64(7); let __v_12: G = G::from_u64(71); let __v_13: G = G::from_u64(152); let __v_14: G = G::from_u64(249); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(124); let __v_17: G = G::from_u64(120); let __v_18: G = G::from_u64(231); let __v_19: G = G::from_u64(128); let __v_20: G = G::from_u64(19); let __v_21: G = G::from_u64(131); let __v_22: G = G::from_u64(233); let __v_23: G = G::from_u64(243); let __v_24: G = G::from_u64(186); let __v_25: G = G::from_u64(229); let __v_26: G = G::from_u64(237); let __v_27: G = G::from_u64(240); let __v_28: G = G::from_u64(87); let __v_29: G = G::from_u64(98); 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_5, __v_23, __v_2, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_184] = [__v_30]; record.function_queries[184].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_184(inp: [G; IN_184], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(37); let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(159); let __v_3: G = G::from_u64(244); let __v_4: G = G::from_u64(133); let __v_5: G = G::from_u64(252); let __v_6: G = G::from_u64(245); let __v_7: G = G::from_u64(112); let __v_8: G = G::from_u64(149); let __v_9: G = G::from_u64(151); let __v_10: G = G::from_u64(205); let __v_11: G = G::from_u64(30); let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(195); let __v_14: G = G::from_u64(206); let __v_15: G = G::from_u64(121); let __v_16: G = G::from_u64(103); let __v_17: G = G::from_u64(118); let __v_18: G = G::from_u64(239); let __v_19: G = G::from_u64(63); let __v_20: G = G::from_u64(113); let __v_21: G = G::from_u64(90); let __v_22: G = G::from_u64(109); let __v_23: G = G::from_u64(24); let __v_24: G = G::from_u64(126); let __v_25: G = G::from_u64(181); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(28); let __v_28: G = G::from_u64(99); let __v_29: G = G::from_u64(180); let __v_30: G = G::from_u64(190); let __v_31: 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_5, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_184] = [__v_31]; record.function_queries[184].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_185: usize = 0; const IN_185: usize = 0; const OUT_185: usize = 1; -fn aiur_fn_185(inp: [G; IN_185], 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 = G::from_u64(221); let __v_1: G = G::from_u64(161); let __v_2: G = G::from_u64(43); let __v_3: G = G::from_u64(203); let __v_4: G = G::from_u64(51); let __v_5: G = G::from_u64(7); let __v_6: G = G::from_u64(39); let __v_7: G = G::from_u64(246); let __v_8: G = G::from_u64(223); let __v_9: G = G::from_u64(184); let __v_10: G = G::from_u64(22); let __v_11: G = G::from_u64(188); let __v_12: G = G::from_u64(151); let __v_13: G = G::from_u64(82); let __v_14: G = G::from_u64(170); let __v_15: G = G::from_u64(189); let __v_16: G = G::from_u64(5); let __v_17: G = G::from_u64(32); let __v_18: G = G::from_u64(230); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(91); let __v_21: G = G::from_u64(121); let __v_22: G = G::from_u64(252); let __v_23: G = G::from_u64(138); let __v_24: G = G::from_u64(90); let __v_25: G = G::from_u64(158); let __v_26: G = G::from_u64(113); let __v_27: G = G::from_u64(56); let __v_28: G = G::from_u64(102); let __v_29: G = G::from_u64(244); let __v_30: G = G::from_u64(198); let __v_31: G = G::from_u64(62); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_185] = [__v_32]; record.function_queries[185].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_185(inp: [G; IN_185], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(211); let __v_1: G = G::from_u64(216); let __v_2: G = G::from_u64(255); let __v_3: G = G::from_u64(146); let __v_4: G = G::from_u64(74); let __v_5: G = G::from_u64(249); let __v_6: G = G::from_u64(220); let __v_7: G = G::from_u64(75); let __v_8: G = G::from_u64(92); let __v_9: G = G::from_u64(105); let __v_10: G = G::from_u64(118); let __v_11: G = G::from_u64(6); let __v_12: G = G::from_u64(21); let __v_13: G = G::from_u64(179); let __v_14: G = G::from_u64(231); let __v_15: G = G::from_u64(238); let __v_16: G = G::from_u64(128); let __v_17: G = G::from_u64(145); let __v_18: G = G::from_u64(107); let __v_19: G = G::from_u64(182); let __v_20: G = G::from_u64(23); let __v_21: G = G::from_u64(37); let __v_22: G = G::from_u64(157); let __v_23: G = G::from_u64(69); let __v_24: G = G::from_u64(137); let __v_25: G = G::from_u64(12); let __v_26: G = G::from_u64(244); let __v_27: G = G::from_u64(18); let __v_28: G = G::from_u64(131); let __v_29: G = G::from_u64(55); 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_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_21, __v_22, __v_23, __v_24, __v_25, __v_9, __v_26, __v_27, __v_28, __v_29]; 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_185] = [__v_30]; record.function_queries[185].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_186: usize = 0; const IN_186: usize = 0; 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 = G::from_u64(111); let __v_1: G = G::from_u64(98); let __v_2: G = G::from_u64(6); let __v_3: G = G::from_u64(84); let __v_4: G = G::from_u64(211); let __v_5: G = G::from_u64(65); let __v_6: G = G::from_u64(153); let __v_7: G = G::from_u64(10); let __v_8: G = G::from_u64(48); let __v_9: G = G::from_u64(19); let __v_10: G = G::from_u64(135); let __v_11: G = G::from_u64(184); let __v_12: G = G::from_u64(14); let __v_13: G = G::from_u64(247); let __v_14: G = G::from_u64(91); let __v_15: G = G::from_u64(30); let __v_16: G = G::from_u64(11); let __v_17: G = G::from_u64(97); let __v_18: G = G::from_u64(221); let __v_19: G = G::from_u64(241); let __v_20: G = G::from_u64(145); let __v_21: G = G::from_u64(100); let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(109); let __v_24: G = G::from_u64(195); let __v_25: G = G::from_u64(123); let __v_26: G = G::from_u64(243); let __v_27: G = G::from_u64(220); let __v_28: G = G::from_u64(24); let __v_29: 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_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_14, __v_23, __v_24, __v_25, __v_26, __v_24, __v_27, __v_28]; 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_186] = [__v_29]; record.function_queries[186].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_186(inp: [G; IN_186], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(158); let __v_1: G = G::from_u64(68); let __v_2: G = G::from_u64(91); let __v_3: G = G::from_u64(157); let __v_4: G = G::from_u64(95); let __v_5: G = G::from_u64(130); let __v_6: G = G::from_u64(82); let __v_7: G = G::from_u64(119); let __v_8: G = G::from_u64(35); let __v_9: G = G::from_u64(71); let __v_10: G = G::from_u64(135); let __v_11: G = G::from_u64(46); let __v_12: G = G::from_u64(144); let __v_13: G = G::from_u64(155); let __v_14: G = G::from_u64(93); let __v_15: G = G::from_u64(180); let __v_16: G = G::from_u64(231); let __v_17: G = G::from_u64(236); let __v_18: G = G::from_u64(167); let __v_19: G = G::from_u64(8); let __v_20: G = G::from_u64(108); let __v_21: G = G::from_u64(237); let __v_22: G = G::from_u64(244); let __v_23: G = G::from_u64(254); let __v_24: G = G::from_u64(198); let __v_25: G = G::from_u64(222); let __v_26: G = G::from_u64(132); let __v_27: G = G::from_u64(15); let __v_28: G = G::from_u64(107); let __v_29: G = G::from_u64(123); let __v_30: G = G::from_u64(146); let __v_31: 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_4, __v_30]; 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_186] = [__v_31]; record.function_queries[186].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_187: usize = 0; const IN_187: usize = 0; 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 = G::from_u64(232); let __v_1: G = G::from_u64(91); let __v_2: G = G::from_u64(245); let __v_3: G = G::from_u64(22); let __v_4: G = G::from_u64(199); let __v_5: G = G::from_u64(108); let __v_6: G = G::from_u64(173); let __v_7: G = G::from_u64(216); let __v_8: G = G::from_u64(206); let __v_9: G = G::from_u64(31); let __v_10: G = G::from_u64(218); let __v_11: G = G::from_u64(179); let __v_12: G = G::from_u64(204); let __v_13: G = G::from_u64(148); let __v_14: G = G::from_u64(237); let __v_15: G = G::from_u64(104); let __v_16: G = G::from_u64(94); let __v_17: G = G::from_u64(71); let __v_18: G = G::from_u64(190); let __v_19: G = G::from_u64(60); let __v_20: G = G::from_u64(122); let __v_21: G = G::from_u64(139); let __v_22: G = G::from_u64(82); let __v_23: G = G::from_u64(63); let __v_24: G = G::from_u64(226); let __v_25: G = G::from_u64(80); let __v_26: G = G::from_u64(46); let __v_27: G = G::from_u64(111); let __v_28: G = G::from_u64(112); let __v_29: 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_2, __v_23, __v_24, __v_11, __v_25, __v_26, __v_27, __v_28, __v_4]; 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_187] = [__v_29]; record.function_queries[187].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_187(inp: [G; IN_187], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(162); let __v_1: G = G::from_u64(154); let __v_2: G = G::from_u64(99); let __v_3: G = G::from_u64(97); let __v_4: G = G::from_u64(118); let __v_5: G = G::from_u64(207); let __v_6: G = G::from_u64(17); let __v_7: G = G::from_u64(53); let __v_8: G = G::from_u64(208); let __v_9: G = G::from_u64(119); let __v_10: G = G::from_u64(235); let __v_11: G = G::from_u64(7); let __v_12: G = G::from_u64(71); let __v_13: G = G::from_u64(152); let __v_14: G = G::from_u64(249); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(124); let __v_17: G = G::from_u64(120); let __v_18: G = G::from_u64(231); let __v_19: G = G::from_u64(128); let __v_20: G = G::from_u64(19); let __v_21: G = G::from_u64(131); let __v_22: G = G::from_u64(233); let __v_23: G = G::from_u64(243); let __v_24: G = G::from_u64(186); let __v_25: G = G::from_u64(229); let __v_26: G = G::from_u64(237); let __v_27: G = G::from_u64(240); let __v_28: G = G::from_u64(87); let __v_29: G = G::from_u64(98); 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_5, __v_23, __v_2, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_187] = [__v_30]; record.function_queries[187].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_188: usize = 0; const IN_188: usize = 0; 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 = G::from_u64(186); let __v_1: G = G::from_u64(204); let __v_2: G = G::from_u64(76); let __v_3: G = G::from_u64(129); let __v_4: G = G::from_u64(74); let __v_5: G = G::from_u64(69); let __v_6: G = G::from_u64(114); let __v_7: G = G::from_u64(221); let __v_8: G = G::from_u64(253); let __v_9: G = G::from_u64(150); let __v_10: G = G::from_u64(154); let __v_11: G = G::from_u64(24); let __v_12: G = G::from_u64(87); let __v_13: G = G::from_u64(173); let __v_14: G = G::from_u64(254); let __v_15: G = G::from_u64(35); let __v_16: G = G::from_u64(158); let __v_17: G = G::from_u64(182); let __v_18: G = G::from_u64(189); let __v_19: G = G::from_u64(139); let __v_20: G = G::from_u64(22); let __v_21: G = G::from_u64(39); let __v_22: G = G::from_u64(238); let __v_23: G = G::from_u64(121); let __v_24: G = G::from_u64(116); let __v_25: G = G::from_u64(106); let __v_26: G = G::from_u64(155); let __v_27: G = G::from_u64(176); let __v_28: G = G::from_u64(48); let __v_29: 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_11, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_4, __v_25, __v_26, __v_15, __v_27, __v_28]; 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_188] = [__v_29]; record.function_queries[188].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_188(inp: [G; IN_188], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(221); let __v_1: G = G::from_u64(161); let __v_2: G = G::from_u64(43); let __v_3: G = G::from_u64(203); let __v_4: G = G::from_u64(51); let __v_5: G = G::from_u64(7); let __v_6: G = G::from_u64(39); let __v_7: G = G::from_u64(246); let __v_8: G = G::from_u64(223); let __v_9: G = G::from_u64(184); let __v_10: G = G::from_u64(22); let __v_11: G = G::from_u64(188); let __v_12: G = G::from_u64(151); let __v_13: G = G::from_u64(82); let __v_14: G = G::from_u64(170); let __v_15: G = G::from_u64(189); let __v_16: G = G::from_u64(5); let __v_17: G = G::from_u64(32); let __v_18: G = G::from_u64(230); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(91); let __v_21: G = G::from_u64(121); let __v_22: G = G::from_u64(252); let __v_23: G = G::from_u64(138); let __v_24: G = G::from_u64(90); let __v_25: G = G::from_u64(158); let __v_26: G = G::from_u64(113); let __v_27: G = G::from_u64(56); let __v_28: G = G::from_u64(102); let __v_29: G = G::from_u64(244); let __v_30: G = G::from_u64(198); let __v_31: G = G::from_u64(62); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_188] = [__v_32]; record.function_queries[188].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_189: usize = 0; const IN_189: usize = 0; 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 = G::from_u64(182); let __v_1: G = G::from_u64(50); let __v_2: G = G::from_u64(125); let __v_3: G = G::from_u64(154); let __v_4: G = G::from_u64(27); let __v_5: G = G::from_u64(187); let __v_6: G = G::from_u64(70); let __v_7: G = G::from_u64(26); let __v_8: G = G::from_u64(68); let __v_9: G = G::from_u64(127); let __v_10: G = G::from_u64(12); let __v_11: G = G::from_u64(151); let __v_12: G = G::from_u64(30); let __v_13: G = G::from_u64(98); let __v_14: G = G::from_u64(45); let __v_15: G = G::from_u64(217); let __v_16: G = G::from_u64(163); let __v_17: G = G::from_u64(81); let __v_18: G = G::from_u64(189); let __v_19: G = G::from_u64(231); let __v_20: G = G::from_u64(91); let __v_21: G = G::from_u64(246); let __v_22: G = G::from_u64(158); let __v_23: G = G::from_u64(32); let __v_24: G = G::from_u64(121); let __v_25: G = G::from_u64(77); let __v_26: G = G::from_u64(122); let __v_27: G = G::from_u64(14); let __v_28: G = G::from_u64(133); let __v_29: G = G::from_u64(149); 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_1, __v_18, __v_2, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_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_189] = [__v_30]; record.function_queries[189].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(87); let __v_1: G = G::from_u64(163); let __v_2: G = G::from_u64(28); let __v_3: G = G::from_u64(30); let __v_4: G = G::from_u64(52); let __v_5: G = G::from_u64(207); let __v_6: G = G::from_u64(57); let __v_7: G = G::from_u64(147); let __v_8: G = G::from_u64(178); let __v_9: G = G::from_u64(9); let __v_10: G = G::from_u64(221); let __v_11: G = G::from_u64(41); let __v_12: G = G::from_u64(186); let __v_13: G = G::from_u64(39); let __v_14: G = G::from_u64(38); let __v_15: G = G::from_u64(63); let __v_16: G = G::from_u64(36); let __v_17: G = G::from_u64(251); let __v_18: G = G::from_u64(190); let __v_19: G = G::from_u64(237); let __v_20: G = G::from_u64(226); let __v_21: G = G::from_u64(246); let __v_22: G = G::from_u64(166); let __v_23: G = G::from_u64(208); let __v_24: G = G::from_u64(137); let __v_25: G = G::from_u64(184); let __v_26: G = G::from_u64(5); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(227); let __v_29: G = G::from_u64(44); let __v_30: G = G::from_u64(60); let __v_31: 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_6, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_189] = [__v_31]; record.function_queries[189].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_190: usize = 0; const IN_190: usize = 0; const OUT_190: usize = 1; -fn aiur_fn_190(inp: [G; IN_190], 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 = G::from_u64(234); let __v_1: G = G::from_u64(101); let __v_2: G = G::from_u64(245); let __v_3: G = G::from_u64(23); let __v_4: G = G::from_u64(69); let __v_5: G = G::from_u64(127); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(155); let __v_8: G = G::from_u64(112); let __v_9: G = G::from_u64(82); let __v_10: G = G::from_u64(153); let __v_11: G = G::from_u64(218); let __v_12: G = G::from_u64(8); let __v_13: G = G::from_u64(176); let __v_14: G = G::from_u64(211); let __v_15: G = G::from_u64(200); let __v_16: G = G::from_u64(207); let __v_17: G = G::from_u64(154); let __v_18: G = G::from_u64(71); let __v_19: G = G::from_u64(111); let __v_20: G = G::from_u64(22); let __v_21: G = G::from_u64(12); let __v_22: G = G::from_u64(202); let __v_23: G = G::from_u64(92); let __v_24: G = G::from_u64(94); let __v_25: G = G::from_u64(167); let __v_26: G = G::from_u64(189); let __v_27: G = G::from_u64(35); let __v_28: G = G::from_u64(130); let __v_29: G = G::from_u64(48); 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_18, __v_21, __v_22, __v_23, __v_6, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_190] = [__v_30]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(82); let __v_1: G = G::from_u64(54); let __v_2: G = G::from_u64(153); let __v_3: G = G::from_u64(182); let __v_4: G = G::from_u64(232); let __v_5: G = G::from_u64(39); let __v_6: G = G::from_u64(183); let __v_7: G = G::from_u64(74); let __v_8: G = G::from_u64(149); let __v_9: G = G::from_u64(13); let __v_10: G = G::from_u64(71); let __v_11: G = G::from_u64(24); let __v_12: G = G::from_u64(189); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(177); let __v_15: G = G::from_u64(60); let __v_16: G = G::from_u64(25); let __v_17: G = G::from_u64(62); let __v_18: G = G::from_u64(124); let __v_19: G = G::from_u64(55); let __v_20: G = G::from_u64(26); let __v_21: G = G::from_u64(170); let __v_22: G = G::from_u64(212); let __v_23: G = G::from_u64(214); let __v_24: G = G::from_u64(53); let __v_25: G = G::from_u64(102); let __v_26: G = G::from_u64(123); let __v_27: G = G::from_u64(231); let __v_28: G = G::from_u64(75); let __v_29: G = G::from_u64(5); let __v_30: G = G::from_u64(250); let __v_31: 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_15, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_190] = [__v_31]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_191: usize = 0; const IN_191: usize = 0; const OUT_191: usize = 1; -fn aiur_fn_191(inp: [G; IN_191], 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 = G::from_u64(0); let __v_1: G = G::from_u64(194); let __v_2: G = G::from_u64(102); let __v_3: G = G::from_u64(131); let __v_4: G = G::from_u64(79); let __v_5: G = G::from_u64(144); let __v_6: G = G::from_u64(57); let __v_7: G = G::from_u64(147); let __v_8: G = G::from_u64(27); let __v_9: G = G::from_u64(75); let __v_10: G = G::from_u64(226); let __v_11: G = G::from_u64(250); let __v_12: G = G::from_u64(197); let __v_13: G = G::from_u64(88); let __v_14: G = G::from_u64(76); let __v_15: G = G::from_u64(209); let __v_16: G = G::from_u64(118); let __v_17: G = G::from_u64(160); let __v_18: G = G::from_u64(174); let __v_19: G = G::from_u64(126); let __v_20: G = G::from_u64(228); let __v_21: G = G::from_u64(203); let __v_22: G = G::from_u64(64); let __v_23: G = G::from_u64(100); let __v_24: G = G::from_u64(221); let __v_25: G = G::from_u64(181); let __v_26: G = G::from_u64(224); let __v_27: G = G::from_u64(77); let __v_28: G = G::from_u64(43); let __v_29: G = G::from_u64(108); let __v_30: G = G::from_u64(187); let __v_31: 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_15, __v_28, __v_29, __v_30]; 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_191] = [__v_31]; 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; +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 = G::from_u64(186); let __v_1: G = G::from_u64(204); let __v_2: G = G::from_u64(76); let __v_3: G = G::from_u64(129); let __v_4: G = G::from_u64(74); let __v_5: G = G::from_u64(69); let __v_6: G = G::from_u64(114); let __v_7: G = G::from_u64(221); let __v_8: G = G::from_u64(253); let __v_9: G = G::from_u64(150); let __v_10: G = G::from_u64(154); let __v_11: G = G::from_u64(24); let __v_12: G = G::from_u64(87); let __v_13: G = G::from_u64(173); let __v_14: G = G::from_u64(254); let __v_15: G = G::from_u64(35); let __v_16: G = G::from_u64(158); let __v_17: G = G::from_u64(182); let __v_18: G = G::from_u64(189); let __v_19: G = G::from_u64(139); let __v_20: G = G::from_u64(22); let __v_21: G = G::from_u64(39); let __v_22: G = G::from_u64(238); let __v_23: G = G::from_u64(121); let __v_24: G = G::from_u64(116); let __v_25: G = G::from_u64(106); let __v_26: G = G::from_u64(155); let __v_27: G = G::from_u64(176); let __v_28: G = G::from_u64(48); let __v_29: 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_11, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_4, __v_25, __v_26, __v_15, __v_27, __v_28]; 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_191] = [__v_29]; record.function_queries[191].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_192: usize = 0; +const IN_192: usize = 0; const OUT_192: usize = 1; -fn aiur_fn_192(inp: [G; IN_192], 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 __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; 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_1: G = __r_arr[0]; 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_192] = [__v_3]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_192] = [__v_5]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_192] = [__v_7]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_192] = [__v_9]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_192] = [__v_11]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_192] = [__v_11]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }) } +fn aiur_fn_192(inp: [G; IN_192], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(182); let __v_1: G = G::from_u64(50); let __v_2: G = G::from_u64(125); let __v_3: G = G::from_u64(154); let __v_4: G = G::from_u64(27); let __v_5: G = G::from_u64(187); let __v_6: G = G::from_u64(70); let __v_7: G = G::from_u64(26); let __v_8: G = G::from_u64(68); let __v_9: G = G::from_u64(127); let __v_10: G = G::from_u64(12); let __v_11: G = G::from_u64(151); let __v_12: G = G::from_u64(30); let __v_13: G = G::from_u64(98); let __v_14: G = G::from_u64(45); let __v_15: G = G::from_u64(217); let __v_16: G = G::from_u64(163); let __v_17: G = G::from_u64(81); let __v_18: G = G::from_u64(189); let __v_19: G = G::from_u64(231); let __v_20: G = G::from_u64(91); let __v_21: G = G::from_u64(246); let __v_22: G = G::from_u64(158); let __v_23: G = G::from_u64(32); let __v_24: G = G::from_u64(121); let __v_25: G = G::from_u64(77); let __v_26: G = G::from_u64(122); let __v_27: G = G::from_u64(14); let __v_28: G = G::from_u64(133); let __v_29: G = G::from_u64(149); 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_1, __v_18, __v_2, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_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_192] = [__v_30]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_193: usize = 0; const IN_193: usize = 0; const OUT_193: usize = 1; -fn aiur_fn_193(inp: [G; IN_193], 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 = G::from_u64(0); let __v_1: G = G::from_u64(64); 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_0, __v_1, __v_0, __v_0, __v_0, __v_0, __v_0, __v_0, __v_0, __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 __v_5: G = G::from_u64(7); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_0, __v_4, __v_0]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __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_6]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(209); let __v_1: G = G::from_u64(191); let __v_2: G = G::from_u64(236); let __v_3: G = G::from_u64(141); let __v_4: G = G::from_u64(249); let __v_5: G = G::from_u64(8); let __v_6: G = G::from_u64(200); let __v_7: G = G::from_u64(135); let __v_8: G = G::from_u64(228); let __v_9: G = G::from_u64(244); let __v_10: G = G::from_u64(137); let __v_11: G = G::from_u64(173); let __v_12: G = G::from_u64(194); let __v_13: G = G::from_u64(238); let __v_14: G = G::from_u64(199); let __v_15: G = G::from_u64(122); let __v_16: G = G::from_u64(83); let __v_17: G = G::from_u64(232); let __v_18: G = G::from_u64(255); let __v_19: G = G::from_u64(40); let __v_20: G = G::from_u64(181); let __v_21: G = G::from_u64(189); let __v_22: G = G::from_u64(154); let __v_23: G = G::from_u64(76); let __v_24: G = G::from_u64(33); let __v_25: G = G::from_u64(165); let __v_26: G = G::from_u64(109); let __v_27: G = G::from_u64(166); let __v_28: G = G::from_u64(56); let __v_29: G = G::from_u64(30); let __v_30: G = G::from_u64(237); let __v_31: G = G::from_u64(143); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_193] = [__v_32]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_194: usize = 0; const IN_194: usize = 0; const OUT_194: usize = 1; -fn aiur_fn_194(inp: [G; IN_194], 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 = G::from_u64(0); let __v_1: G = G::from_u64(1); let __v_2: G = { let __values: [G; 10] = [__v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1]; 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_3: G = { let __values: [G; 10] = [__v_0, __v_1, __v_0, __v_0, __v_0, __v_0, __v_0, __v_0, __v_0, __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(7); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_0, __v_3, __v_0]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_194] = [__v_5]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_195: usize = 3; -const IN_195: usize = 3; -const OUT_195: usize = 2; -fn aiur_fn_195(inp: [G; IN_195], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; 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 __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_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_193] = { let __args: [G; IN_193] = []; 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_6: G = __r_arr[0]; let __ret: [G; OUT_195] = [__v_5, __v_6]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; 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_8: G = __r_arr[0]; let __ret: [G; OUT_195] = [__v_7, __v_8]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_9, __v_10]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); match __v_13.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_195] = [__v_14, __v_15]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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 __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_16.as_canonical_u64() { 1u64 => { 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_195] = [__v_17, __v_18]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_18, __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_19: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_19]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_20, __v_21]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_19]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_20, __v_21]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_196: usize = 1; -const IN_196: usize = 1; -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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); 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() { 1u64 => { 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_196] = [__v_4, __v_5]; record.function_queries[196].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_191] = { let __args: [G; IN_191] = []; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; 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_15: G = __r_arr[0]; let __ret: [G; OUT_196] = [__v_14, __v_15]; record.function_queries[196].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_196] = [__v_14, __v_15]; record.function_queries[196].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_196] = [__v_12, __v_13]; record.function_queries[196].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_197: usize = 1; -const IN_197: usize = 1; -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 __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_184] = { let __args: [G; IN_184] = []; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_7]; 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 = (__v_6 + __v_8); match __v_9.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_197] = [__v_10, __v_11]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_197] = [__v_10, __v_0]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { 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_197] = [__v_5, __v_6]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_198: usize = 1; -const IN_198: 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 = G::from_u64(35); let __v_1: G = G::from_u64(110); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(189); let __v_4: G = G::from_u64(225); let __v_5: G = G::from_u64(245); let __v_6: G = G::from_u64(147); let __v_7: G = G::from_u64(9); let __v_8: G = G::from_u64(194); let __v_9: G = G::from_u64(204); let __v_10: G = G::from_u64(104); let __v_11: G = G::from_u64(90); let __v_12: G = G::from_u64(115); let __v_13: G = G::from_u64(121); let __v_14: G = G::from_u64(188); let __v_15: G = G::from_u64(82); let __v_16: G = G::from_u64(148); let __v_17: G = G::from_u64(169); let __v_18: G = G::from_u64(129); let __v_19: G = G::from_u64(126); let __v_20: G = G::from_u64(89); let __v_21: G = G::from_u64(21); let __v_22: G = G::from_u64(221); let __v_23: G = G::from_u64(75); let __v_24: G = G::from_u64(61); let __v_25: G = G::from_u64(50); let __v_26: G = G::from_u64(132); let __v_27: G = G::from_u64(205); let __v_28: G = G::from_u64(112); let __v_29: 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_13, __v_21, __v_22, __v_9, __v_23, __v_24, __v_6, __v_25, __v_26, __v_27, __v_28]; 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_194] = [__v_29]; 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 __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; 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_1: G = __r_arr[0]; 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_195] = [__v_3]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); 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_191] = { let __args: [G; IN_191] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_195] = [__v_7]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_195] = [__v_9]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_195] = [__v_11]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(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 = 0; +const IN_196: usize = 0; +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 = G::from_u64(0); let __v_1: G = G::from_u64(64); 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_0, __v_1, __v_0, __v_0, __v_0, __v_0, __v_0, __v_0, __v_0, __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 __v_5: G = G::from_u64(7); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_0, __v_4, __v_0]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_196] = [__v_6]; record.function_queries[196].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_197: usize = 0; +const IN_197: usize = 0; +const OUT_197: usize = 1; +fn aiur_fn_197(inp: [G; IN_197], 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 = G::from_u64(0); let __v_1: G = G::from_u64(1); let __v_2: G = { let __values: [G; 10] = [__v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1]; 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_3: G = { let __values: [G; 10] = [__v_0, __v_1, __v_0, __v_0, __v_0, __v_0, __v_0, __v_0, __v_0, __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(7); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_0, __v_3, __v_0]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_197] = [__v_5]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_198: usize = 3; +const IN_198: usize = 3; 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 __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() { 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_5, __v_0]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_198] = [__v_5, __v_6]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { 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_198] = [__v_5, __v_6]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_199: usize = 0; -const IN_199: usize = 0; -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 = G::from_u64(193); let __v_1: G = G::from_u64(16); let __v_2: G = G::from_u64(214); let __v_3: G = G::from_u64(20); let __v_4: G = G::from_u64(180); let __v_5: G = G::from_u64(65); let __v_6: G = G::from_u64(198); let __v_7: G = G::from_u64(204); let __v_8: G = G::from_u64(166); let __v_9: G = G::from_u64(158); let __v_10: G = G::from_u64(205); let __v_11: G = G::from_u64(124); let __v_12: G = G::from_u64(28); let __v_13: G = G::from_u64(44); let __v_14: G = G::from_u64(118); let __v_15: G = G::from_u64(243); let __v_16: G = G::from_u64(188); let __v_17: G = G::from_u64(33); let __v_18: G = G::from_u64(253); let __v_19: G = G::from_u64(64); let __v_20: G = G::from_u64(196); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(30); let __v_23: G = G::from_u64(106); let __v_24: G = G::from_u64(26); let __v_25: G = G::from_u64(125); let __v_26: G = G::from_u64(244); let __v_27: G = G::from_u64(129); let __v_28: G = G::from_u64(226); let __v_29: G = G::from_u64(60); let __v_30: G = G::from_u64(221); let __v_31: 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_12, __v_26, __v_27, __v_28, __v_29, __v_30]; 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_199] = [__v_31]; record.function_queries[199].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_200: usize = 0; -const IN_200: usize = 0; -const OUT_200: usize = 1; -fn aiur_fn_200(inp: [G; IN_200], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(41); let __v_1: G = G::from_u64(185); let __v_2: G = G::from_u64(242); let __v_3: G = G::from_u64(64); let __v_4: G = G::from_u64(134); let __v_5: G = G::from_u64(177); let __v_6: G = G::from_u64(248); let __v_7: G = G::from_u64(130); let __v_8: G = G::from_u64(17); let __v_9: G = G::from_u64(53); let __v_10: G = G::from_u64(136); let __v_11: G = G::from_u64(102); let __v_12: G = G::from_u64(19); let __v_13: G = G::from_u64(159); let __v_14: G = G::from_u64(219); let __v_15: G = G::from_u64(125); let __v_16: G = G::from_u64(205); let __v_17: G = G::from_u64(252); let __v_18: G = G::from_u64(151); let __v_19: G = G::from_u64(181); let __v_20: G = G::from_u64(246); let __v_21: G = G::from_u64(199); let __v_22: G = G::from_u64(127); let __v_23: G = G::from_u64(196); let __v_24: G = G::from_u64(149); let __v_25: G = G::from_u64(191); let __v_26: G = G::from_u64(140); let __v_27: G = G::from_u64(119); let __v_28: G = G::from_u64(99); let __v_29: G = G::from_u64(153); let __v_30: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __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_200] = [__v_30]; record.function_queries[200].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_201: usize = 0; -const IN_201: usize = 0; -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 = G::from_u64(127); let __v_1: G = G::from_u64(15); let __v_2: G = G::from_u64(95); let __v_3: G = G::from_u64(237); let __v_4: G = G::from_u64(161); let __v_5: G = G::from_u64(130); let __v_6: G = G::from_u64(128); let __v_7: G = G::from_u64(114); let __v_8: G = G::from_u64(18); let __v_9: G = G::from_u64(63); let __v_10: G = G::from_u64(36); let __v_11: G = G::from_u64(42); let __v_12: G = G::from_u64(70); let __v_13: G = G::from_u64(164); let __v_14: G = G::from_u64(5); let __v_15: G = G::from_u64(73); let __v_16: G = G::from_u64(232); let __v_17: G = G::from_u64(89); let __v_18: G = G::from_u64(52); let __v_19: G = G::from_u64(247); let __v_20: G = G::from_u64(57); let __v_21: G = G::from_u64(94); let __v_22: G = G::from_u64(79); let __v_23: G = G::from_u64(147); let __v_24: G = G::from_u64(246); let __v_25: G = G::from_u64(93); let __v_26: G = G::from_u64(218); let __v_27: G = G::from_u64(78); let __v_28: G = G::from_u64(72); let __v_29: G = G::from_u64(9); let __v_30: G = G::from_u64(243); let __v_31: G = G::from_u64(37); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_201] = [__v_32]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_198(inp: [G; IN_198], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; 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 __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_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_196] = { let __args: [G; IN_196] = []; 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_6: G = __r_arr[0]; let __ret: [G; OUT_198] = [__v_5, __v_6]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; 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_8: G = __r_arr[0]; let __ret: [G; OUT_198] = [__v_7, __v_8]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_9, __v_10]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); match __v_13.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_198] = [__v_14, __v_15]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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 __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_16.as_canonical_u64() { 1u64 => { 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_198] = [__v_17, __v_18]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_18, __v_2]; 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_19: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, (&__args[..]))?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { (*(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200])) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_20, __v_21]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_20, __v_21]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } +const INPUT_SIZE_199: usize = 1; +const IN_199: usize = 1; +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); 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() { 1u64 => { 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_199] = [__v_4, __v_5]; record.function_queries[199].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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_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_194] = { let __args: [G; IN_194] = []; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; 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_15: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_14, __v_15]; record.function_queries[199].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_199] = [__v_14, __v_15]; record.function_queries[199].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_199] = [__v_12, __v_13]; record.function_queries[199].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_200: usize = 1; +const IN_200: usize = 1; +const OUT_200: usize = 2; +fn aiur_fn_200(inp: [G; IN_200], 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 __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_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_7]; 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 = (__v_6 + __v_8); match __v_9.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_200] = [__v_10, __v_11]; record.function_queries[200].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_200] = [__v_10, __v_0]; record.function_queries[200].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { 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_200] = [__v_5, __v_6]; record.function_queries[200].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_201: usize = 1; +const IN_201: usize = 1; +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 __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() { 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_201] = [__v_5, __v_0]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_201] = [__v_5, __v_6]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { 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_201] = [__v_5, __v_6]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_202: usize = 0; const IN_202: usize = 0; 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 = G::from_u64(147); let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(216); let __v_3: G = G::from_u64(80); let __v_4: G = G::from_u64(189); let __v_5: G = G::from_u64(226); let __v_6: G = G::from_u64(70); let __v_7: G = G::from_u64(148); let __v_8: G = G::from_u64(11); let __v_9: G = G::from_u64(123); let __v_10: G = G::from_u64(62); let __v_11: G = G::from_u64(129); let __v_12: G = G::from_u64(231); let __v_13: G = G::from_u64(134); let __v_14: G = G::from_u64(247); let __v_15: G = G::from_u64(241); let __v_16: G = G::from_u64(43); let __v_17: G = G::from_u64(174); let __v_18: G = G::from_u64(142); let __v_19: G = G::from_u64(92); let __v_20: G = G::from_u64(234); let __v_21: G = G::from_u64(107); let __v_22: G = G::from_u64(63); let __v_23: G = G::from_u64(64); let __v_24: G = G::from_u64(6); let __v_25: G = G::from_u64(58); let __v_26: G = G::from_u64(127); let __v_27: G = G::from_u64(89); let __v_28: G = G::from_u64(85); let __v_29: G = G::from_u64(124); 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_23, __v_24, __v_8, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_202] = [__v_30]; record.function_queries[202].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(250); let __v_1: G = G::from_u64(222); let __v_2: G = G::from_u64(45); let __v_3: G = G::from_u64(191); let __v_4: G = G::from_u64(177); let __v_5: G = G::from_u64(215); let __v_6: G = G::from_u64(247); let __v_7: G = G::from_u64(124); let __v_8: G = G::from_u64(48); let __v_9: G = G::from_u64(194); let __v_10: G = G::from_u64(71); let __v_11: G = G::from_u64(213); let __v_12: G = G::from_u64(241); let __v_13: G = G::from_u64(40); let __v_14: G = G::from_u64(81); let __v_15: G = G::from_u64(110); let __v_16: G = G::from_u64(237); let __v_17: G = G::from_u64(206); let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(248); let __v_20: G = G::from_u64(23); let __v_21: G = G::from_u64(211); let __v_22: G = G::from_u64(99); let __v_23: G = G::from_u64(136); let __v_24: G = G::from_u64(218); let __v_25: G = G::from_u64(19); let __v_26: G = G::from_u64(207); let __v_27: G = G::from_u64(172); let __v_28: G = G::from_u64(43); let __v_29: 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_2, __v_12, __v_13, __v_3, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_17, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; 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_202] = [__v_29]; record.function_queries[202].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_203: usize = 0; const IN_203: usize = 0; 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 = G::from_u64(32); let __v_1: G = G::from_u64(232); let __v_2: G = G::from_u64(144); let __v_3: G = G::from_u64(98); let __v_4: G = G::from_u64(128); let __v_5: G = G::from_u64(180); let __v_6: G = G::from_u64(220); let __v_7: G = G::from_u64(215); let __v_8: G = G::from_u64(74); let __v_9: G = G::from_u64(122); let __v_10: G = G::from_u64(120); let __v_11: G = G::from_u64(224); let __v_12: G = G::from_u64(109); let __v_13: G = G::from_u64(88); let __v_14: G = G::from_u64(14); let __v_15: G = G::from_u64(111); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(238); let __v_18: G = G::from_u64(187); let __v_19: G = G::from_u64(169); let __v_20: G = G::from_u64(252); let __v_21: G = G::from_u64(64); let __v_22: G = G::from_u64(146); let __v_23: G = G::from_u64(233); let __v_24: G = G::from_u64(92); let __v_25: G = G::from_u64(172); let __v_26: G = G::from_u64(182); let __v_27: G = G::from_u64(240); let __v_28: G = G::from_u64(214); let __v_29: G = G::from_u64(153); 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_10, __v_22, __v_3, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_203] = [__v_30]; record.function_queries[203].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(103); let __v_1: G = G::from_u64(22); let __v_2: G = G::from_u64(11); let __v_3: G = G::from_u64(151); let __v_4: G = G::from_u64(147); let __v_5: G = G::from_u64(6); let __v_6: G = G::from_u64(210); let __v_7: G = G::from_u64(130); let __v_8: G = G::from_u64(4); let __v_9: G = G::from_u64(69); let __v_10: G = G::from_u64(56); let __v_11: G = G::from_u64(58); let __v_12: G = G::from_u64(109); let __v_13: G = G::from_u64(116); let __v_14: G = G::from_u64(14); let __v_15: G = G::from_u64(111); let __v_16: G = G::from_u64(233); let __v_17: G = G::from_u64(131); let __v_18: G = G::from_u64(156); let __v_19: G = G::from_u64(37); let __v_20: G = G::from_u64(234); let __v_21: G = G::from_u64(72); let __v_22: G = G::from_u64(104); let __v_23: G = G::from_u64(15); let __v_24: G = G::from_u64(242); let __v_25: G = G::from_u64(167); let __v_26: G = G::from_u64(123); let __v_27: G = G::from_u64(134); let __v_28: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_9, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_2, __v_16, __v_27]; 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_203] = [__v_28]; record.function_queries[203].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_204: usize = 0; const IN_204: usize = 0; 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 = G::from_u64(72); let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(177); let __v_3: G = G::from_u64(131); let __v_4: G = G::from_u64(244); let __v_5: G = G::from_u64(214); let __v_6: G = G::from_u64(220); let __v_7: G = G::from_u64(204); let __v_8: G = G::from_u64(172); let __v_9: G = G::from_u64(186); let __v_10: G = G::from_u64(87); let __v_11: G = G::from_u64(114); let __v_12: G = G::from_u64(24); let __v_13: G = G::from_u64(36); let __v_14: G = G::from_u64(167); let __v_15: G = G::from_u64(187); let __v_16: G = G::from_u64(103); let __v_17: G = G::from_u64(218); let __v_18: G = G::from_u64(235); let __v_19: G = G::from_u64(39); let __v_20: G = G::from_u64(37); let __v_21: G = G::from_u64(23); let __v_22: G = G::from_u64(35); let __v_23: G = G::from_u64(146); let __v_24: G = G::from_u64(113); let __v_25: G = G::from_u64(193); let __v_26: G = G::from_u64(53); let __v_27: G = G::from_u64(149); let __v_28: G = G::from_u64(44); let __v_29: G = G::from_u64(170); let __v_30: G = G::from_u64(97); let __v_31: 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_17, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_204] = [__v_31]; record.function_queries[204].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_205: usize = 1; -const IN_205: 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 = G::from_u64(144); let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(42); let __v_3: G = G::from_u64(228); let __v_4: G = G::from_u64(197); let __v_5: G = G::from_u64(213); let __v_6: G = G::from_u64(210); let __v_7: G = G::from_u64(138); let __v_8: G = G::from_u64(205); let __v_9: G = G::from_u64(128); let __v_10: G = G::from_u64(5); let __v_11: G = G::from_u64(29); let __v_12: G = G::from_u64(212); let __v_13: G = G::from_u64(31); let __v_14: G = G::from_u64(39); let __v_15: G = G::from_u64(245); let __v_16: G = G::from_u64(28); let __v_17: G = G::from_u64(156); let __v_18: G = G::from_u64(74); let __v_19: G = G::from_u64(251); let __v_20: G = G::from_u64(171); let __v_21: G = G::from_u64(27); let __v_22: G = G::from_u64(179); let __v_23: G = G::from_u64(145); let __v_24: G = G::from_u64(119); let __v_25: G = G::from_u64(60); let __v_26: G = G::from_u64(25); let __v_27: G = G::from_u64(239); let __v_28: G = G::from_u64(13); let __v_29: G = G::from_u64(193); let __v_30: G = G::from_u64(233); let __v_31: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __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]; 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_204] = [__v_31]; record.function_queries[204].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_205: usize = 0; +const IN_205: usize = 0; const OUT_205: usize = 1; -fn aiur_fn_205(inp: [G; IN_205], 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 __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = []; 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_1: G = __r_arr[0]; 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_205] = [__v_3]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_205] = [__v_5]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_205] = [__v_7]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_205] = [__v_7]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_206: usize = 1; -const IN_206: 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 = G::from_u64(47); let __v_1: G = G::from_u64(156); let __v_2: G = G::from_u64(54); let __v_3: G = G::from_u64(144); let __v_4: G = G::from_u64(69); let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(109); let __v_7: G = G::from_u64(154); let __v_8: G = G::from_u64(53); let __v_9: G = G::from_u64(255); let __v_10: G = G::from_u64(123); let __v_11: G = G::from_u64(56); let __v_12: G = G::from_u64(40); let __v_13: G = G::from_u64(93); let __v_14: G = G::from_u64(202); let __v_15: G = G::from_u64(59); let __v_16: G = G::from_u64(151); let __v_17: G = G::from_u64(100); let __v_18: G = G::from_u64(38); let __v_19: G = G::from_u64(200); let __v_20: G = G::from_u64(26); let __v_21: G = G::from_u64(143); let __v_22: G = G::from_u64(111); let __v_23: G = G::from_u64(206); let __v_24: G = G::from_u64(17); let __v_25: G = G::from_u64(97); let __v_26: G = G::from_u64(176); let __v_27: G = G::from_u64(214); let __v_28: G = G::from_u64(13); let __v_29: G = { let __values: [G; 32] = [__v_0, __v_1, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_2, __v_22, __v_23, __v_24, __v_25, __v_26, __v_3, __v_27, __v_28]; 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_205] = [__v_29]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_206: usize = 0; +const IN_206: usize = 0; const OUT_206: usize = 1; -fn aiur_fn_206(inp: [G; IN_206], 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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(2); let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; 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_2: G = __r_arr[0]; 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 = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_1, __v_2, __v_4, __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_206] = [__v_6]; record.function_queries[206].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; 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_2: G = __r_arr[0]; 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 = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_1, __v_2, __v_4, __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_206] = [__v_6]; 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 = 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 __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, (&__args[..]))?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { (*(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210])) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[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 = { 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 __ret: [G; OUT_207] = [__v_5, __v_7]; record.function_queries[207].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_4]; 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_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(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_207] = [__v_7, __v_9]; record.function_queries[207].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { 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 __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.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_207] = [__v_9, __v_11]; record.function_queries[207].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(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_146] = { let __args: [G; IN_146] = [__v_13, __v_8]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_6, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, (&__args[..]))?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { (*(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144])) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_207] = [__v_11, __v_16]; record.function_queries[207].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 = G::from_u64(17); let __v_1: G = G::from_u64(21); let __v_2: G = G::from_u64(123); let __v_3: G = G::from_u64(195); let __v_4: G = G::from_u64(137); let __v_5: G = G::from_u64(143); let __v_6: G = G::from_u64(6); let __v_7: G = G::from_u64(227); let __v_8: G = G::from_u64(230); let __v_9: G = G::from_u64(242); let __v_10: G = G::from_u64(202); let __v_11: G = G::from_u64(131); let __v_12: G = G::from_u64(65); let __v_13: G = G::from_u64(30); let __v_14: G = G::from_u64(253); let __v_15: G = G::from_u64(13); let __v_16: G = G::from_u64(67); let __v_17: G = G::from_u64(184); let __v_18: G = G::from_u64(132); let __v_19: G = G::from_u64(107); let __v_20: G = G::from_u64(87); let __v_21: G = G::from_u64(210); let __v_22: G = G::from_u64(246); let __v_23: G = G::from_u64(8); let __v_24: G = G::from_u64(142); let __v_25: G = G::from_u64(24); let __v_26: G = G::from_u64(243); let __v_27: G = G::from_u64(68); let __v_28: G = G::from_u64(125); let __v_29: G = G::from_u64(220); let __v_30: G = G::from_u64(59); let __v_31: G = G::from_u64(40); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_206] = [__v_32]; record.function_queries[206].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_207: usize = 0; +const IN_207: usize = 0; +const OUT_207: usize = 1; +fn aiur_fn_207(inp: [G; IN_207], 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 = G::from_u64(6); let __v_1: G = G::from_u64(28); let __v_2: G = G::from_u64(38); let __v_3: G = G::from_u64(88); let __v_4: G = G::from_u64(199); let __v_5: G = G::from_u64(106); let __v_6: G = G::from_u64(104); let __v_7: G = G::from_u64(217); let __v_8: G = G::from_u64(9); let __v_9: G = G::from_u64(120); let __v_10: G = G::from_u64(133); let __v_11: G = G::from_u64(152); let __v_12: G = G::from_u64(36); let __v_13: G = G::from_u64(153); let __v_14: G = G::from_u64(59); let __v_15: G = G::from_u64(187); let __v_16: G = G::from_u64(225); let __v_17: G = G::from_u64(93); let __v_18: G = G::from_u64(191); let __v_19: G = G::from_u64(155); let __v_20: G = G::from_u64(97); let __v_21: G = G::from_u64(147); let __v_22: G = G::from_u64(37); let __v_23: G = G::from_u64(66); let __v_24: G = G::from_u64(14); let __v_25: G = G::from_u64(124); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(5); let __v_28: 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_13, __v_6, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_19, __v_27, __v_4]; 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_207] = [__v_28]; record.function_queries[207].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_208: usize = 1; const IN_208: usize = 1; -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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); 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() { 1u64 => { 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_208] = [__v_4, __v_5]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_789] = { let __args: [G; IN_789] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(2); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_7]; 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]; match __v_10.as_canonical_u64() { 0u64 => { 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_208] = [__v_12, __v_13]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_9]; 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_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_208] = [__v_14, __v_15]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_13, __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_15: G = __r_arr[0]; let __v_16: G = (__v_14 - __v_15); let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_14, __v_17]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }) } +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 __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; 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_1: G = __r_arr[0]; 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_208] = [__v_3]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_208] = [__v_5]; 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] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_208] = [__v_7]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_208] = [__v_7]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } const INPUT_SIZE_209: usize = 1; const IN_209: usize = 1; -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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(2); 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() { 1u64 => { 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_209] = [__v_4, __v_5]; record.function_queries[209].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_204] = { let __args: [G; IN_204] = []; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __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_13: G = __r_arr[0]; match __v_13.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_209] = [__v_14, __v_15]; record.function_queries[209].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_16.as_canonical_u64() { 1u64 => { 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_209] = [__v_17, __v_18]; record.function_queries[209].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_7, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; 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_19: G = __r_arr[0]; let __v_20: 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_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: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].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]; match __v_21.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_22, __v_25]; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_27, __v_27, __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_209] = [__v_27, __v_28]; record.function_queries[209].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = { let __a_val = __v_27.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 __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 4] = [__v_30, __v_30, __v_30, __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 __ret: [G; OUT_209] = [__v_30, __v_31]; record.function_queries[209].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_20, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_7, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(3); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_7, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; 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 __v_38: G = { let __values: [G; 3] = [__v_30, __v_35, __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_30, __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_30, __v_31, __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 __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __ret: [G; OUT_209] = [__v_41, __v_42]; record.function_queries[209].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { 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_209] = [__v_25, __v_26]; 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); }, } }, } }) } -const INPUT_SIZE_210: usize = 1; -const IN_210: usize = 1; -const OUT_210: usize = 3; -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 __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_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_200] = { let __args: [G; IN_200] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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(1); let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_2, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_2, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_12, __v_14, __v_15]; record.function_queries[210].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_210] = [__v_12, __v_13, __v_13]; record.function_queries[210].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_210] = [__v_9, __v_10, __v_10]; record.function_queries[210].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_210] = [__v_7, __v_8, __v_8]; record.function_queries[210].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_211: usize = 3; -const IN_211: usize = 3; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(2); let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; 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_2: G = __r_arr[0]; 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 = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_1, __v_2, __v_4, __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_209] = [__v_6]; record.function_queries[209].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; 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 = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_1, __v_2, __v_4, __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_209] = [__v_6]; 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 = 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 __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__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]; 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; 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 __ret: [G; OUT_210] = [__v_5, __v_7]; record.function_queries[210].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_4]; 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_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(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_210] = [__v_7, __v_9]; record.function_queries[210].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.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_210] = [__v_9, __v_11]; record.function_queries[210].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(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_149] = { let __args: [G; IN_149] = [__v_13, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, (&__args[..]))?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { (*(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149])) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_6, __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 __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_11, __v_16]; record.function_queries[210].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_211: usize = 1; +const IN_211: usize = 1; 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 __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; 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_211] = [__v_8, __v_9]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_2]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_789] = { let __args: [G; IN_789] = [__v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_10, __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_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_211] = [__v_15, __v_16]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_14]; 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 __ret: [G; OUT_211] = [__v_15, __v_16]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, } }, _ => { let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_1, __v_2]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_211] = [__v_8, __v_9]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_1]; 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 __v_10: G = __r_arr[1]; let __ret: [G; OUT_211] = [__v_9, __v_10]; record.function_queries[211].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_211] = [__v_9, __v_10]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_212: usize = 2; -const IN_212: usize = 2; -const OUT_212: usize = 1; -fn aiur_fn_212(inp: [G; IN_212], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1]; 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_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() { 1u64 => { let __ret: [G; OUT_212] = [__v_2]; record.function_queries[212].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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_212] = [__v_2]; record.function_queries[212].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_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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_212] = [__v_2]; record.function_queries[212].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_12: G = __r_arr[0]; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_10, __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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __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_16: G = { let __values: [G; 3] = [__v_14, __v_12, __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_14, __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 __ret: [G; OUT_212] = [__v_17]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_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_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_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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_3, __v_1]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_4]; 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 __ret: [G; OUT_213] = [__v_5]; record.function_queries[213].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_214: usize = 0; -const IN_214: usize = 0; -const OUT_214: usize = 1; -fn aiur_fn_214(inp: [G; IN_214], 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 = G::from_u64(82); let __v_1: G = G::from_u64(176); let __v_2: G = G::from_u64(34); let __v_3: G = G::from_u64(110); let __v_4: G = G::from_u64(161); let __v_5: G = G::from_u64(76); let __v_6: G = G::from_u64(148); let __v_7: G = G::from_u64(177); let __v_8: G = G::from_u64(249); let __v_9: G = G::from_u64(51); let __v_10: G = G::from_u64(153); let __v_11: G = G::from_u64(87); let __v_12: G = G::from_u64(245); let __v_13: G = G::from_u64(88); let __v_14: G = G::from_u64(147); let __v_15: G = G::from_u64(168); let __v_16: G = G::from_u64(107); let __v_17: G = G::from_u64(205); let __v_18: G = G::from_u64(174); let __v_19: G = G::from_u64(17); let __v_20: G = G::from_u64(31); let __v_21: G = G::from_u64(40); let __v_22: G = G::from_u64(71); let __v_23: G = G::from_u64(201); let __v_24: G = G::from_u64(194); let __v_25: G = G::from_u64(251); let __v_26: G = G::from_u64(10); let __v_27: G = G::from_u64(97); let __v_28: 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_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_10, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_1, __v_24, __v_25, __v_26, __v_2, __v_27]; 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_214] = [__v_28]; record.function_queries[214].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_215: usize = 0; -const IN_215: usize = 0; +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); 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() { 1u64 => { 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_211] = [__v_4, __v_5]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_792] = { let __args: [G; IN_792] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(2); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_5, __v_7]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { 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_211] = [__v_12, __v_13]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_5, __v_9]; 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_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_211] = [__v_14, __v_15]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_13, __v_11]; 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_15: G = __r_arr[0]; let __v_16: G = (__v_14 - __v_15); let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__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_211] = [__v_14, __v_17]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_212: usize = 1; +const IN_212: usize = 1; +const OUT_212: usize = 2; +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(2); 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() { 1u64 => { 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_212] = [__v_4, __v_5]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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_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_207] = { let __args: [G; IN_207] = []; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __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_13: G = __r_arr[0]; match __v_13.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_212] = [__v_14, __v_15]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_16.as_canonical_u64() { 1u64 => { 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_212] = [__v_17, __v_18]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_7, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: 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_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: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].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]; match __v_21.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_22, __v_25]; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_27, __v_27, __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_212] = [__v_27, __v_28]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = { let __a_val = __v_27.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 __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 4] = [__v_30, __v_30, __v_30, __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 __ret: [G; OUT_212] = [__v_30, __v_31]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_20, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_7, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(3); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_7, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; 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 __v_38: G = { let __values: [G; 3] = [__v_30, __v_35, __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_30, __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_30, __v_31, __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 __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __ret: [G; OUT_212] = [__v_41, __v_42]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { 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_212] = [__v_25, __v_26]; record.function_queries[212].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_212] = [__v_12, __v_13]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_213: usize = 1; +const IN_213: usize = 1; +const OUT_213: usize = 3; +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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_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_203] = { let __args: [G; IN_203] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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(1); let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_2, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_2, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_213] = [__v_12, __v_14, __v_15]; record.function_queries[213].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_213] = [__v_12, __v_13, __v_13]; record.function_queries[213].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_213] = [__v_9, __v_10, __v_10]; record.function_queries[213].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_213] = [__v_7, __v_8, __v_8]; record.function_queries[213].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_214: usize = 3; +const IN_214: usize = 3; +const OUT_214: usize = 2; +fn aiur_fn_214(inp: [G; IN_214], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; 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_214] = [__v_8, __v_9]; record.function_queries[214].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_2]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_792] = { let __args: [G; IN_792] = [__v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_10, __v_12]; 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_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_214] = [__v_15, __v_16]; record.function_queries[214].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_14]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_15, __v_16]; record.function_queries[214].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, } }, _ => { let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_1, __v_2]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_214] = [__v_8, __v_9]; record.function_queries[214].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, (&__args[..]))?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { (*(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212])) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_214] = [__v_9, __v_10]; record.function_queries[214].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_214] = [__v_9, __v_10]; 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 = G::from_u64(19); let __v_1: G = G::from_u64(47); let __v_2: G = G::from_u64(17); let __v_3: G = G::from_u64(117); let __v_4: G = G::from_u64(204); let __v_5: G = G::from_u64(60); let __v_6: G = G::from_u64(172); let __v_7: G = G::from_u64(90); let __v_8: G = G::from_u64(62); let __v_9: G = G::from_u64(61); let __v_10: G = G::from_u64(116); let __v_11: G = G::from_u64(232); let __v_12: G = G::from_u64(121); let __v_13: G = G::from_u64(127); let __v_14: G = G::from_u64(155); let __v_15: G = G::from_u64(166); let __v_16: G = G::from_u64(46); let __v_17: G = G::from_u64(70); let __v_18: G = G::from_u64(123); let __v_19: G = G::from_u64(128); let __v_20: G = G::from_u64(4); let __v_21: G = G::from_u64(163); let __v_22: G = G::from_u64(242); let __v_23: G = G::from_u64(139); let __v_24: G = G::from_u64(181); let __v_25: G = G::from_u64(223); let __v_26: G = G::from_u64(209); let __v_27: G = G::from_u64(106); let __v_28: G = G::from_u64(54); let __v_29: G = G::from_u64(71); let __v_30: G = G::from_u64(177); let __v_31: 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_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_28, __v_29, __v_30]; 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_215] = [__v_31]; record.function_queries[215].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_216: usize = 0; -const IN_216: usize = 0; +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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_1]; 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_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() { 1u64 => { let __ret: [G; OUT_215] = [__v_2]; record.function_queries[215].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_215] = [__v_2]; record.function_queries[215].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_215] = [__v_2]; record.function_queries[215].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_12: G = __r_arr[0]; let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_10, __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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __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_16: G = { let __values: [G; 3] = [__v_14, __v_12, __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_14, __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 __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_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_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 = G::from_u64(39); let __v_1: G = G::from_u64(46); let __v_2: G = G::from_u64(165); let __v_3: G = G::from_u64(206); let __v_4: G = G::from_u64(107); let __v_5: G = G::from_u64(171); let __v_6: G = G::from_u64(137); let __v_7: G = G::from_u64(88); let __v_8: G = G::from_u64(22); let __v_9: G = G::from_u64(92); let __v_10: G = G::from_u64(127); let __v_11: G = G::from_u64(86); let __v_12: G = G::from_u64(215); let __v_13: G = G::from_u64(31); let __v_14: G = G::from_u64(254); let __v_15: G = G::from_u64(42); let __v_16: G = G::from_u64(91); let __v_17: G = G::from_u64(23); let __v_18: G = G::from_u64(94); let __v_19: G = G::from_u64(213); let __v_20: G = G::from_u64(129); let __v_21: G = G::from_u64(16); let __v_22: G = G::from_u64(18); let __v_23: G = G::from_u64(109); let __v_24: G = G::from_u64(250); let __v_25: G = G::from_u64(150); let __v_26: G = G::from_u64(225); let __v_27: G = G::from_u64(248); let __v_28: G = G::from_u64(160); let __v_29: G = G::from_u64(201); let __v_30: G = G::from_u64(154); let __v_31: G = G::from_u64(210); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_216] = [__v_32]; record.function_queries[216].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_3, __v_1]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2, __v_4]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_216] = [__v_5]; record.function_queries[216].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_217: usize = 0; const IN_217: usize = 0; const OUT_217: usize = 1; -fn aiur_fn_217(inp: [G; IN_217], 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 = G::from_u64(202); let __v_1: G = G::from_u64(245); let __v_2: G = G::from_u64(27); let __v_3: G = G::from_u64(3); let __v_4: G = G::from_u64(157); let __v_5: G = G::from_u64(113); let __v_6: G = G::from_u64(207); let __v_7: G = G::from_u64(206); let __v_8: G = G::from_u64(112); let __v_9: G = G::from_u64(99); let __v_10: G = G::from_u64(225); let __v_11: G = G::from_u64(6); let __v_12: G = G::from_u64(79); let __v_13: G = G::from_u64(148); let __v_14: G = G::from_u64(53); let __v_15: G = G::from_u64(51); let __v_16: G = G::from_u64(123); let __v_17: G = G::from_u64(188); let __v_18: G = G::from_u64(66); let __v_19: G = G::from_u64(86); let __v_20: G = G::from_u64(124); let __v_21: G = G::from_u64(140); let __v_22: G = G::from_u64(120); let __v_23: G = G::from_u64(181); let __v_24: G = G::from_u64(246); let __v_25: G = G::from_u64(108); let __v_26: G = G::from_u64(127); let __v_27: G = G::from_u64(8); let __v_28: G = G::from_u64(121); let __v_29: G = G::from_u64(32); 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_11, __v_12, __v_13, __v_14, __v_1, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_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_217] = [__v_30]; record.function_queries[217].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(76); let __v_1: G = G::from_u64(8); let __v_2: G = G::from_u64(104); let __v_3: G = G::from_u64(38); let __v_4: G = G::from_u64(204); let __v_5: G = G::from_u64(103); let __v_6: G = G::from_u64(157); let __v_7: G = G::from_u64(243); let __v_8: G = G::from_u64(182); let __v_9: G = G::from_u64(170); let __v_10: G = G::from_u64(87); let __v_11: G = G::from_u64(162); let __v_12: G = G::from_u64(159); let __v_13: G = G::from_u64(61); let __v_14: G = G::from_u64(9); let __v_15: G = G::from_u64(58); let __v_16: G = G::from_u64(138); let __v_17: G = G::from_u64(146); let __v_18: G = G::from_u64(208); let __v_19: G = G::from_u64(222); let __v_20: G = G::from_u64(78); let __v_21: G = G::from_u64(206); let __v_22: G = G::from_u64(244); let __v_23: G = G::from_u64(106); let __v_24: G = G::from_u64(144); let __v_25: G = G::from_u64(141); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(152); let __v_28: G = G::from_u64(115); let __v_29: G = G::from_u64(192); 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_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_13, __v_29]; 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_217] = [__v_30]; record.function_queries[217].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_218: usize = 0; const IN_218: usize = 0; 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 = G::from_u64(57); let __v_1: G = G::from_u64(148); let __v_2: G = G::from_u64(188); let __v_3: G = G::from_u64(81); let __v_4: G = G::from_u64(227); let __v_5: G = G::from_u64(104); let __v_6: G = G::from_u64(111); let __v_7: G = G::from_u64(48); let __v_8: G = G::from_u64(161); let __v_9: G = G::from_u64(212); let __v_10: G = G::from_u64(131); let __v_11: G = G::from_u64(214); let __v_12: G = G::from_u64(157); let __v_13: G = G::from_u64(10); let __v_14: G = G::from_u64(90); let __v_15: G = G::from_u64(123); let __v_16: G = G::from_u64(72); let __v_17: G = G::from_u64(77); let __v_18: G = G::from_u64(137); let __v_19: G = G::from_u64(35); let __v_20: G = G::from_u64(147); let __v_21: G = G::from_u64(192); let __v_22: G = G::from_u64(132); let __v_23: G = G::from_u64(248); let __v_24: G = G::from_u64(122); let __v_25: G = G::from_u64(88); let __v_26: G = G::from_u64(73); let __v_27: G = G::from_u64(222); let __v_28: G = G::from_u64(84); let __v_29: G = G::from_u64(243); let __v_30: G = G::from_u64(2); let __v_31: 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_10, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_218] = [__v_31]; record.function_queries[218].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(14); let __v_1: G = G::from_u64(174); let __v_2: G = G::from_u64(105); let __v_3: G = G::from_u64(243); let __v_4: G = G::from_u64(248); let __v_5: G = G::from_u64(177); let __v_6: G = G::from_u64(152); let __v_7: G = G::from_u64(209); let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(172); let __v_10: G = G::from_u64(103); let __v_11: G = G::from_u64(185); let __v_12: G = G::from_u64(232); let __v_13: G = G::from_u64(141); let __v_14: G = G::from_u64(57); let __v_15: G = G::from_u64(82); let __v_16: G = G::from_u64(107); let __v_17: G = G::from_u64(27); let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(159); let __v_20: G = G::from_u64(245); let __v_21: G = G::from_u64(25); let __v_22: G = G::from_u64(205); let __v_23: G = G::from_u64(135); let __v_24: G = G::from_u64(238); let __v_25: G = G::from_u64(193); let __v_26: G = G::from_u64(6); let __v_27: G = G::from_u64(246); let __v_28: G = G::from_u64(116); let __v_29: G = G::from_u64(134); let __v_30: G = G::from_u64(12); let __v_31: 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_14, __v_28, __v_29, __v_30]; 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_218] = [__v_31]; record.function_queries[218].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_219: usize = 0; const IN_219: usize = 0; 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 = G::from_u64(179); let __v_1: G = G::from_u64(167); let __v_2: G = G::from_u64(216); let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(73); let __v_5: G = G::from_u64(253); let __v_6: G = G::from_u64(130); let __v_7: G = G::from_u64(49); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(238); let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(98); let __v_12: G = G::from_u64(50); let __v_13: G = G::from_u64(209); let __v_14: G = G::from_u64(65); let __v_15: G = G::from_u64(42); let __v_16: G = G::from_u64(14); let __v_17: G = G::from_u64(131); let __v_18: G = G::from_u64(53); let __v_19: G = G::from_u64(39); let __v_20: G = G::from_u64(93); let __v_21: G = G::from_u64(245); let __v_22: G = G::from_u64(59); let __v_23: G = G::from_u64(146); let __v_24: G = G::from_u64(148); let __v_25: G = G::from_u64(56); let __v_26: G = G::from_u64(135); let __v_27: G = G::from_u64(182); let __v_28: G = G::from_u64(80); let __v_29: G = G::from_u64(247); 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_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_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_219] = [__v_30]; record.function_queries[219].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(69); let __v_1: G = G::from_u64(220); let __v_2: G = G::from_u64(179); let __v_3: G = G::from_u64(197); let __v_4: G = G::from_u64(229); let __v_5: G = G::from_u64(173); let __v_6: G = G::from_u64(163); let __v_7: G = G::from_u64(188); let __v_8: G = G::from_u64(12); let __v_9: G = G::from_u64(165); let __v_10: G = G::from_u64(45); let __v_11: G = G::from_u64(98); let __v_12: G = G::from_u64(166); let __v_13: G = G::from_u64(111); let __v_14: G = G::from_u64(127); let __v_15: G = G::from_u64(157); let __v_16: G = G::from_u64(218); let __v_17: G = G::from_u64(53); let __v_18: G = G::from_u64(7); let __v_19: G = G::from_u64(223); let __v_20: G = G::from_u64(113); let __v_21: G = G::from_u64(6); let __v_22: G = G::from_u64(26); let __v_23: G = G::from_u64(92); let __v_24: G = G::from_u64(32); let __v_25: G = G::from_u64(10); let __v_26: G = G::from_u64(222); let __v_27: G = G::from_u64(160); let __v_28: G = G::from_u64(207); let __v_29: G = G::from_u64(36); let __v_30: G = G::from_u64(16); let __v_31: G = G::from_u64(20); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_219] = [__v_32]; record.function_queries[219].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_220: usize = 0; const IN_220: usize = 0; 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 = G::from_u64(76); let __v_1: G = G::from_u64(89); let __v_2: G = G::from_u64(188); let __v_3: G = G::from_u64(78); let __v_4: G = G::from_u64(172); let __v_5: G = G::from_u64(130); let __v_6: G = G::from_u64(211); let __v_7: G = G::from_u64(30); let __v_8: G = G::from_u64(190); let __v_9: G = G::from_u64(213); let __v_10: G = G::from_u64(155); let __v_11: G = G::from_u64(178); let __v_12: G = G::from_u64(6); let __v_13: G = G::from_u64(144); let __v_14: G = G::from_u64(157); let __v_15: G = G::from_u64(189); let __v_16: G = G::from_u64(237); let __v_17: G = G::from_u64(101); let __v_18: G = G::from_u64(185); let __v_19: G = G::from_u64(47); let __v_20: G = G::from_u64(109); let __v_21: G = G::from_u64(226); let __v_22: G = G::from_u64(81); let __v_23: G = G::from_u64(143); let __v_24: G = G::from_u64(205); let __v_25: G = G::from_u64(173); let __v_26: G = G::from_u64(176); let __v_27: G = G::from_u64(164); let __v_28: G = G::from_u64(44); let __v_29: G = G::from_u64(17); let __v_30: G = G::from_u64(160); let __v_31: 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_9, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_220] = [__v_31]; record.function_queries[220].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(207); let __v_1: G = G::from_u64(248); let __v_2: G = G::from_u64(117); let __v_3: G = G::from_u64(145); let __v_4: G = G::from_u64(79); let __v_5: G = G::from_u64(63); let __v_6: G = G::from_u64(139); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(20); let __v_9: G = G::from_u64(209); let __v_10: G = G::from_u64(234); let __v_11: G = G::from_u64(162); let __v_12: G = G::from_u64(35); let __v_13: G = G::from_u64(198); let __v_14: G = G::from_u64(185); let __v_15: G = G::from_u64(218); let __v_16: G = G::from_u64(114); let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(155); let __v_19: G = G::from_u64(197); let __v_20: G = G::from_u64(151); let __v_21: G = G::from_u64(110); let __v_22: G = G::from_u64(11); let __v_23: G = G::from_u64(105); let __v_24: G = G::from_u64(217); let __v_25: G = G::from_u64(156); let __v_26: G = G::from_u64(243); let __v_27: G = G::from_u64(87); let __v_28: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_12, __v_18, __v_19, __v_20, __v_21, __v_8, __v_22, __v_23, __v_24, __v_25, __v_9, __v_26, __v_27]; 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_220] = [__v_28]; record.function_queries[220].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_221: usize = 0; const IN_221: usize = 0; 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 = G::from_u64(50); let __v_1: G = G::from_u64(16); let __v_2: G = G::from_u64(75); let __v_3: G = G::from_u64(3); let __v_4: G = G::from_u64(52); let __v_5: G = G::from_u64(141); let __v_6: G = G::from_u64(17); let __v_7: G = G::from_u64(172); let __v_8: G = G::from_u64(178); let __v_9: G = G::from_u64(67); let __v_10: G = G::from_u64(127); let __v_11: G = G::from_u64(218); let __v_12: G = G::from_u64(36); let __v_13: G = G::from_u64(150); let __v_14: G = G::from_u64(109); let __v_15: G = G::from_u64(197); let __v_16: G = G::from_u64(140); let __v_17: G = G::from_u64(200); let __v_18: G = G::from_u64(188); let __v_19: G = G::from_u64(202); let __v_20: G = G::from_u64(88); let __v_21: G = G::from_u64(38); let __v_22: G = G::from_u64(20); let __v_23: G = G::from_u64(230); let __v_24: G = G::from_u64(68); let __v_25: G = G::from_u64(211); let __v_26: G = G::from_u64(25); let __v_27: G = G::from_u64(164); let __v_28: G = G::from_u64(44); let __v_29: G = G::from_u64(98); 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_17, __v_18, __v_19, __v_13, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_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_221] = [__v_30]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_221(inp: [G; IN_221], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(57); let __v_1: G = G::from_u64(148); let __v_2: G = G::from_u64(188); let __v_3: G = G::from_u64(81); let __v_4: G = G::from_u64(227); let __v_5: G = G::from_u64(104); let __v_6: G = G::from_u64(111); let __v_7: G = G::from_u64(48); let __v_8: G = G::from_u64(161); let __v_9: G = G::from_u64(212); let __v_10: G = G::from_u64(131); let __v_11: G = G::from_u64(214); let __v_12: G = G::from_u64(157); let __v_13: G = G::from_u64(10); let __v_14: G = G::from_u64(90); let __v_15: G = G::from_u64(123); let __v_16: G = G::from_u64(72); let __v_17: G = G::from_u64(77); let __v_18: G = G::from_u64(137); let __v_19: G = G::from_u64(35); let __v_20: G = G::from_u64(147); let __v_21: G = G::from_u64(192); let __v_22: G = G::from_u64(132); let __v_23: G = G::from_u64(248); let __v_24: G = G::from_u64(122); let __v_25: G = G::from_u64(88); let __v_26: G = G::from_u64(73); let __v_27: G = G::from_u64(222); let __v_28: G = G::from_u64(84); let __v_29: G = G::from_u64(243); let __v_30: G = G::from_u64(2); let __v_31: 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_10, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_221] = [__v_31]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_222: usize = 0; const IN_222: usize = 0; 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 = G::from_u64(55); let __v_1: G = G::from_u64(239); let __v_2: G = G::from_u64(95); let __v_3: G = G::from_u64(238); let __v_4: G = G::from_u64(118); let __v_5: G = G::from_u64(93); let __v_6: G = G::from_u64(194); let __v_7: G = G::from_u64(229); let __v_8: G = G::from_u64(199); let __v_9: G = G::from_u64(66); let __v_10: G = G::from_u64(92); let __v_11: G = G::from_u64(24); let __v_12: G = G::from_u64(12); let __v_13: G = G::from_u64(212); let __v_14: G = G::from_u64(32); let __v_15: G = G::from_u64(7); let __v_16: G = G::from_u64(219); let __v_17: G = G::from_u64(125); let __v_18: G = G::from_u64(41); let __v_19: G = G::from_u64(174); let __v_20: G = G::from_u64(13); let __v_21: G = G::from_u64(9); let __v_22: G = G::from_u64(23); let __v_23: G = G::from_u64(137); let __v_24: G = G::from_u64(244); let __v_25: G = G::from_u64(98); let __v_26: G = G::from_u64(242); let __v_27: G = G::from_u64(128); let __v_28: G = G::from_u64(91); let __v_29: G = G::from_u64(14); 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_10, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __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 __ret: [G; OUT_222] = [__v_30]; record.function_queries[222].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(179); let __v_1: G = G::from_u64(167); let __v_2: G = G::from_u64(216); let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(73); let __v_5: G = G::from_u64(253); let __v_6: G = G::from_u64(130); let __v_7: G = G::from_u64(49); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(238); let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(98); let __v_12: G = G::from_u64(50); let __v_13: G = G::from_u64(209); let __v_14: G = G::from_u64(65); let __v_15: G = G::from_u64(42); let __v_16: G = G::from_u64(14); let __v_17: G = G::from_u64(131); let __v_18: G = G::from_u64(53); let __v_19: G = G::from_u64(39); let __v_20: G = G::from_u64(93); let __v_21: G = G::from_u64(245); let __v_22: G = G::from_u64(59); let __v_23: G = G::from_u64(146); let __v_24: G = G::from_u64(148); let __v_25: G = G::from_u64(56); let __v_26: G = G::from_u64(135); let __v_27: G = G::from_u64(182); let __v_28: G = G::from_u64(80); let __v_29: G = G::from_u64(247); 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_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_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_222] = [__v_30]; record.function_queries[222].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_223: usize = 0; const IN_223: usize = 0; 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 = G::from_u64(121); let __v_1: G = G::from_u64(134); let __v_2: G = G::from_u64(42); let __v_3: G = G::from_u64(207); let __v_4: G = G::from_u64(188); let __v_5: G = G::from_u64(46); let __v_6: G = G::from_u64(55); let __v_7: G = G::from_u64(183); let __v_8: G = G::from_u64(182); let __v_9: G = G::from_u64(18); let __v_10: G = G::from_u64(33); let __v_11: G = G::from_u64(67); let __v_12: G = G::from_u64(240); let __v_13: G = G::from_u64(166); let __v_14: G = G::from_u64(165); let __v_15: G = G::from_u64(17); let __v_16: G = G::from_u64(20); let __v_17: G = G::from_u64(195); let __v_18: G = G::from_u64(79); let __v_19: G = G::from_u64(164); let __v_20: G = G::from_u64(131); let __v_21: G = G::from_u64(255); let __v_22: G = G::from_u64(100); let __v_23: G = G::from_u64(222); let __v_24: G = G::from_u64(24); let __v_25: G = G::from_u64(93); let __v_26: G = G::from_u64(66); let __v_27: G = G::from_u64(9); let __v_28: 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_16, __v_16, __v_22, __v_20, __v_23, __v_24, __v_20, __v_25, __v_26, __v_27]; 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_223] = [__v_28]; record.function_queries[223].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(6); let __v_1: G = G::from_u64(95); let __v_2: G = G::from_u64(200); let __v_3: G = G::from_u64(180); let __v_4: G = G::from_u64(19); let __v_5: G = G::from_u64(147); let __v_6: G = G::from_u64(245); let __v_7: G = G::from_u64(37); let __v_8: G = G::from_u64(193); let __v_9: G = G::from_u64(229); let __v_10: G = G::from_u64(65); let __v_11: G = G::from_u64(185); let __v_12: G = G::from_u64(212); let __v_13: G = G::from_u64(188); let __v_14: G = G::from_u64(151); let __v_15: G = G::from_u64(194); let __v_16: G = G::from_u64(12); let __v_17: G = G::from_u64(191); let __v_18: G = G::from_u64(35); let __v_19: G = G::from_u64(167); let __v_20: G = G::from_u64(32); let __v_21: G = G::from_u64(154); let __v_22: G = G::from_u64(182); let __v_23: G = G::from_u64(244); let __v_24: G = G::from_u64(82); let __v_25: G = G::from_u64(115); let __v_26: G = G::from_u64(48); let __v_27: G = G::from_u64(17); let __v_28: G = G::from_u64(74); let __v_29: 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_4, __v_17, __v_18, __v_19, __v_20, __v_21, __v_20, __v_5, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; 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_223] = [__v_29]; record.function_queries[223].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_224: usize = 0; const IN_224: usize = 0; 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 = G::from_u64(191); let __v_1: G = G::from_u64(88); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(203); let __v_4: G = G::from_u64(58); let __v_5: G = G::from_u64(160); let __v_6: G = G::from_u64(247); let __v_7: G = G::from_u64(70); let __v_8: G = G::from_u64(133); let __v_9: G = G::from_u64(6); let __v_10: G = G::from_u64(41); let __v_11: G = G::from_u64(4); let __v_12: G = G::from_u64(22); let __v_13: G = G::from_u64(53); let __v_14: G = G::from_u64(205); let __v_15: G = G::from_u64(48); let __v_16: G = G::from_u64(192); let __v_17: G = G::from_u64(173); let __v_18: G = G::from_u64(102); let __v_19: G = G::from_u64(38); let __v_20: G = G::from_u64(43); let __v_21: G = G::from_u64(23); let __v_22: G = G::from_u64(15); let __v_23: G = G::from_u64(34); let __v_24: G = G::from_u64(144); let __v_25: G = G::from_u64(36); let __v_26: G = G::from_u64(31); let __v_27: G = G::from_u64(8); let __v_28: G = G::from_u64(176); let __v_29: G = G::from_u64(139); 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_18, __v_21, __v_18, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_224] = [__v_30]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_224(inp: [G; IN_224], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(176); let __v_1: G = G::from_u64(82); let __v_2: G = G::from_u64(232); let __v_3: G = G::from_u64(20); let __v_4: G = G::from_u64(18); let __v_5: G = G::from_u64(14); let __v_6: G = G::from_u64(166); let __v_7: G = G::from_u64(41); let __v_8: G = G::from_u64(154); let __v_9: G = G::from_u64(236); let __v_10: G = G::from_u64(244); let __v_11: G = G::from_u64(233); let __v_12: G = G::from_u64(187); let __v_13: G = G::from_u64(43); let __v_14: G = G::from_u64(101); let __v_15: G = G::from_u64(109); let __v_16: G = G::from_u64(103); let __v_17: G = G::from_u64(193); let __v_18: G = G::from_u64(249); let __v_19: G = G::from_u64(83); let __v_20: G = G::from_u64(126); let __v_21: G = G::from_u64(143); let __v_22: G = G::from_u64(159); let __v_23: G = G::from_u64(22); let __v_24: G = G::from_u64(71); let __v_25: G = G::from_u64(156); let __v_26: G = G::from_u64(152); let __v_27: G = G::from_u64(160); let __v_28: G = G::from_u64(79); let __v_29: G = G::from_u64(222); let __v_30: G = G::from_u64(147); let __v_31: 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_5, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; 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_224] = [__v_31]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_225: usize = 0; const IN_225: usize = 0; 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 = G::from_u64(25); let __v_1: G = G::from_u64(19); let __v_2: G = G::from_u64(79); let __v_3: G = G::from_u64(220); let __v_4: G = G::from_u64(24); let __v_5: G = G::from_u64(142); let __v_6: G = G::from_u64(131); let __v_7: G = G::from_u64(119); let __v_8: G = G::from_u64(208); let __v_9: G = G::from_u64(23); let __v_10: G = G::from_u64(56); let __v_11: G = G::from_u64(87); let __v_12: G = G::from_u64(225); let __v_13: G = G::from_u64(93); let __v_14: G = G::from_u64(59); let __v_15: G = G::from_u64(80); let __v_16: G = G::from_u64(101); let __v_17: G = G::from_u64(237); let __v_18: G = G::from_u64(118); let __v_19: G = G::from_u64(218); let __v_20: G = G::from_u64(152); let __v_21: G = G::from_u64(151); let __v_22: G = G::from_u64(16); let __v_23: G = G::from_u64(126); let __v_24: G = G::from_u64(92); let __v_25: G = G::from_u64(64); let __v_26: G = G::from_u64(77); let __v_27: G = G::from_u64(179); let __v_28: G = G::from_u64(243); let __v_29: G = G::from_u64(183); 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_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_4]; 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_225] = [__v_30]; record.function_queries[225].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(16); let __v_1: G = G::from_u64(175); let __v_2: G = G::from_u64(29); let __v_3: G = G::from_u64(236); let __v_4: G = G::from_u64(213); let __v_5: G = G::from_u64(210); let __v_6: G = G::from_u64(205); let __v_7: G = G::from_u64(8); let __v_8: G = G::from_u64(90); let __v_9: G = G::from_u64(223); let __v_10: G = G::from_u64(248); let __v_11: G = G::from_u64(174); let __v_12: G = G::from_u64(127); let __v_13: G = G::from_u64(180); let __v_14: G = G::from_u64(76); let __v_15: G = G::from_u64(252); let __v_16: G = G::from_u64(93); let __v_17: G = G::from_u64(34); let __v_18: G = G::from_u64(168); let __v_19: G = G::from_u64(155); let __v_20: G = G::from_u64(188); let __v_21: G = G::from_u64(64); let __v_22: G = G::from_u64(184); let __v_23: G = G::from_u64(27); let __v_24: G = G::from_u64(128); let __v_25: G = G::from_u64(157); let __v_26: G = G::from_u64(61); let __v_27: G = G::from_u64(85); let __v_28: G = G::from_u64(111); let __v_29: G = G::from_u64(218); let __v_30: G = G::from_u64(62); let __v_31: G = G::from_u64(143); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_225] = [__v_32]; record.function_queries[225].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_226: usize = 0; const IN_226: usize = 0; 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 = G::from_u64(157); let __v_1: G = G::from_u64(106); let __v_2: G = G::from_u64(228); let __v_3: G = G::from_u64(52); let __v_4: G = G::from_u64(41); let __v_5: G = G::from_u64(236); let __v_6: G = G::from_u64(2); let __v_7: G = G::from_u64(169); let __v_8: G = G::from_u64(51); let __v_9: G = G::from_u64(139); let __v_10: G = G::from_u64(188); let __v_11: G = G::from_u64(208); let __v_12: G = G::from_u64(219); let __v_13: G = G::from_u64(10); let __v_14: G = G::from_u64(193); let __v_15: G = G::from_u64(147); let __v_16: G = G::from_u64(215); let __v_17: G = G::from_u64(94); let __v_18: G = G::from_u64(189); let __v_19: G = G::from_u64(70); let __v_20: G = G::from_u64(248); let __v_21: G = G::from_u64(132); let __v_22: G = G::from_u64(191); let __v_23: G = G::from_u64(203); let __v_24: G = G::from_u64(210); let __v_25: G = G::from_u64(196); let __v_26: G = G::from_u64(43); let __v_27: G = G::from_u64(247); let __v_28: G = G::from_u64(250); let __v_29: G = G::from_u64(234); let __v_30: G = G::from_u64(21); let __v_31: G = G::from_u64(13); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_226] = [__v_32]; record.function_queries[226].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_227: usize = 1; -const IN_227: 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 = G::from_u64(222); let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(48); let __v_3: G = G::from_u64(36); let __v_4: G = G::from_u64(197); let __v_5: G = G::from_u64(152); let __v_6: G = G::from_u64(229); let __v_7: G = G::from_u64(240); let __v_8: G = G::from_u64(195); let __v_9: G = G::from_u64(220); let __v_10: G = G::from_u64(208); let __v_11: G = G::from_u64(103); let __v_12: G = G::from_u64(245); let __v_13: G = G::from_u64(6); let __v_14: G = G::from_u64(225); let __v_15: G = G::from_u64(210); let __v_16: G = G::from_u64(227); let __v_17: G = G::from_u64(39); let __v_18: G = G::from_u64(73); let __v_19: G = G::from_u64(87); let __v_20: G = G::from_u64(53); let __v_21: G = G::from_u64(34); let __v_22: G = G::from_u64(172); let __v_23: G = G::from_u64(181); let __v_24: G = G::from_u64(57); let __v_25: G = G::from_u64(182); let __v_26: G = G::from_u64(20); let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(98); let __v_29: G = G::from_u64(124); let __v_30: G = G::from_u64(248); let __v_31: G = G::from_u64(151); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_226] = [__v_32]; record.function_queries[226].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_227: usize = 0; +const IN_227: usize = 0; 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 __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; 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_1: G = __r_arr[0]; 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_227] = [__v_3]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; 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_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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_5]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_7]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_9]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_11]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_13]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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 __v_15: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_15]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_227] = [__v_15]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_228: usize = 3; -const IN_228: usize = 3; -const OUT_228: usize = 2; -fn aiur_fn_228(inp: [G; IN_228], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_228] = [__v_10, __v_13]; record.function_queries[228].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_228] = [__v_10, __v_11]; record.function_queries[228].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_228] = [__v_6, __v_7]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; 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_2] = { let __args: [G; IN_2] = [__v_0, __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_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 __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_228] = [__v_10, __v_11]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_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_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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(7); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_20, __v_17, __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_228] = [__v_18, __v_21]; record.function_queries[228].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_228] = [__v_16, __v_17]; record.function_queries[228].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_228] = [__v_16, __v_17]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_228] = [__v_10, __v_11]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = []; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_228] = [__v_12, __v_13]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = []; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_1]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_228] = [__v_14, __v_15]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = []; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_14]; 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_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(543, (&__args[..]))?) { [G::ZERO; OUT_543] } else { let (__hash, __hit) = record.function_queries[543].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[543].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { (*(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543])) }; __ret }, _ => { aiur_fn_543::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_228] = [__v_16, __v_17]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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]; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(2); let __v_19: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = 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_19.as_canonical_u64() { 1u64 => { 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_228] = [__v_20, __v_21]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: 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_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: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; let __v_27: G = __loaded[3]; match __v_24.as_canonical_u64() { 7u64 => { match __v_25.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_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: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; match __v_28.as_canonical_u64() { 7u64 => { match __v_29.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_26, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(7); let __v_35: G = G::from_u64(0); let __v_36: G = { let __values: [G; 4] = [__v_34, __v_33, __v_32, __v_35]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_228] = [__v_33, __v_36]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_32, __v_32, __v_32, __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 __ret: [G; OUT_228] = [__v_32, __v_33]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_32, __v_32, __v_32, __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 __ret: [G; OUT_228] = [__v_32, __v_33]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_28, __v_28, __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_228] = [__v_28, __v_29]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_28, __v_28, __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_228] = [__v_28, __v_29]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { 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_228] = [__v_18, __v_19]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_229: usize = 1; -const IN_229: usize = 1; -const OUT_229: usize = 2; -fn aiur_fn_229(inp: [G; IN_229], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); 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() { 1u64 => { 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_229] = [__v_4, __v_5]; record.function_queries[229].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: 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_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() { 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_8]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __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_15: G = G::from_u64(2); let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; 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 = 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 = { let __values: [G; 4] = [__v_15, __v_16, __v_18, __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_20: G = G::from_u64(3); let __v_21: G = { let __values: [G; 4] = [__v_20, __v_19, __v_14, __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_229] = [__v_17, __v_21]; record.function_queries[229].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_229] = [__v_10, __v_11]; record.function_queries[229].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_229] = [__v_10, __v_11]; record.function_queries[229].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_227(inp: [G; IN_227], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = G::from_u64(77); let __v_1: G = G::from_u64(166); let __v_2: G = G::from_u64(97); let __v_3: G = G::from_u64(145); let __v_4: G = G::from_u64(122); let __v_5: G = G::from_u64(88); let __v_6: G = G::from_u64(21); let __v_7: G = G::from_u64(47); let __v_8: G = G::from_u64(92); let __v_9: G = G::from_u64(169); let __v_10: G = G::from_u64(116); let __v_11: G = G::from_u64(210); let __v_12: G = G::from_u64(37); let __v_13: G = G::from_u64(109); let __v_14: G = G::from_u64(152); let __v_15: G = G::from_u64(239); let __v_16: G = G::from_u64(215); let __v_17: G = G::from_u64(34); let __v_18: G = G::from_u64(196); let __v_19: G = G::from_u64(241); let __v_20: G = G::from_u64(99); let __v_21: G = G::from_u64(130); let __v_22: G = G::from_u64(233); let __v_23: G = G::from_u64(205); let __v_24: G = G::from_u64(240); let __v_25: G = G::from_u64(22); let __v_26: G = G::from_u64(223); let __v_27: G = G::from_u64(76); let __v_28: G = G::from_u64(87); let __v_29: G = G::from_u64(67); let __v_30: G = G::from_u64(104); let __v_31: 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_9, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_227] = [__v_31]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_228: usize = 0; +const IN_228: usize = 0; +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 = G::from_u64(218); let __v_1: G = G::from_u64(123); let __v_2: G = G::from_u64(179); let __v_3: G = G::from_u64(49); let __v_4: G = G::from_u64(224); let __v_5: G = G::from_u64(152); let __v_6: G = G::from_u64(249); let __v_7: G = G::from_u64(191); let __v_8: G = G::from_u64(92); let __v_9: G = G::from_u64(188); let __v_10: G = G::from_u64(185); let __v_11: G = G::from_u64(96); let __v_12: G = G::from_u64(154); let __v_13: G = G::from_u64(126); let __v_14: G = G::from_u64(149); let __v_15: G = G::from_u64(61); let __v_16: G = G::from_u64(255); let __v_17: G = G::from_u64(198); let __v_18: G = G::from_u64(9); let __v_19: G = G::from_u64(173); let __v_20: G = G::from_u64(157); let __v_21: G = G::from_u64(144); let __v_22: G = G::from_u64(135); let __v_23: G = G::from_u64(26); let __v_24: G = G::from_u64(20); let __v_25: G = G::from_u64(192); let __v_26: G = G::from_u64(22); let __v_27: G = G::from_u64(197); let __v_28: G = G::from_u64(42); let __v_29: G = G::from_u64(48); let __v_30: G = G::from_u64(17); let __v_31: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_0, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_228] = [__v_31]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_229: usize = 0; +const IN_229: usize = 0; +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 = G::from_u64(34); let __v_1: G = G::from_u64(22); let __v_2: G = G::from_u64(37); let __v_3: G = G::from_u64(160); let __v_4: G = G::from_u64(14); let __v_5: G = G::from_u64(226); let __v_6: G = G::from_u64(214); let __v_7: G = G::from_u64(185); let __v_8: G = G::from_u64(98); let __v_9: G = G::from_u64(151); let __v_10: G = G::from_u64(227); let __v_11: G = G::from_u64(77); let __v_12: G = G::from_u64(126); let __v_13: G = G::from_u64(5); let __v_14: G = G::from_u64(191); let __v_15: G = G::from_u64(79); let __v_16: G = G::from_u64(211); let __v_17: G = G::from_u64(141); let __v_18: G = G::from_u64(153); let __v_19: G = G::from_u64(225); let __v_20: G = G::from_u64(74); let __v_21: G = G::from_u64(124); let __v_22: G = G::from_u64(210); let __v_23: G = G::from_u64(224); let __v_24: G = G::from_u64(108); let __v_25: G = G::from_u64(117); let __v_26: G = G::from_u64(45); let __v_27: 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_12, __v_15, __v_16, __v_17, __v_17, __v_18, __v_16, __v_19, __v_6, __v_20, __v_21, __v_22, __v_23, __v_24, __v_3, __v_25, __v_26]; 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_229] = [__v_27]; 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 = 2; -fn aiur_fn_230(inp: [G; IN_230], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); 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() { 1u64 => { 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_230] = [__v_4, __v_5]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: 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_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() { 7u64 => { 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_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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(2); let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = []; 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_15: G = __r_arr[0]; let __v_16: 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_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_14, __v_15, __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 __ret: [G; OUT_230] = [__v_13, __v_18]; record.function_queries[230].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_230] = [__v_13, __v_14]; record.function_queries[230].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_230] = [__v_10, __v_11]; record.function_queries[230].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_230] = [__v_10, __v_11]; 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 = 0; -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; 3] = { let __base = 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_231] = []; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5]; 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 __ret: [G; OUT_231] = []; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; 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_1: G = __r_arr[0]; 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_230] = [__v_3]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; 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_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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_230] = [__v_5]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_230] = [__v_7]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_230] = [__v_9]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_230] = [__v_11]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_230] = [__v_13]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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 __v_15: G = G::from_u64(1); let __ret: [G; OUT_230] = [__v_15]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_230] = [__v_15]; 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 = 2; +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7, __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_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_231] = [__v_10, __v_13]; record.function_queries[231].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_231] = [__v_10, __v_11]; record.function_queries[231].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_231] = [__v_6, __v_7]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; 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_2] = { let __args: [G; IN_2] = [__v_0, __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_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 __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_231] = [__v_10, __v_11]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_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_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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; 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 __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(7); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_20, __v_17, __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_231] = [__v_18, __v_21]; record.function_queries[231].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_231] = [__v_16, __v_17]; record.function_queries[231].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_231] = [__v_16, __v_17]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = []; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_231] = [__v_10, __v_11]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = []; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_231] = [__v_12, __v_13]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = []; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_231] = [__v_14, __v_15]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = []; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_14]; 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_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_231] = [__v_16, __v_17]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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]; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(2); let __v_19: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = 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_19.as_canonical_u64() { 1u64 => { 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_231] = [__v_20, __v_21]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: 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_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: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; let __v_27: G = __loaded[3]; match __v_24.as_canonical_u64() { 7u64 => { match __v_25.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_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: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; match __v_28.as_canonical_u64() { 7u64 => { match __v_29.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_26, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(7); let __v_35: G = G::from_u64(0); let __v_36: G = { let __values: [G; 4] = [__v_34, __v_33, __v_32, __v_35]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_231] = [__v_33, __v_36]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_32, __v_32, __v_32, __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 __ret: [G; OUT_231] = [__v_32, __v_33]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_32, __v_32, __v_32, __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 __ret: [G; OUT_231] = [__v_32, __v_33]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_28, __v_28, __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_231] = [__v_28, __v_29]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_28, __v_28, __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_231] = [__v_28, __v_29]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { 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_231] = [__v_18, __v_19]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }) } const INPUT_SIZE_232: usize = 1; const IN_232: usize = 1; -const OUT_232: usize = 1; -fn aiur_fn_232(inp: [G; IN_232], 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 = G::from_u64(65); let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __ret: [G; OUT_232] = [__v_2]; record.function_queries[232].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_233: usize = 2; -const IN_233: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_233] = [__v_1]; record.function_queries[233].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_3, __v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_6, __v_5]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_233] = [__v_7]; record.function_queries[233].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); 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() { 1u64 => { 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_232] = [__v_4, __v_5]; record.function_queries[232].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: 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_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() { 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_8]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_10]; 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_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __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_15: G = G::from_u64(2); let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = []; 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_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 = { let __values: [G; 4] = [__v_15, __v_16, __v_18, __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_20: G = G::from_u64(3); let __v_21: G = { let __values: [G; 4] = [__v_20, __v_19, __v_14, __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_232] = [__v_17, __v_21]; record.function_queries[232].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_232] = [__v_10, __v_11]; record.function_queries[232].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_232] = [__v_10, __v_11]; record.function_queries[232].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_233: usize = 1; +const IN_233: usize = 1; +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); 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() { 1u64 => { 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_233] = [__v_4, __v_5]; record.function_queries[233].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: 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_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() { 7u64 => { 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_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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(2); let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = []; 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_15: G = __r_arr[0]; let __v_16: 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_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_14, __v_15, __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 __ret: [G; OUT_233] = [__v_13, __v_18]; record.function_queries[233].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_233] = [__v_13, __v_14]; record.function_queries[233].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_233] = [__v_10, __v_11]; record.function_queries[233].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_233] = [__v_10, __v_11]; 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 __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_234] = [__v_6]; record.function_queries[234].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_235: usize = 2; -const IN_235: usize = 2; -const OUT_235: usize = 2; -fn aiur_fn_235(inp: [G; IN_235], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; 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_235] = [__v_0, __v_1]; record.function_queries[235].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_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_15: G = __r_arr[0]; let __v_16: G = (__v_14 + __v_15); let __ret: [G; OUT_235] = [__v_16, __v_10]; record.function_queries[235].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_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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(64); let __v_22: G = (__v_20 * __v_21); let __r_arr: [G; OUT_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_23: G = __r_arr[0]; let __v_24: G = (__v_22 + __v_23); let __v_25: G = (__v_19 + __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 __ret: [G; OUT_235] = [__v_25, __v_15]; record.function_queries[235].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_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_23: G = __r_arr[0]; let __v_24: G = G::from_u64(4096); let __v_25: G = (__v_23 * __v_24); let __r_arr: [G; OUT_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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(64); let __v_28: G = (__v_26 * __v_27); let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_17]; 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_29: G = __r_arr[0]; let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_25 + __v_30); let __v_32: G = (__v_22 + __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 __ret: [G; OUT_235] = [__v_32, __v_18]; record.function_queries[235].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_236: usize = 1; -const IN_236: usize = 1; +const OUT_234: usize = 0; +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; 3] = { let __base = 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_234] = []; record.function_queries[234].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; 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 __ret: [G; OUT_234] = []; 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 = 1; +const IN_235: usize = 1; +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 = G::from_u64(65); 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_235] = [__v_2]; record.function_queries[235].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(0); 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 __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 = G::from_u64(2); let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; 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_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_5, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_219] = { let __args: [G; IN_219] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, (&__args[..]))?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { (*(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219])) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __v_9, __v_5, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_220] = { let __args: [G; IN_220] = []; 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_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_6, __v_11, __v_4, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_217] = { let __args: [G; IN_217] = []; 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_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_6, __v_13, __v_4, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_216] = { let __args: [G; IN_216] = []; 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 __v_16: G = { let __values: [G; 4] = [__v_6, __v_15, __v_4, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_8, __v_12, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_17, __v_10, __v_12, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_237] = { let __args: [G; IN_237] = [__v_0, __v_18, __v_19, __v_14]; 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_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_17, __v_16, __v_20, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __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_21]; record.function_queries[236].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_237: usize = 4; -const IN_237: usize = 4; +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 __loaded: [G; 3] = { let __base = 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_236] = [__v_1]; record.function_queries[236].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_3, __v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_6, __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_7: G = __r_arr[0]; let __ret: [G; OUT_236] = [__v_7]; record.function_queries[236].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.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 __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_237] = [__v_1]; record.function_queries[237].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_5, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__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_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_237] = { let __args: [G; IN_237] = [__v_8, __v_1, __v_2, __v_3]; 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_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_237] = [__v_17]; record.function_queries[237].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +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 = 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_237] = [__v_6]; record.function_queries[237].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_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 __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() { 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_295] = { let __args: [G; IN_295] = [__v_7]; 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_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 __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 __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_14, __v_24]; 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_25: 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_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_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; let __v_29: G = __loaded[3]; match __v_26.as_canonical_u64() { 4u64 => { let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_28, __v_4, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_31, __v_1]; 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_32: G = __r_arr[0]; let __ret: [G; OUT_238] = [__v_32]; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_30, __v_25, __v_4, __v_31]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_431] = { let __args: [G; IN_431] = [__v_32, __v_1]; 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_33: G = __r_arr[0]; let __ret: [G; OUT_238] = [__v_33]; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_238] = [__v_0]; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_238] = [__v_0]; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_238] = [__v_0]; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_239: usize = 2; -const IN_239: usize = 2; +const OUT_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]; 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_238] = [__v_0, __v_1]; record.function_queries[238].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_237] = { let __args: [G; IN_237] = [__v_9]; 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_15: G = __r_arr[0]; let __v_16: G = (__v_14 + __v_15); let __ret: [G; OUT_238] = [__v_16, __v_10]; record.function_queries[238].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_237] = { let __args: [G; IN_237] = [__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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(64); let __v_22: G = (__v_20 * __v_21); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_14]; 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 __v_24: G = (__v_22 + __v_23); let __v_25: G = (__v_19 + __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 __ret: [G; OUT_238] = [__v_25, __v_15]; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_237] = { let __args: [G; IN_237] = [__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_23: G = __r_arr[0]; let __v_24: G = G::from_u64(4096); let __v_25: G = (__v_23 * __v_24); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_14]; 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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(64); let __v_28: G = (__v_26 * __v_27); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_17]; 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_29: G = __r_arr[0]; let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_25 + __v_30); let __v_32: G = (__v_22 + __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 __ret: [G; OUT_238] = [__v_32, __v_18]; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_239: usize = 1; +const IN_239: usize = 1; 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 __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() { 7u64 => { match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__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_6: G = __r_arr[0]; let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_6, __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_7: G = __r_arr[0]; let __ret: [G; OUT_239] = [__v_7]; record.function_queries[239].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_239] = [__v_0]; record.function_queries[239].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_239] = [__v_0]; 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 = 4; -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 = G::from_u64(0); let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_7, __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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_240] = [__v_2, __v_4, __v_6, __v_8]; record.function_queries[240].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_241: usize = 1; -const IN_241: 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 = G::from_u64(0); 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 __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 = G::from_u64(2); let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = []; 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_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_5, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_222] = { let __args: [G; IN_222] = []; 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 = { let __values: [G; 4] = [__v_6, __v_9, __v_5, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_223] = { let __args: [G; IN_223] = []; 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_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_6, __v_11, __v_4, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_220] = { let __args: [G; IN_220] = []; 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_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_6, __v_13, __v_4, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_219] = { let __args: [G; IN_219] = []; 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 = { let __values: [G; 4] = [__v_6, __v_15, __v_4, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_8, __v_12, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_17, __v_10, __v_12, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_240] = { let __args: [G; IN_240] = [__v_0, __v_18, __v_19, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, (&__args[..]))?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { (*(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240])) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_17, __v_16, __v_20, __v_1]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_239] = [__v_21]; record.function_queries[239].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_240: usize = 4; +const IN_240: usize = 4; +const OUT_240: usize = 1; +fn aiur_fn_240(inp: [G; IN_240], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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_240] = [__v_1]; record.function_queries[240].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_5, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_7]; 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_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_240] = { let __args: [G; IN_240] = [__v_8, __v_1, __v_2, __v_3]; 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_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_240] = [__v_17]; record.function_queries[240].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_241: usize = 2; +const IN_241: usize = 2; 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 __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[240].lookup((&__args[..])); match __hit { Some(__i) if true => { 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_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 = G::from_u64(65536); let __v_13: G = (__v_12 * __v_8); let __v_14: G = G::from_u64(16777216); let __v_15: G = (__v_14 * __v_9); let __v_16: G = (__v_13 + __v_15); let __v_17: G = (__v_11 + __v_16); let __v_18: G = (__v_6 + __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_130] = { let __args: [G; IN_130] = [__v_21]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_241] = [__v_22]; record.function_queries[241].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __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() { 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_298] = { let __args: [G; IN_298] = [__v_7]; 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_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 __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 __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_14, __v_24]; 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_25: 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_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_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; let __v_29: G = __loaded[3]; match __v_26.as_canonical_u64() { 4u64 => { let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_28, __v_4, __v_30]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_31, __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_32: G = __r_arr[0]; let __ret: [G; OUT_241] = [__v_32]; record.function_queries[241].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_30, __v_25, __v_4, __v_31]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_434] = { let __args: [G; IN_434] = [__v_32, __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_33: G = __r_arr[0]; let __ret: [G; OUT_241] = [__v_33]; record.function_queries[241].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_241] = [__v_0]; record.function_queries[241].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_241] = [__v_0]; record.function_queries[241].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_241] = [__v_0]; 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 = 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 __v_1: G = inp[1]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __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_2: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__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_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() { 2u64 => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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 __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_242] = [__v_12, __v_13]; record.function_queries[242].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; 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_242] = [__v_12, __v_14]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { 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_242] = [__v_13, __v_15]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 3u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_4, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_15, __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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(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_242] = [__v_18, __v_20]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_18: G = G::from_u64(2); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_4, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_19, __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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_242] = [__v_22, __v_21]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_17, __v_21]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_242] = [__v_22, __v_23]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = { 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_242] = [__v_14, __v_16]; record.function_queries[242].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; 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_242] = [__v_9, __v_11]; 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]; 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 __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_243] = [__v_4, __v_3]; record.function_queries[243].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __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_4: 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_243] = [__v_5, __v_6]; record.function_queries[243].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __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() { 7u64 => { match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_242] = [__v_7]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_242] = [__v_0]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_242] = [__v_0]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_243: usize = 1; +const IN_243: usize = 1; +const OUT_243: usize = 4; +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 = G::from_u64(0); 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 __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_7, __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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_243] = [__v_2, __v_4, __v_6, __v_8]; 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; 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 __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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_11, __v_11]; record.function_queries[244].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_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_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() { 0u64 => { let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_244] = [__v_15, __v_16]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_15, __v_15]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_15, __v_15]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_9, __v_9]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_5, __v_5]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_245: usize = 1; -const IN_245: 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 __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if true => { 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_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 = G::from_u64(65536); let __v_13: G = (__v_12 * __v_8); let __v_14: G = G::from_u64(16777216); let __v_15: G = (__v_14 * __v_9); let __v_16: G = (__v_13 + __v_15); let __v_17: G = (__v_11 + __v_16); let __v_18: G = (__v_6 + __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_133] = { let __args: [G; IN_133] = [__v_21]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_244] = [__v_22]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_245: usize = 2; +const IN_245: usize = 2; const OUT_245: usize = 2; -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; 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_8 + __v_9); let __v_22: G = (__v_7 + __v_21); let __v_23: G = (__v_6 + __v_22); let __v_24: G = (__v_5 + __v_23); 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_245] = [__v_26, __v_26]; record.function_queries[245].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 = G::from_u64(65536); let __v_29: G = (__v_4 * __v_28); let __v_30: G = (__v_27 + __v_29); let __v_31: G = (__v_2 + __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_245] = [__v_34, __v_31]; record.function_queries[245].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_245] = [__v_36, __v_36]; record.function_queries[245].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_245] = [__v_38, __v_31]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __ret: [G; OUT_245] = [__v_38, __v_38]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_245] = [__v_21, __v_21]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_245] = [__v_11, __v_11]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; 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_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() { 2u64 => { let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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 __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_245] = [__v_12, __v_13]; record.function_queries[245].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; 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_245] = [__v_12, __v_14]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { 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_245] = [__v_13, __v_15]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 3u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_4, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_15, __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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(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_245] = [__v_18, __v_20]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_18: G = G::from_u64(2); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_4, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19, __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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_245] = [__v_22, __v_21]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_17, __v_21]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_245] = [__v_22, __v_23]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = { 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_245] = [__v_14, __v_16]; record.function_queries[245].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; 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_245] = [__v_9, __v_11]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_246: usize = 2; const IN_246: usize = 2; const OUT_246: usize = 2; -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 __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_246] = [__v_0, __v_1]; record.function_queries[246].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_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 __v_9: G = __r_arr[1]; let __ret: [G; OUT_246] = [__v_8, __v_9]; record.function_queries[246].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_246] = [__v_4, __v_3]; record.function_queries[246].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_1]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_246] = [__v_5, __v_6]; record.function_queries[246].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_247: usize = 1; const IN_247: usize = 1; -const OUT_247: usize = 4; -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 = G::from_u64(0); let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3, __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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_5, __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 = __r_arr[1]; let __ret: [G; OUT_247] = [__v_2, __v_4, __v_6, __v_7]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -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 __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __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 = G::from_u64(4096); let __v_19: G = (__v_9 * __v_18); let __v_20: G = G::from_u64(262144); let __v_21: G = (__v_10 * __v_20); let __v_22: G = (__v_19 + __v_21); let __v_23: G = (__v_17 + __v_22); let __v_24: G = (__v_7 + __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_248] = [__v_28]; record.function_queries[248].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_248] = [__v_35]; record.function_queries[248].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_248] = [__v_39]; record.function_queries[248].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_248] = [__v_41]; record.function_queries[248].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -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 __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; 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_1: G = __r_arr[0]; 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_249] = [__v_3]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_5]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_7]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_9]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_11]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_13]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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 __v_15: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_15]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; 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]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_17]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_19]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; 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 = G::from_u64(1); let __ret: [G; OUT_249] = [__v_21]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_23]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_25]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_27]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; 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_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_29]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; 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_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_31]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; 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]; match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_33]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); let __ret: [G; OUT_249] = [__v_33]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }) } +const OUT_247: usize = 2; +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; 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 __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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_11, __v_11]; record.function_queries[247].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_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_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() { 0u64 => { let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(248, (&__args[..]))?) { [G::ZERO; OUT_248] } else { let (__hash, __hit) = record.function_queries[248].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[248].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { (*(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248])) }; __ret }, _ => { aiur_fn_248::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_247] = [__v_15, __v_16]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_15, __v_15]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_15, __v_15]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_9, __v_9]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_5, __v_5]; 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 = 2; +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; 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_8 + __v_9); let __v_22: G = (__v_7 + __v_21); let __v_23: G = (__v_6 + __v_22); let __v_24: G = (__v_5 + __v_23); 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_248] = [__v_26, __v_26]; record.function_queries[248].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 = G::from_u64(65536); let __v_29: G = (__v_4 * __v_28); let __v_30: G = (__v_27 + __v_29); let __v_31: G = (__v_2 + __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_248] = [__v_34, __v_31]; record.function_queries[248].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_248] = [__v_36, __v_36]; record.function_queries[248].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_248] = [__v_38, __v_31]; record.function_queries[248].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __ret: [G; OUT_248] = [__v_38, __v_38]; record.function_queries[248].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_248] = [__v_21, __v_21]; record.function_queries[248].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_248] = [__v_11, __v_11]; record.function_queries[248].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __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_249] = [__v_0, __v_1]; record.function_queries[249].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_249] = { let __args: [G; IN_249] = [__v_5, __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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_249] = [__v_8, __v_9]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } 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 __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; 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_1: G = __r_arr[0]; 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]; let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; 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_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_6: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, (&__args[..]))?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { (*(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163])) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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]; let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; 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 __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_18: G = __r_arr[0]; let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; 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]; let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_16 + __v_21); let __v_23: G = (__v_14 + __v_22); let __v_24: G = (__v_12 + __v_23); let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_8 + __v_25); let __v_27: G = (__v_6 + __v_26); let __v_28: G = (__v_4 + __v_27); let __v_29: G = (__v_2 + __v_28); let __ret: [G; OUT_250] = [__v_29]; 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 = 2; -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; 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() { 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_251] = [__v_5, __v_3]; record.function_queries[251].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; 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 __ret: [G; OUT_251] = [__v_5, __v_7]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { 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_251] = [__v_7, __v_8]; record.function_queries[251].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_251] = [__v_7, __v_9]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_251] = [__v_5, __v_6]; record.function_queries[251].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; 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 __ret: [G; OUT_251] = [__v_5, __v_7]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_252: usize = 2; -const IN_252: usize = 2; -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 __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_156] = { let __args: [G; IN_156] = []; 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_6: G = __r_arr[0]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_9]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_10, __v_11]; record.function_queries[252].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_252] = [__v_10, __v_12]; record.function_queries[252].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_252] = [__v_8, __v_10]; record.function_queries[252].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_252] = [__v_6, __v_8]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const OUT_250: usize = 4; +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 = G::from_u64(0); let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_3, __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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_250] = [__v_2, __v_4, __v_6, __v_7]; record.function_queries[250].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if true => { 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 __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 = G::from_u64(4096); let __v_19: G = (__v_9 * __v_18); let __v_20: G = G::from_u64(262144); let __v_21: G = (__v_10 * __v_20); let __v_22: G = (__v_19 + __v_21); let __v_23: G = (__v_17 + __v_22); let __v_24: G = (__v_7 + __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_251] = [__v_28]; record.function_queries[251].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_251] = [__v_35]; record.function_queries[251].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_251] = [__v_39]; record.function_queries[251].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_251] = [__v_41]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_1: G = __r_arr[0]; 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_252] = [__v_3]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_5]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_7]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; 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_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_9]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_11]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_13]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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 __v_15: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_15]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; 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]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_17]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_19]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; 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 = G::from_u64(1); let __ret: [G; OUT_252] = [__v_21]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_23]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_25]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_27]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; 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_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_29]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; 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_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_31]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; 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]; match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_33]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); let __ret: [G; OUT_252] = [__v_33]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }) } 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 __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_253] = [__v_3]; record.function_queries[253].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; 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_1: G = __r_arr[0]; 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]; let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; 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 __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_4: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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 __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; 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 __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_18: G = __r_arr[0]; let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; 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]; let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_16 + __v_21); let __v_23: G = (__v_14 + __v_22); let __v_24: G = (__v_12 + __v_23); let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_8 + __v_25); let __v_27: G = (__v_6 + __v_26); let __v_28: G = (__v_4 + __v_27); let __v_29: G = (__v_2 + __v_28); let __ret: [G; OUT_253] = [__v_29]; record.function_queries[253].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_254: usize = 1; const IN_254: usize = 1; -const OUT_254: usize = 3; -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; 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 __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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_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 __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_158] = { let __args: [G; IN_158] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_10]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_254] = [__v_13, __v_14, __v_15]; record.function_queries[254].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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 __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_10]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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 __ret: [G; OUT_254] = [__v_15, __v_15, __v_17]; record.function_queries[254].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(1); let __v_17: G = { let __values: [G; 10] = [__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(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_254] = [__v_15, __v_15, __v_17]; record.function_queries[254].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_254] = [__v_11, __v_11, __v_13]; record.function_queries[254].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_254] = [__v_9, __v_9, __v_11]; record.function_queries[254].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; 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 __ret: [G; OUT_254] = [__v_5, __v_5, __v_7]; record.function_queries[254].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const OUT_254: usize = 2; +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; 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() { 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_254] = [__v_5, __v_3]; record.function_queries[254].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; 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 __ret: [G; OUT_254] = [__v_5, __v_7]; record.function_queries[254].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; 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_2] = { let __args: [G; IN_2] = [__v_2, __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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { 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_254] = [__v_7, __v_8]; record.function_queries[254].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_254] = [__v_7, __v_9]; record.function_queries[254].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, (&__args[..]))?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { (*(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255])) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_254] = [__v_5, __v_6]; record.function_queries[254].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; 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 __ret: [G; OUT_254] = [__v_5, __v_7]; record.function_queries[254].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_255: usize = 2; const IN_255: usize = 2; -const OUT_255: usize = 1; -fn aiur_fn_255(inp: [G; IN_255], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_2]; 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_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); let __v_6: G = (__v_0 * __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; 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_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, _ => { let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, } }; let __v_7: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_6.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_2]; }, _ => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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_8: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_8]; 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_9: G = __r_arr[0]; break '__mc_1 [__v_9]; }, } }; let __v_8: G = __mc_out___mc_1[0]; let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(2); 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 = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_10, __v_7, __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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8]; 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 = { let __values: [G; 4] = [__v_9, __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 __ret: [G; OUT_255] = [__v_16]; record.function_queries[255].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_256: usize = 4; -const IN_256: usize = 4; +const OUT_255: usize = 2; +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 __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_159] = { let __args: [G; IN_159] = []; 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_6: G = __r_arr[0]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_255] = [__v_10, __v_11]; record.function_queries[255].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_255] = [__v_10, __v_12]; record.function_queries[255].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_255] = [__v_8, __v_10]; record.function_queries[255].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_255] = [__v_6, __v_8]; record.function_queries[255].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __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); match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __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 __ret: [G; OUT_256] = [__v_6]; record.function_queries[256].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(132, (&__args[..]))?) { [G::ZERO; OUT_132] } else { let (__hash, __hit) = record.function_queries[132].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[132].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { (*(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132])) }; __ret }, _ => { aiur_fn_132::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_256] = [__v_7]; record.function_queries[256].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_256] = [__v_7]; record.function_queries[256].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_257: usize = 3; -const IN_257: usize = 3; -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 __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, (&__args[..]))?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { (*(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255])) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_257] = [__v_4]; record.function_queries[257].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_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_10: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_10]; 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 __ret: [G; OUT_257] = [__v_11]; record.function_queries[257].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_4]; 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_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); }, } }, } }) } -const INPUT_SIZE_258: usize = 4; -const IN_258: usize = 4; +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 = 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_256] = [__v_3]; 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 = 3; +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; 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 __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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_10]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_257] = [__v_13, __v_14, __v_15]; record.function_queries[257].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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 __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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 __ret: [G; OUT_257] = [__v_15, __v_15, __v_17]; record.function_queries[257].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(1); let __v_17: G = { let __values: [G; 10] = [__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(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_257] = [__v_15, __v_15, __v_17]; record.function_queries[257].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_257] = [__v_11, __v_11, __v_13]; record.function_queries[257].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_257] = [__v_9, __v_9, __v_11]; record.function_queries[257].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; 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 __ret: [G; OUT_257] = [__v_5, __v_5, __v_7]; 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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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_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_255] = { let __args: [G; IN_255] = [__v_5, __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_258] = [__v_8]; record.function_queries[258].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __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_144] = { let __args: [G; IN_144] = [__v_1, __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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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_8: G = __r_arr[0]; let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_0 * __v_9); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, (&__args[..]))?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { (*(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123])) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, _ => { break '__mc_0 [__v_5]; }, } }; let __v_11: G = __mc_out___mc_0[0]; let __v_12: G = G::from_u64(2); let __v_13: G = (__v_0 * __v_2); let __v_14: G = (__v_12 * __v_13); let __v_15: G = (__v_2 - __v_14); let __v_16: G = (__v_0 + __v_15); let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_11]; 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_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = (__v_16 * __v_19); let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_11]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_258] = [__v_21]; record.function_queries[258].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_259: usize = 3; -const IN_259: usize = 3; +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 __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_2]; 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_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); let __v_6: G = (__v_0 * __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; 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_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, _ => { let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; 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_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, } }; let __v_7: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_6.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_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_8: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_8]; 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_9: G = __r_arr[0]; break '__mc_1 [__v_9]; }, } }; let __v_8: G = __mc_out___mc_1[0]; let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(2); 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 = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_10, __v_7, __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 __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_8]; 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_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __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 __ret: [G; OUT_258] = [__v_16]; record.function_queries[258].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_259: usize = 4; +const IN_259: usize = 4; 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 __v_2: G = inp[2]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, (&__args[..]))?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { (*(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255])) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_259] = [__v_4]; record.function_queries[259].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_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_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, _ => { break '__mc_0 [__v_4]; }, } }; let __v_9: G = __mc_out___mc_0[0]; 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_123] = { let __args: [G; IN_123] = [__v_2]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_15, __v_14]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16, __v_9]; 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_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(1); let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_2, __v_9]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_19]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_259] = [__v_20]; record.function_queries[259].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __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_19: G = __r_arr[0]; let __ret: [G; OUT_259] = [__v_19]; record.function_queries[259].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 - __v_2); match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_259] = [__v_6]; record.function_queries[259].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_3]; 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]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_2, __v_6]; 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_259] = [__v_7]; record.function_queries[259].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __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_258] = { let __args: [G; IN_258] = [__v_0, __v_6]; 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_259] = [__v_7]; record.function_queries[259].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_260: usize = 3; const IN_260: usize = 3; 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 __v_2: G = inp[2]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); 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 __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_4, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_7]; record.function_queries[260].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_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_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, _ => { break '__mc_0 [__v_4]; }, } }; let __v_9: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; 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 __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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 __v_13: G = (__v_11 - __v_12); let __v_14: G = (__v_0 * __v_13); let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_10]; 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_15: G = __r_arr[0]; break '__mc_1 [__v_15]; }, _ => { break '__mc_1 [__v_10]; }, } }; let __v_15: G = __mc_out___mc_1[0]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_15]; 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_17: G = __r_arr[0]; let __v_18: G = (__v_16 - __v_17); let __v_19: G = (__v_0 * __v_18); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(2); let __v_22: G = { let __values: [G; 10] = [__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(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_23: G = { let __values: [G; 10] = [__v_20, __v_21, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __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 __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2]; 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 __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, (&__args[..]))?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { (*(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143])) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_25, __v_9]; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_15]; 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_27: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_27]; record.function_queries[260].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_28, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __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 __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_19, __v_15, __v_27, __v_30]; 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_31: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_31]; record.function_queries[260].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_261: usize = 3; -const IN_261: usize = 3; -const OUT_261: usize = 2; -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 __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; 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 __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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 = (__v_6 + __v_8); match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __a_val = __v_4.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_11.as_canonical_u64() { 1u64 => { 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_261] = [__v_12, __v_13]; record.function_queries[261].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_18: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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]; break '__mc_0 [__v_19]; }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = (__v_19 - __v_15); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_16]; 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_21: G = __r_arr[0]; let __v_22: G = (__v_19 - __v_21); let __v_23: G = (__v_20 * __v_22); let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_23, __v_16]; 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_24: G = __r_arr[0]; break '__mc_0 [__v_24]; }, } }; let __v_19: G = __mc_out___mc_0[0]; let __v_20: G = G::from_u64(1); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_3, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_19, __v_21]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_20, __v_22]; record.function_queries[261].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_261] = [__v_17, __v_18]; record.function_queries[261].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_10: G = G::from_u64(2); let __v_11: G = { let __a_val = __v_4.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_11.as_canonical_u64() { 1u64 => { 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_261] = [__v_12, __v_13]; record.function_queries[261].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_3, __v_15, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_261] = [__v_17, __v_18]; record.function_queries[261].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_261] = [__v_17, __v_18]; record.function_queries[261].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_262: usize = 4; -const IN_262: usize = 4; -const OUT_262: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; 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_2] = { let __args: [G; IN_2] = [__v_0, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_13]; 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 __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_2, __v_3, __v_15]; 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_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, _ => { let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_18]; 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_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3, __v_15]; 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_20: G = __r_arr[0]; break '__mc_0 [__v_20]; }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(2); 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 __v_24: G = { let __values: [G; 10] = [__v_20, __v_21, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __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 __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_15, __v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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_26: G = __r_arr[0]; let __v_27: G = (__v_22 - __v_26); let __v_28: G = (__v_2 * __v_27); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_15]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_28, __v_29]; 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_30: G = __r_arr[0]; break '__mc_0 [__v_30]; }, } }, } }; let __v_18: G = __mc_out___mc_0[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(2); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_18, __v_21]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_262] = [__v_19, __v_22]; record.function_queries[262].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_262] = [__v_16, __v_17]; record.function_queries[262].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_18: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_2, __v_3, __v_15, __v_16]; 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_19: G = __r_arr[0]; break '__mc_1 [__v_19]; }, _ => { let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; 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 = G::from_u64(1); let __v_22: G = (__v_21 - __v_15); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_16]; 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_23: G = __r_arr[0]; let __v_24: G = (__v_21 - __v_23); let __v_25: G = (__v_22 * __v_24); let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_2, __v_3, __v_25, __v_16]; 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_26: G = __r_arr[0]; break '__mc_1 [__v_26]; }, _ => { let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(2); let __v_24: G = (__v_2 * __v_15); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_15 - __v_25); let __v_27: G = (__v_2 + __v_26); let __v_28: G = G::from_u64(1); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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_29: G = __r_arr[0]; let __v_30: G = (__v_28 - __v_29); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_16]; 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_31: G = __r_arr[0]; let __v_32: G = (__v_28 - __v_31); let __v_33: G = (__v_30 * __v_32); let __v_34: G = (__v_27 * __v_33); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __v_16]; 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_35: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_34, __v_35]; 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_36: G = __r_arr[0]; break '__mc_1 [__v_36]; }, _ => { let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3, __v_16]; 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_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, _ => { let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_2, __v_3, __v_15, __v_16]; 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_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, } }, } }, } }, } }; let __v_19: G = __mc_out___mc_1[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(2); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_1, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_19, __v_22]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_262] = [__v_20, __v_23]; record.function_queries[262].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_262] = [__v_17, __v_18]; record.function_queries[262].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_263: usize = 2; -const IN_263: usize = 2; +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 __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { 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_4: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_4]; record.function_queries[260].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1, __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]; let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_2, __v_4]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_9, __v_10]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_11]; record.function_queries[260].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_9, __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_10: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_10]; record.function_queries[260].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_261: usize = 4; +const IN_261: usize = 4; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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_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_258] = { let __args: [G; IN_258] = [__v_5, __v_7]; 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 __ret: [G; OUT_261] = [__v_8]; record.function_queries[261].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1, __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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_6]; 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_8: G = __r_arr[0]; let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_0 * __v_9); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__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_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, _ => { break '__mc_0 [__v_5]; }, } }; let __v_11: G = __mc_out___mc_0[0]; let __v_12: G = G::from_u64(2); let __v_13: G = (__v_0 * __v_2); let __v_14: G = (__v_12 * __v_13); let __v_15: G = (__v_2 - __v_14); let __v_16: G = (__v_0 + __v_15); let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_11]; 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_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = (__v_16 * __v_19); let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_20, __v_11]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_21]; record.function_queries[261].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_262: usize = 3; +const IN_262: usize = 3; +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 __v_2: G = inp[2]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { 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_4: G = __r_arr[0]; let __ret: [G; OUT_262] = [__v_4]; record.function_queries[262].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1, __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]; let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_2, __v_4]; 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_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, _ => { break '__mc_0 [__v_4]; }, } }; let __v_9: G = __mc_out___mc_0[0]; 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_126] = { let __args: [G; IN_126] = [__v_2]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_15, __v_14]; 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_135] = { let __args: [G; IN_135] = [__v_16, __v_9]; 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_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(1); let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_2, __v_9]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_18, __v_19]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_262] = [__v_20]; record.function_queries[262].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_18, __v_9]; 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_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); }, } }, } }) } +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 __loaded: [G; 3] = { let __base = 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_263] = [__v_0]; record.function_queries[263].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_263] = { let __args: [G; IN_263] = [__v_7, __v_4]; 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]; let __ret: [G; OUT_263] = [__v_8]; record.function_queries[263].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); 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 __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_4, __v_6]; 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_263] = [__v_7]; record.function_queries[263].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1, __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]; let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_2, __v_4]; 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_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, _ => { break '__mc_0 [__v_4]; }, } }; let __v_9: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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 __v_13: G = (__v_11 - __v_12); let __v_14: G = (__v_0 * __v_13); let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10]; 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_15: G = __r_arr[0]; break '__mc_1 [__v_15]; }, _ => { break '__mc_1 [__v_10]; }, } }; let __v_15: G = __mc_out___mc_1[0]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, (&__args[..]))?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { (*(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144])) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_16 - __v_17); let __v_19: G = (__v_0 * __v_18); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(2); let __v_22: G = { let __values: [G; 10] = [__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(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_23: G = { let __values: [G; 10] = [__v_20, __v_21, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_2]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_24, __v_23]; 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 __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_25, __v_9]; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_19, __v_15]; 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_27: G = __r_arr[0]; let __ret: [G; OUT_263] = [__v_27]; record.function_queries[263].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_28, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __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 __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_19, __v_15, __v_27, __v_30]; 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_31: G = __r_arr[0]; let __ret: [G; OUT_263] = [__v_31]; record.function_queries[263].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_264: usize = 3; const IN_264: usize = 3; 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 __v_2: G = inp[2]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; 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_3: G = __r_arr[0]; 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_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_125] = { let __args: [G; IN_125] = [__v_1, __v_2]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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_8: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_5, __v_8]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_2]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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_10: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_7, __v_10]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_9, __v_12]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; 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_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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_14: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_11, __v_14]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, (&__args[..]))?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { (*(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253])) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_13, __v_16]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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 __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1, __v_2]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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 __ret: [G; OUT_264] = [__v_15, __v_18]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; 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]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_18]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_19]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_17, __v_20]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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_150] = { let __args: [G; IN_150] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_20]; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_21]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_19, __v_22]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; 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 = G::from_u64(1); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_1, __v_2]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_22]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_23]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_21, __v_24]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_2]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_25]; 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_26: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_23, __v_26]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_26]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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 __ret: [G; OUT_264] = [__v_25, __v_28]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_1, __v_2]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_28]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_29]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_27, __v_30]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; 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_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1, __v_2]; 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_30: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_30]; 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_31: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_29, __v_31]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; 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_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; 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_32: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_32]; 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_33: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_31, __v_33]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_31, __v_31, __v_31, __v_31]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_264] = [__v_31, __v_32]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_265: usize = 2; -const IN_265: usize = 2; -const OUT_265: usize = 3; -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 __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_170] = { let __args: [G; IN_170] = []; 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 __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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(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_265] = [__v_8, __v_0, __v_10]; record.function_queries[265].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(2); let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_789] = { let __args: [G; IN_789] = [__v_1, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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() { 7u64 => { match __v_16.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); let __ret: [G; OUT_265] = [__v_19, __v_12, __v_17]; record.function_queries[265].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__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(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_265] = [__v_19, __v_0, __v_21]; record.function_queries[265].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__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(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_265] = [__v_19, __v_0, __v_21]; record.function_queries[265].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_265] = [__v_11, __v_0, __v_13]; record.function_queries[265].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_265] = [__v_6, __v_0, __v_8]; record.function_queries[265].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __v_2: G = inp[2]; let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_1, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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 = (__v_6 + __v_8); match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __a_val = __v_4.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_11.as_canonical_u64() { 1u64 => { 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_264] = [__v_12, __v_13]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_18: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_16]; 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_19: G = __r_arr[0]; break '__mc_0 [__v_19]; }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = (__v_19 - __v_15); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, (&__args[..]))?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { (*(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144])) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_19 - __v_21); let __v_23: G = (__v_20 * __v_22); let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_23, __v_16]; 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_24: G = __r_arr[0]; break '__mc_0 [__v_24]; }, } }; let __v_19: G = __mc_out___mc_0[0]; let __v_20: G = G::from_u64(1); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_3, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_19, __v_21]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_20, __v_22]; record.function_queries[264].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_264] = [__v_17, __v_18]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_10: G = G::from_u64(2); let __v_11: G = { let __a_val = __v_4.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_11.as_canonical_u64() { 1u64 => { 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_264] = [__v_12, __v_13]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_3, __v_15, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_264] = [__v_17, __v_18]; record.function_queries[264].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_264] = [__v_17, __v_18]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_265: usize = 4; +const IN_265: usize = 4; +const OUT_265: usize = 2; +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_169] = { let __args: [G; IN_169] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_2, __v_3, __v_15]; 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_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, _ => { let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_18]; 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_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3, __v_15]; 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_20: G = __r_arr[0]; break '__mc_0 [__v_20]; }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(2); 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 __v_24: G = { let __values: [G; 10] = [__v_20, __v_21, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __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 __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_15, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, (&__args[..]))?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { (*(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147])) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = (__v_22 - __v_26); let __v_28: G = (__v_2 * __v_27); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_3, __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_29: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_28, __v_29]; 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_30: G = __r_arr[0]; break '__mc_0 [__v_30]; }, } }, } }; let __v_18: G = __mc_out___mc_0[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(2); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_18, __v_21]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_265] = [__v_19, __v_22]; record.function_queries[265].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_265] = [__v_16, __v_17]; record.function_queries[265].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, (&__args[..]))?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { (*(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163])) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_18: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_2, __v_3, __v_15, __v_16]; 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_19: G = __r_arr[0]; break '__mc_1 [__v_19]; }, _ => { let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, (&__args[..]))?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { (*(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164])) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; 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 = G::from_u64(1); let __v_22: G = (__v_21 - __v_15); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_16]; 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_23: G = __r_arr[0]; let __v_24: G = (__v_21 - __v_23); let __v_25: G = (__v_22 * __v_24); let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_2, __v_3, __v_25, __v_16]; 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_26: G = __r_arr[0]; break '__mc_1 [__v_26]; }, _ => { let __r_arr: [G; OUT_165] = { let __args: [G; IN_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_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(2); let __v_24: G = (__v_2 * __v_15); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_15 - __v_25); let __v_27: G = (__v_2 + __v_26); let __v_28: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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_29: G = __r_arr[0]; let __v_30: G = (__v_28 - __v_29); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_16]; 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_31: G = __r_arr[0]; let __v_32: G = (__v_28 - __v_31); let __v_33: G = (__v_30 * __v_32); let __v_34: G = (__v_27 * __v_33); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_3, __v_16]; 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_35: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_34, __v_35]; 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_36: G = __r_arr[0]; break '__mc_1 [__v_36]; }, _ => { let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3, __v_16]; 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_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, _ => { let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_2, __v_3, __v_15, __v_16]; 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_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, } }, } }, } }, } }; let __v_19: G = __mc_out___mc_1[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(2); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_1, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_19, __v_22]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_265] = [__v_20, __v_23]; record.function_queries[265].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_265] = [__v_17, __v_18]; record.function_queries[265].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_266: usize = 2; const IN_266: usize = 2; 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 = G::from_u64(0); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 10] = [__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(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_5: G = { let __values: [G; 10] = [__v_2, __v_3, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __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 __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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 = G::from_u64(2); let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; 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_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_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_141] = { let __args: [G; IN_141] = [__v_7]; 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]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_13, __v_11, __v_0, __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_266] = [__v_15]; record.function_queries[266].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(2); let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; 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_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_13, __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(7); let __v_20: G = { let __values: [G; 4] = [__v_19, __v_17, __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_21: G = G::from_u64(3); let __v_22: G = { let __values: [G; 4] = [__v_21, __v_18, __v_0, __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_23: G = { let __values: [G; 4] = [__v_21, __v_22, __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 __v_24: G = { let __values: [G; 4] = [__v_21, __v_11, __v_23, __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_266] = [__v_24]; record.function_queries[266].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_267: usize = 1; -const IN_267: usize = 1; -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 __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() { 7u64 => { let __ret: [G; OUT_267] = [__v_0]; record.function_queries[267].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_5: G = __r_arr[0]; let __v_6: 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_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_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_265] = { let __args: [G; IN_265] = [__v_5, __v_6]; 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 __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_14]; 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_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_267] = [__v_0]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_12, __v_14]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_16]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_267] = [__v_0]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_267] = [__v_0]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_268: usize = 3; -const IN_268: usize = 3; -const OUT_268: usize = 2; -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 __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __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_5: G = __r_arr[0]; let __ret: [G; OUT_268] = [__v_4, __v_5]; record.function_queries[268].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; 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_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_4, __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 __v_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_9, __v_0, __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_253] = { let __args: [G; IN_253] = [__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_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __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 __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_13, __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_14: G = __r_arr[0]; let __ret: [G; OUT_268] = [__v_6, __v_14]; record.function_queries[268].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_269: usize = 1; -const IN_269: 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 __loaded: [G; 3] = { let __base = 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_266] = [__v_0]; record.function_queries[266].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_266] = { let __args: [G; IN_266] = [__v_7, __v_4]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_266] = [__v_8]; record.function_queries[266].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_267: usize = 3; +const IN_267: usize = 3; +const OUT_267: usize = 2; +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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; 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_3: G = __r_arr[0]; 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_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_128] = { let __args: [G; IN_128] = [__v_1, __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 __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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 __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_5, __v_8]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __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_8: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_9]; 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_267] = [__v_7, __v_10]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_11]; 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 __ret: [G; OUT_267] = [__v_9, __v_12]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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 __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_11, __v_14]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1, __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_14: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_13, __v_16]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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 __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_2]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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 __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_17]; 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_18: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_15, __v_18]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; 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]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_2]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_18]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_19]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_17, __v_20]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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_153] = { let __args: [G; IN_153] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_20]; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_21]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_19, __v_22]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; 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 = G::from_u64(1); let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_1, __v_2]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_22]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_23]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_21, __v_24]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_1, __v_2]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_25]; 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_26: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_23, __v_26]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_1, __v_2]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_26]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_27]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_25, __v_28]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_1, __v_2]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_28]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_29]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_27, __v_30]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; 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_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_1, __v_2]; 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_30: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_30]; 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_31: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_29, __v_31]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; 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_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; 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_32: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_32]; 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_33: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_31, __v_33]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_31, __v_31, __v_31, __v_31]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_267] = [__v_31, __v_32]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }) } +const INPUT_SIZE_268: usize = 2; +const IN_268: usize = 2; +const OUT_268: usize = 3; +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 __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_173] = { let __args: [G; IN_173] = []; 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_6: G = __r_arr[0]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(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_268] = [__v_8, __v_0, __v_10]; record.function_queries[268].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(2); let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_792] = { let __args: [G; IN_792] = [__v_1, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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() { 7u64 => { match __v_16.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); let __ret: [G; OUT_268] = [__v_19, __v_12, __v_17]; record.function_queries[268].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__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(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_268] = [__v_19, __v_0, __v_21]; record.function_queries[268].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__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(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_268] = [__v_19, __v_0, __v_21]; record.function_queries[268].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_268] = [__v_11, __v_0, __v_13]; record.function_queries[268].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_268] = [__v_6, __v_0, __v_8]; record.function_queries[268].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_269: usize = 2; +const IN_269: usize = 2; 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 __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() { 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_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() { 4u64 => { let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_7]; 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_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_156] = { let __args: [G; IN_156] = []; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_15]; 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]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_269] = [__v_17]; record.function_queries[269].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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); match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_10, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: 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_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: 4 })?; if (!unconstrained) { __mq.bump_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() { 0u64 => { let __v_26: G = G::from_bool((__v_23 == G::ZERO)); let __ret: [G; OUT_269] = [__v_26]; record.function_queries[269].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_269] = [__v_26]; record.function_queries[269].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_269] = [__v_20]; record.function_queries[269].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_269] = [__v_15]; record.function_queries[269].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_269] = [__v_9]; record.function_queries[269].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_269] = [__v_5]; record.function_queries[269].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_270: usize = 5; -const IN_270: usize = 5; -const OUT_270: usize = 2; -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 __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_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 __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_270] = [__v_7, __v_8]; record.function_queries[270].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__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_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_270] = [__v_10, __v_11]; record.function_queries[270].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_10: G = (__v_1 + __v_2); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 + __v_11); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_13]; 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_14: G = __r_arr[0]; match __v_14.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_270] = [__v_15, __v_16]; record.function_queries[270].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_4 + __v_16); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_20, __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_22: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_22]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_23, __v_18]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_270] = [__v_21, __v_24]; record.function_queries[270].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_9, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_270] = [__v_21, __v_22]; record.function_queries[270].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, } }) } +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 = inp[1]; let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 10] = [__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(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_5: G = { let __values: [G; 10] = [__v_2, __v_3, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __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 __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __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 __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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 = G::from_u64(2); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_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_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_144] = { let __args: [G; IN_144] = [__v_7]; 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]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_13, __v_11, __v_0, __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_269] = [__v_15]; record.function_queries[269].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(2); let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; 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_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_13, __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(7); let __v_20: G = { let __values: [G; 4] = [__v_19, __v_17, __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_21: G = G::from_u64(3); let __v_22: G = { let __values: [G; 4] = [__v_21, __v_18, __v_0, __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_23: G = { let __values: [G; 4] = [__v_21, __v_22, __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 __v_24: G = { let __values: [G; 4] = [__v_21, __v_11, __v_23, __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_269] = [__v_24]; record.function_queries[269].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_270: usize = 1; +const IN_270: usize = 1; +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 __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() { 7u64 => { let __ret: [G; OUT_270] = [__v_0]; record.function_queries[270].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_5: G = __r_arr[0]; let __v_6: 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_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_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_268] = { let __args: [G; IN_268] = [__v_5, __v_6]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, (&__args[..]))?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { (*(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144])) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_270] = [__v_0]; 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_12, __v_14]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_270] = [__v_16]; record.function_queries[270].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_270] = [__v_0]; record.function_queries[270].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_270] = [__v_0]; record.function_queries[270].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_271: usize = 3; const IN_271: usize = 3; 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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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 __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_271] = [__v_10, __v_11]; record.function_queries[271].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_1, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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_17: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_17, __v_15]; 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_18: G = __r_arr[0]; let __ret: [G; OUT_271] = [__v_14, __v_18]; record.function_queries[271].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_271] = [__v_14, __v_15]; record.function_queries[271].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_271] = [__v_10, __v_11]; record.function_queries[271].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_1, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_13]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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 __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_18, __v_15]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_271] = [__v_14, __v_19]; record.function_queries[271].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_271] = [__v_14, __v_15]; record.function_queries[271].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_1, __v_3]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_271] = [__v_8, __v_9]; record.function_queries[271].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_272: usize = 3; -const IN_272: usize = 3; -const OUT_272: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = G::from_u64(2); 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_272] = [__v_5, __v_6]; record.function_queries[272].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_789] = { let __args: [G; IN_789] = [__v_1, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_6]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_10, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(2); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_1, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_14, __v_16]; 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_18: G = __r_arr[0]; let __ret: [G; OUT_272] = [__v_17, __v_18]; record.function_queries[272].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_272] = [__v_15, __v_16]; record.function_queries[272].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_272] = [__v_13, __v_14]; record.function_queries[272].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_0, __v_6, __v_12, __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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_272] = [__v_13, __v_14]; record.function_queries[272].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_272] = [__v_13, __v_14]; 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; +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 __v_2: G = inp[2]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __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_5: G = __r_arr[0]; let __ret: [G; OUT_271] = [__v_4, __v_5]; record.function_queries[271].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; 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_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_4, __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 __v_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_9, __v_0, __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_256] = { let __args: [G; IN_256] = [__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_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __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 __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_13, __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_14: G = __r_arr[0]; let __ret: [G; OUT_271] = [__v_6, __v_14]; 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 __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() { 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_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() { 4u64 => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_7]; 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_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_159] = { let __args: [G; IN_159] = []; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_15]; 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]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_17]; record.function_queries[272].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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); match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_10, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: 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_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: 4 })?; if (!unconstrained) { __mq.bump_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() { 0u64 => { let __v_26: G = G::from_bool((__v_23 == G::ZERO)); let __ret: [G; OUT_272] = [__v_26]; record.function_queries[272].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_26]; record.function_queries[272].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_20]; record.function_queries[272].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_15]; record.function_queries[272].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_9]; record.function_queries[272].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_5]; record.function_queries[272].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_273: usize = 5; +const IN_273: usize = 5; const OUT_273: usize = 2; -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]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, (&__args[..]))?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { (*(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170])) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, (&__args[..]))?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { (*(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175])) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_2]; 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 __v_13: G = (__v_11 - __v_12); let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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_14: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_15]; 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_16: G = __r_arr[0]; let __v_17: G = (__v_11 - __v_16); let __v_18: G = (__v_13 * __v_17); let __v_19: G = (__v_10 * __v_18); let __v_20: G = (__v_5 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); 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 __ret: [G; OUT_273] = [__v_21, __v_22]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(2); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_3, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_1, __v_2, __v_22]; 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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; match __v_23.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(2); let __ret: [G; OUT_273] = [__v_25, __v_24]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_273] = [__v_25, __v_26]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(2); let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_0, __v_1, __v_2, __v_22]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_273] = [__v_23, __v_24]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_274: usize = 4; -const IN_274: usize = 4; -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 = 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_253] = { let __args: [G; IN_253] = [__v_2]; 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_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_263] = { let __args: [G; IN_263] = [__v_12, __v_3]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_274] = [__v_13]; record.function_queries[274].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_275: usize = 10; -const IN_275: usize = 10; -const OUT_275: usize = 8; -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 = inp[8]; let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 8u64 => { let __ret: [G; OUT_275] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[275].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_275] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[275].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_275] = { let __args: [G; IN_275] = [__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(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_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_275] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(2); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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(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_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_275] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_13: G = G::from_u64(3); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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(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_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_275] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_13: G = G::from_u64(4); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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(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_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_275] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_13: G = G::from_u64(5); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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(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_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_275] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_13: G = G::from_u64(6); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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(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_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_275] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_13: G = G::from_u64(7); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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(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_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_275] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(8); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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(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_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_275] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }) } -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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_276] = [__v_0]; record.function_queries[276].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_276] = [__v_6]; record.function_queries[276].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_276] = { let __args: [G; IN_276] = [__v_4, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_276] = [__v_7]; record.function_queries[276].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_277: usize = 1; -const IN_277: 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]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(2); 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 __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_273] = [__v_7, __v_8]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_7]; 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 __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_273] = [__v_10, __v_11]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_10: G = (__v_1 + __v_2); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 + __v_11); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_13]; 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_14: G = __r_arr[0]; match __v_14.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_273] = [__v_15, __v_16]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_4 + __v_16); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_15]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_20, __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_22: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_22]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_23, __v_18]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_273] = [__v_21, __v_24]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_15, __v_9, __v_18]; 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]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_273] = [__v_21, __v_22]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_274: usize = 3; +const IN_274: usize = 3; +const OUT_274: usize = 2; +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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 __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_274] = [__v_10, __v_11]; record.function_queries[274].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_1, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_16]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_17, __v_15]; 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_18: G = __r_arr[0]; let __ret: [G; OUT_274] = [__v_14, __v_18]; record.function_queries[274].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_274] = [__v_14, __v_15]; record.function_queries[274].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_274] = [__v_10, __v_11]; record.function_queries[274].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_1, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_13]; 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_133] = { let __args: [G; IN_133] = [__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 __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_18, __v_15]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_274] = [__v_14, __v_19]; record.function_queries[274].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_274] = [__v_14, __v_15]; record.function_queries[274].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_0, __v_1, __v_3]; 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 __v_9: G = __r_arr[1]; let __ret: [G; OUT_274] = [__v_8, __v_9]; record.function_queries[274].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_275: usize = 3; +const IN_275: usize = 3; +const OUT_275: usize = 2; +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 = G::from_u64(2); 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_275] = [__v_5, __v_6]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_792] = { let __args: [G; IN_792] = [__v_1, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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 = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_10, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(2); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_1, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_14, __v_16]; 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_18: G = __r_arr[0]; let __ret: [G; OUT_275] = [__v_17, __v_18]; record.function_queries[275].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_275] = [__v_15, __v_16]; record.function_queries[275].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_275] = [__v_13, __v_14]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_6, __v_12, __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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_275] = [__v_13, __v_14]; record.function_queries[275].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_275] = [__v_13, __v_14]; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_276: usize = 4; +const IN_276: usize = 4; +const OUT_276: usize = 2; +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 = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; 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_2] = { let __args: [G; IN_2] = [__v_0, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_2]; 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 __v_13: G = (__v_11 - __v_12); 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_15]; 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_16: G = __r_arr[0]; let __v_17: G = (__v_11 - __v_16); let __v_18: G = (__v_13 * __v_17); let __v_19: G = (__v_10 * __v_18); let __v_20: G = (__v_5 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); 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 __ret: [G; OUT_276] = [__v_21, __v_22]; record.function_queries[276].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(2); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_3, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_1, __v_2, __v_22]; 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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; match __v_23.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(2); let __ret: [G; OUT_276] = [__v_25, __v_24]; record.function_queries[276].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_276] = [__v_25, __v_26]; record.function_queries[276].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(2); let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_0, __v_1, __v_2, __v_22]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_276] = [__v_23, __v_24]; record.function_queries[276].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_277: usize = 4; +const IN_277: usize = 4; const OUT_277: usize = 1; -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 = G::from_u64(0); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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(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_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_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 __loaded: [G; 3] = { let __base = 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_277] = { let __args: [G; IN_277] = [__v_11]; 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_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_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_277] = [__v_28]; record.function_queries[277].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_277] = [__v_30]; record.function_queries[277].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_277] = [__v_27]; record.function_queries[277].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_278: usize = 1; -const IN_278: usize = 1; -const OUT_278: usize = 1; -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 __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_278] = [__v_11]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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_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_278] = [__v_13]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_10: G = G::from_u64(2); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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_11: G = __r_arr[0]; let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_3]; 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_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_278] = [__v_13]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_10: G = G::from_u64(3); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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_11: G = __r_arr[0]; let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_3]; 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_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_278] = [__v_13]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(4); let __r_arr: [G; OUT_19] = { let __args: [G; IN_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(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__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_278] = [__v_13]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __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_256] = { let __args: [G; IN_256] = [__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_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_266] = { let __args: [G; IN_266] = [__v_12, __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_13: G = __r_arr[0]; let __ret: [G; OUT_277] = [__v_13]; record.function_queries[277].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_278: usize = 10; +const IN_278: usize = 10; +const OUT_278: usize = 8; +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]; match __v_9.as_canonical_u64() { 8u64 => { let __ret: [G; OUT_278] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[278].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_278] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[278].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_278] = { let __args: [G; IN_278] = [__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(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_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_278] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(2); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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(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_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_278] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_13: G = G::from_u64(3); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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(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_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_278] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_13: G = G::from_u64(4); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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(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_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_278] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_13: G = G::from_u64(5); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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(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_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_278] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_13: G = G::from_u64(6); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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(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_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_278] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_13: G = G::from_u64(7); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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(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_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_278] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(8); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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(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_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_278] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }) } 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; 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_279] = [__v_13]; record.function_queries[279].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_278] = { let __args: [G; IN_278] = [__v_13]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_11, __v_1]; 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_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_279] = [__v_17]; record.function_queries[279].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_280: usize = 5; -const IN_280: usize = 5; +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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_279] = [__v_0]; record.function_queries[279].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_279] = [__v_6]; record.function_queries[279].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_279] = { let __args: [G; IN_279] = [__v_4, __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_279] = [__v_7]; record.function_queries[279].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.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 __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_19] = { let __args: [G; IN_19] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_4, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_278] = { let __args: [G; IN_278] = [__v_24]; 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_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_280] = [__v_28]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_23: G = G::from_u64(0); let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__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_280] = [__v_25]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_14, __v_4]; 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_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_280] = [__v_28]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_14, __v_4]; 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_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_280] = [__v_28]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_19] = { let __args: [G; IN_19] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_22, __v_1, __v_2, __v_3, __v_4]; 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_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_280] = [__v_28]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_25]; 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_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_280] = [__v_29]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_25]; 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_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_280] = [__v_29]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_23: G = G::from_u64(3); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 = 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_280] = [__v_27]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_23: G = G::from_u64(4); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_9, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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 = 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_280] = [__v_27]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __v_23: G = G::from_u64(5); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_11, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_12, __v_1, __v_2, __v_3, __v_4]; 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 = 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_280] = [__v_27]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __v_23: G = G::from_u64(6); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_11, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_12, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_13, __v_1, __v_2, __v_3, __v_4]; 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_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_280] = [__v_27]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_1, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_280] = { let __args: [G; IN_280] = [__v_26, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_280] = [__v_28]; record.function_queries[280].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_281: usize = 17; -const IN_281: usize = 17; -const OUT_281: usize = 12; -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 = 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_280] = { let __args: [G; IN_280] = [__v_10, __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_17: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__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_18: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_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(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__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_281] = [__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[281].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_281] = [__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[281].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_281] = [__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[281].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_282: usize = 14; -const IN_282: usize = 14; -const OUT_282: usize = 12; -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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_9, __v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_282] = [__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[282].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_283: usize = 14; -const IN_283: usize = 14; -const OUT_283: usize = 12; -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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_9, __v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __ret: [G; OUT_283] = [__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[283].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_284: usize = 1; -const IN_284: usize = 1; -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 __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_284] = [__v_37]; record.function_queries[284].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_36]; 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_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_284] = [__v_39]; record.function_queries[284].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_285: usize = 2; -const IN_285: usize = 2; -const OUT_285: usize = 34; -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; 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_285] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __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[285].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_285] = { let __args: [G; IN_285] = [__v_37, __v_39]; 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_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_285] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_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[285].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_286: usize = 33; -const IN_286: usize = 33; +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 = G::from_u64(0); let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__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(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_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_279] = { let __args: [G; IN_279] = [__v_0, __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_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_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_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_280] = [__v_28]; record.function_queries[280].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_280] = [__v_30]; record.function_queries[280].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_280] = [__v_27]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_281: usize = 1; +const IN_281: usize = 1; +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 __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_281] = [__v_11]; record.function_queries[281].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2]; 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_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_281] = [__v_13]; record.function_queries[281].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_10: G = G::from_u64(2); let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_3]; 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_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_281] = [__v_13]; record.function_queries[281].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_10: G = G::from_u64(3); let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_3]; 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_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_281] = [__v_13]; record.function_queries[281].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_281] = [__v_13]; record.function_queries[281].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.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; 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_282] = [__v_13]; record.function_queries[282].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_792] = { let __args: [G; IN_792] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_281] = { let __args: [G; IN_281] = [__v_13]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_11, __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_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_282] = [__v_17]; 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 = 5; +const IN_283: usize = 5; +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 __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_792] = { let __args: [G; IN_792] = [__v_4, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_281] = { let __args: [G; IN_281] = [__v_24]; 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_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_283] = [__v_28]; record.function_queries[283].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_283] = [__v_25]; record.function_queries[283].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_792] = { let __args: [G; IN_792] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_14, __v_4]; 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_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_283] = [__v_28]; record.function_queries[283].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_792] = { let __args: [G; IN_792] = [__v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_14, __v_4]; 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_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_283] = [__v_28]; record.function_queries[283].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_792] = { let __args: [G; IN_792] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_283] = { let __args: [G; IN_283] = [__v_22, __v_1, __v_2, __v_3, __v_4]; 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_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_283] = [__v_28]; record.function_queries[283].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_792] = { let __args: [G; IN_792] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_25]; 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_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_283] = [__v_29]; record.function_queries[283].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_792] = { let __args: [G; IN_792] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_25]; 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_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_283] = [__v_29]; record.function_queries[283].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_23: G = G::from_u64(3); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __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_283] = [__v_27]; record.function_queries[283].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_23: G = G::from_u64(4); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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 __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_283] = [__v_27]; record.function_queries[283].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __v_23: G = G::from_u64(5); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_11, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_12, __v_1, __v_2, __v_3, __v_4]; 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 __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_283] = [__v_27]; record.function_queries[283].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __v_23: G = G::from_u64(6); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_11, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_12, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13, __v_1, __v_2, __v_3, __v_4]; 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 __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_283] = [__v_27]; record.function_queries[283].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_801] = { let __args: [G; IN_801] = [__v_1, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_283] = { let __args: [G; IN_283] = [__v_26, __v_1, __v_2, __v_3, __v_4]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_283] = [__v_28]; record.function_queries[283].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_284: usize = 17; +const IN_284: usize = 17; +const OUT_284: usize = 12; +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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10, __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 __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__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 __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_284] = [__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[284].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_284] = [__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[284].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_284] = [__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[284].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_285: usize = 14; +const IN_285: usize = 14; +const OUT_285: usize = 12; +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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9, __v_10, __v_11, __v_12, __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_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_285] = [__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[285].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_286: usize = 14; +const IN_286: usize = 14; const OUT_286: usize = 12; -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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_25, __v_29, __v_30, __v_31, __v_32]; 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_33: G = __r_arr[0]; let __v_34: G = G::from_u64(5); let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_26]; 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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __ret: [G; OUT_286] = [__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[286].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_287: usize = 40; -const IN_287: usize = 40; -const OUT_287: usize = 12; -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]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_280] = { let __args: [G; IN_280] = [__v_33, __v_36, __v_37, __v_38, __v_39]; 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_40: G = __r_arr[0]; let __v_41: G = G::from_u64(6); let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); let __ret: [G; OUT_287] = [__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[287].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_288: usize = 6; -const IN_288: usize = 6; -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]; 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_288] = [__v_18]; record.function_queries[288].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_15, __v_1, __v_2, __v_3, __v_4]; 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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__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_288] = { let __args: [G; IN_288] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; 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 = { 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_288] = [__v_23]; record.function_queries[288].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } -const INPUT_SIZE_289: usize = 50; -const IN_289: usize = 50; +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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9, __v_10, __v_11, __v_12, __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_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_286] = [__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[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]; 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_287] = [__v_37]; record.function_queries[287].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_36]; 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_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_287] = [__v_39]; record.function_queries[287].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_288: usize = 2; +const IN_288: usize = 2; +const OUT_288: usize = 34; +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 __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_288] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __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[288].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_288] = { let __args: [G; IN_288] = [__v_37, __v_39]; 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_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_288] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_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[288].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_289: usize = 33; +const IN_289: usize = 33; const OUT_289: usize = 12; -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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_280] = { let __args: [G; IN_280] = [__v_42, __v_46, __v_47, __v_48, __v_49]; 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_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; 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_52: G = __r_arr[0]; let __v_53: G = G::from_u64(7); let __r_arr: [G; OUT_19] = { let __args: [G; IN_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(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __ret: [G; OUT_289] = [__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[289].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_290: usize = 1; -const IN_290: usize = 1; -const OUT_290: usize = 48; -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 __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_23] = { let __args: [G; IN_23] = [__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(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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_36]; 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_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_290] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_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[290].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_291: usize = 1; -const IN_291: 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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_283] = { let __args: [G; IN_283] = [__v_25, __v_29, __v_30, __v_31, __v_32]; 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_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_287] = { let __args: [G; IN_287] = [__v_26]; 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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __ret: [G; OUT_289] = [__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[289].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_290: usize = 40; +const IN_290: usize = 40; +const OUT_290: usize = 12; +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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_283] = { let __args: [G; IN_283] = [__v_33, __v_36, __v_37, __v_38, __v_39]; 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_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_290] = [__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[290].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_291: usize = 6; +const IN_291: usize = 6; 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 __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_291] = [__v_38]; record.function_queries[291].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }) } -const INPUT_SIZE_292: usize = 1; -const IN_292: usize = 1; -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 __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_23] = { let __args: [G; IN_23] = [__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(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 __ret: [G; OUT_292] = [__v_36]; record.function_queries[292].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_293: usize = 2; -const IN_293: usize = 2; -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]; match __v_0.as_canonical_u64() { 2u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_293] = [__v_2]; record.function_queries[293].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_293] = [__v_2]; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_293] = [__v_2]; record.function_queries[293].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_293] = [__v_2]; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_293] = [__v_2]; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_294: usize = 14; -const IN_294: usize = 14; +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 = 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_291] = [__v_18]; record.function_queries[291].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_15, __v_1, __v_2, __v_3, __v_4]; 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_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_291] = { let __args: [G; IN_291] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; 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_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_291] = [__v_23]; record.function_queries[291].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } +const INPUT_SIZE_292: usize = 50; +const IN_292: usize = 50; +const OUT_292: usize = 12; +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 = 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_283] = { let __args: [G; IN_283] = [__v_42, __v_46, __v_47, __v_48, __v_49]; 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_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; 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_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_292] = [__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[292].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_293: usize = 1; +const IN_293: usize = 1; +const OUT_293: usize = 48; +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 __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_124] = { let __args: [G; IN_124] = [__v_36]; 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_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_293] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_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[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_294: usize = 1; +const IN_294: usize = 1; 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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_293] = { let __args: [G; IN_293] = [__v_0, __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_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_294] = [__v_16]; record.function_queries[294].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_12, __v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_294] = [__v_15]; record.function_queries[294].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +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 __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_294] = [__v_38]; record.function_queries[294].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }) } const INPUT_SIZE_295: usize = 1; const IN_295: usize = 1; 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 __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_291] = { let __args: [G; IN_291] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[291].lookup((&__args[..])); match __hit { Some(__i) if true => { 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_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_293] = { let __args: [G; IN_293] = [__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_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_281] = { let __args: [G; IN_281] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; 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_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_295] = [__v_63]; record.function_queries[295].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_282] = { let __args: [G; IN_282] = [__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(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_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_295] = [__v_63]; record.function_queries[295].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_283] = { let __args: [G; IN_283] = [__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(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_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_295] = [__v_63]; record.function_queries[295].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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(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_49: G = __r_arr[0]; let __ret: [G; OUT_295] = [__v_49]; record.function_queries[295].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_19] = { let __args: [G; IN_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(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_10, __v_49]; 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_50: G = __r_arr[0]; let __ret: [G; OUT_295] = [__v_50]; record.function_queries[295].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_19] = { let __args: [G; IN_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(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_18, __v_49, __v_50]; 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_51: G = __r_arr[0]; let __ret: [G; OUT_295] = [__v_51]; record.function_queries[295].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 5u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_19] = { let __args: [G; IN_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(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_10, __v_49]; 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_50: G = __r_arr[0]; let __ret: [G; OUT_295] = [__v_50]; record.function_queries[295].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_289] = { let __args: [G; IN_289] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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(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_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_295] = [__v_65]; record.function_queries[295].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_296: usize = 10; -const IN_296: usize = 10; +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 __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_295] = [__v_36]; record.function_queries[295].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_296: usize = 2; +const IN_296: usize = 2; 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 __v_5: G = inp[5]; let __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_290] = { let __args: [G; IN_290] = [__v_9]; 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_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_791] = { let __args: [G; IN_791] = [__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(791, (&__args[..]))?) { [G::ZERO; OUT_791] } else { let (__hash, __hit) = record.function_queries[791].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[791].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { (*(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791])) }; __ret }, _ => { aiur_fn_791::(__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_291] = { let __args: [G; IN_291] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[291].lookup((&__args[..])); match __hit { Some(__i) if true => { 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_103: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__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(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_104: G = __r_arr[0]; let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__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(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_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_296] = [__v_117]; record.function_queries[296].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_297: usize = 2; -const IN_297: 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 __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 2u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_296] = [__v_2]; record.function_queries[296].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_296] = [__v_2]; record.function_queries[296].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_296] = [__v_2]; record.function_queries[296].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_296] = [__v_2]; record.function_queries[296].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_296] = [__v_2]; record.function_queries[296].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_297: usize = 14; +const IN_297: usize = 14; 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_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_300] = { let __args: [G; IN_300] = [__v_3, __v_1]; 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_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_303] = { let __args: [G; IN_303] = [__v_3, __v_0]; 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_95: G = __r_arr[0]; let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__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(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_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_297] = [__v_108]; record.function_queries[297].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_298: usize = 3; -const IN_298: usize = 3; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_296] = { let __args: [G; IN_296] = [__v_0, __v_1]; 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_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_297] = [__v_16]; record.function_queries[297].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__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_15: G = __r_arr[0]; let __ret: [G; OUT_297] = [__v_15]; record.function_queries[297].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_298: usize = 1; +const IN_298: usize = 1; 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 __v_2: G = inp[2]; let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_300] = { let __args: [G; IN_300] = [__v_4, __v_1]; 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_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_285] = { let __args: [G; IN_285] = [__v_78, __v_2]; 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_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_303] = { let __args: [G; IN_303] = [__v_4, __v_0]; 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_130: G = __r_arr[0]; let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__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(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_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_298] = [__v_143]; record.function_queries[298].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_299: usize = 2; -const IN_299: 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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_294] = { let __args: [G; IN_294] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[294].lookup((&__args[..])); match __hit { Some(__i) if true => { 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_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_296] = { let __args: [G; IN_296] = [__v_2, __v_3]; 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_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_284] = { let __args: [G; IN_284] = [__v_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(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_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_298] = [__v_63]; record.function_queries[298].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_285] = { let __args: [G; IN_285] = [__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(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_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_298] = [__v_63]; record.function_queries[298].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_286] = { let __args: [G; IN_286] = [__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(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_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_298] = [__v_63]; record.function_queries[298].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__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(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_49: G = __r_arr[0]; let __ret: [G; OUT_298] = [__v_49]; record.function_queries[298].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_300] = { let __args: [G; IN_300] = [__v_10, __v_49]; 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_50: G = __r_arr[0]; let __ret: [G; OUT_298] = [__v_50]; record.function_queries[298].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_301] = { let __args: [G; IN_301] = [__v_18, __v_49, __v_50]; 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_51: G = __r_arr[0]; let __ret: [G; OUT_298] = [__v_51]; record.function_queries[298].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_302] = { let __args: [G; IN_302] = [__v_10, __v_49]; 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_50: G = __r_arr[0]; let __ret: [G; OUT_298] = [__v_50]; record.function_queries[298].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_292] = { let __args: [G; IN_292] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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(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_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_298] = [__v_65]; record.function_queries[298].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_299: usize = 10; +const IN_299: usize = 10; 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 __v_1: G = inp[1]; let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_300] = { let __args: [G; IN_300] = [__v_3, __v_1]; 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_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_303] = { let __args: [G; IN_303] = [__v_3, __v_0]; 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_95: G = __r_arr[0]; let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__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(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_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_299] = [__v_108]; record.function_queries[299].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())); }, } }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __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_293] = { let __args: [G; IN_293] = [__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 __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_794] = { let __args: [G; IN_794] = [__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(794, (&__args[..]))?) { [G::ZERO; OUT_794] } else { let (__hash, __hit) = record.function_queries[794].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[794].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[794].bump_multiplicity(__i); } let __ret: [G; OUT_794] = unsafe { (*(record.function_queries[794].output_at(__i).as_ptr() as *const [G; OUT_794])) }; __ret }, _ => { aiur_fn_794::(__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_294] = { let __args: [G; IN_294] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[294].lookup((&__args[..])); match __hit { Some(__i) if true => { 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_103: G = __r_arr[0]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__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(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_104: G = __r_arr[0]; let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__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(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_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_299] = [__v_117]; record.function_queries[299].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_300: usize = 2; const IN_300: usize = 2; -const OUT_300: usize = 45; -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]; 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_300] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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[300].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_300] = { let __args: [G; IN_300] = [__v_48, __v_50]; 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_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_300] = [__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[300].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_301: usize = 1; -const IN_301: usize = 1; -const OUT_301: usize = 8; -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 __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_19] = { let __args: [G; IN_19] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__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_301] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[301].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_302: usize = 3; -const IN_302: usize = 3; +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]; let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_303] = { let __args: [G; IN_303] = [__v_3, __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_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_306] = { let __args: [G; IN_306] = [__v_3, __v_0]; 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_95: G = __r_arr[0]; let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__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(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_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_300] = [__v_108]; record.function_queries[300].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_301: usize = 3; +const IN_301: usize = 3; +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]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_303] = { let __args: [G; IN_303] = [__v_4, __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_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_288] = { let __args: [G; IN_288] = [__v_78, __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_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_306] = { let __args: [G; IN_306] = [__v_4, __v_0]; 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_130: G = __r_arr[0]; let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__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(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_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_301] = [__v_143]; record.function_queries[301].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_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 __v_2: G = inp[2]; let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_2]; 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_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_301] = { let __args: [G; IN_301] = [__v_2]; 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_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_78] = { let __args: [G; IN_78] = [__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(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_103: G = __r_arr[0]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_103]; 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_104: G = __r_arr[0]; let __ret: [G; OUT_302] = [__v_104]; record.function_queries[302].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_303] = { let __args: [G; IN_303] = [__v_3, __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_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_306] = { let __args: [G; IN_306] = [__v_3, __v_0]; 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_95: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; 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_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_302] = [__v_108]; record.function_queries[302].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_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 __v_2: G = G::from_u64(0); let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_0, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_303] = [__v_3]; record.function_queries[303].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_304: usize = 4; -const IN_304: usize = 4; -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 __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_304] = [__v_52]; record.function_queries[304].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __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_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_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_50, __v_54]; 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_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_304] = [__v_56]; record.function_queries[304].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_305: usize = 1; -const IN_305: usize = 1; +const OUT_303: usize = 45; +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; 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_303] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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[303].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_303] = { let __args: [G; IN_303] = [__v_48, __v_50]; 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_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_303] = [__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[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 = 1; +const IN_304: usize = 1; +const OUT_304: usize = 8; +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 __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_304] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[304].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_305: usize = 3; +const IN_305: usize = 3; 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 __loaded: [G; 3] = { let __base = 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_305] = [__v_4]; record.function_queries[305].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_305] = [__v_4]; record.function_queries[305].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_305] = [__v_4]; record.function_queries[305].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_2]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3]; 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_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_305] = [__v_6]; record.function_queries[305].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_305] = [__v_6]; record.function_queries[305].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_305] = [__v_6]; record.function_queries[305].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_305] = [__v_4]; record.function_queries[305].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_2]; 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_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_304] = { let __args: [G; IN_304] = [__v_2]; 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_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_79] = { let __args: [G; IN_79] = [__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(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_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_305] = [__v_104]; record.function_queries[305].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_306: usize = 2; const IN_306: usize = 2; 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 __loaded: [G; 3] = { let __base = 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_306] = [__v_8]; record.function_queries[306].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_306] = [__v_8]; record.function_queries[306].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_306] = { let __args: [G; IN_306] = [__v_3, __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_8: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_8]; record.function_queries[306].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_306] = [__v_8]; record.function_queries[306].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_306] = { let __args: [G; IN_306] = [__v_3, __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_8: G = __r_arr[0]; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __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_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); let __ret: [G; OUT_306] = [__v_10]; record.function_queries[306].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_306] = [__v_8]; record.function_queries[306].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_306] = { let __args: [G; IN_306] = [__v_3, __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_8: G = __r_arr[0]; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __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_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); let __ret: [G; OUT_306] = [__v_10]; record.function_queries[306].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_306] = [__v_8]; record.function_queries[306].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_306] = [__v_9]; record.function_queries[306].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_306] = [__v_8]; record.function_queries[306].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_307: usize = 2; -const IN_307: usize = 2; +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 = G::from_u64(0); let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_1, __v_0, __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_3: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_3]; record.function_queries[306].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_307: usize = 4; +const IN_307: usize = 4; 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 __loaded: [G; 3] = { let __base = 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_307] = [__v_8]; record.function_queries[307].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_307] = [__v_8]; record.function_queries[307].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_307] = [__v_8]; record.function_queries[307].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_307] = [__v_9]; record.function_queries[307].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_307] = [__v_10]; record.function_queries[307].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_10]; record.function_queries[307].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_308: usize = 2; -const IN_308: usize = 2; +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 __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_307] = [__v_52]; record.function_queries[307].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_3]; 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_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_307] = { let __args: [G; IN_307] = [__v_0, __v_1, __v_50, __v_54]; 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 = { 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_307] = [__v_56]; record.function_queries[307].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_308: usize = 1; +const IN_308: usize = 1; 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 __loaded: [G; 3] = { let __base = 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_308] = [__v_5]; record.function_queries[308].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_308] = [__v_8]; record.function_queries[308].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_308] = [__v_9]; record.function_queries[308].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_308] = { let __args: [G; IN_308] = [__v_0, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_308] = [__v_10]; record.function_queries[308].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_308] = [__v_10]; record.function_queries[308].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())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_308] = [__v_4]; record.function_queries[308].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_308] = [__v_4]; record.function_queries[308].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_308] = [__v_4]; record.function_queries[308].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__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_4: G = __r_arr[0]; let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3]; 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_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_308] = [__v_6]; record.function_queries[308].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_308] = [__v_6]; record.function_queries[308].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_308] = [__v_6]; record.function_queries[308].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_308] = [__v_4]; record.function_queries[308].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_309: usize = 2; const IN_309: usize = 2; const OUT_309: usize = 1; -fn aiur_fn_309(inp: [G; IN_309], 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 __loaded: [G; 3] = { let __base = 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_309] = [__v_8]; record.function_queries[309].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_309] = [__v_8]; record.function_queries[309].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_309] = [__v_8]; record.function_queries[309].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_309] = [__v_8]; record.function_queries[309].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_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 __loaded: [G; 3] = { let __base = 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_309] = [__v_8]; record.function_queries[309].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_309] = [__v_8]; record.function_queries[309].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_309] = { let __args: [G; IN_309] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_309] = [__v_8]; record.function_queries[309].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_309] = [__v_8]; record.function_queries[309].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_309] = { let __args: [G; IN_309] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); let __ret: [G; OUT_309] = [__v_10]; record.function_queries[309].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_309] = [__v_8]; record.function_queries[309].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_309] = { let __args: [G; IN_309] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); let __ret: [G; OUT_309] = [__v_10]; record.function_queries[309].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_309] = [__v_8]; record.function_queries[309].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_309] = [__v_9]; record.function_queries[309].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_309] = [__v_8]; record.function_queries[309].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_310: usize = 2; const IN_310: usize = 2; -const OUT_310: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_310] = [__v_5, __v_8]; record.function_queries[310].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_310] = [__v_6, __v_8]; record.function_queries[310].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_310] = [__v_7, __v_1]; record.function_queries[310].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __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 = __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_310] = [__v_7, __v_10]; record.function_queries[310].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_311: usize = 3; -const IN_311: 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 __loaded: [G; 3] = { let __base = 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_310] = [__v_8]; record.function_queries[310].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_310] = [__v_8]; record.function_queries[310].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_310] = [__v_8]; record.function_queries[310].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_310] = [__v_9]; record.function_queries[310].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_310] = [__v_10]; record.function_queries[310].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __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_10: G = __r_arr[0]; let __ret: [G; OUT_310] = [__v_10]; record.function_queries[310].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_311: usize = 2; +const IN_311: usize = 2; 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; 3] = { let __base = 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_311] = [__v_10]; record.function_queries[311].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_311] = [__v_11]; record.function_queries[311].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_311] = { let __args: [G; IN_311] = [__v_5, __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_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_311] = [__v_12]; record.function_queries[311].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_311] = [__v_13]; record.function_queries[311].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_311] = [__v_0]; record.function_queries[311].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())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_311] = [__v_5]; record.function_queries[311].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_311] = [__v_8]; record.function_queries[311].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_311] = [__v_9]; record.function_queries[311].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_311] = { let __args: [G; IN_311] = [__v_0, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_311] = [__v_10]; record.function_queries[311].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_4, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_311] = [__v_10]; record.function_queries[311].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_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 __loaded: [G; 3] = { let __base = 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_312] = [__v_8]; record.function_queries[312].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_312] = [__v_8]; record.function_queries[312].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_312] = [__v_8]; record.function_queries[312].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_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_14: G = __r_arr[0]; let __ret: [G; OUT_312] = [__v_14]; record.function_queries[312].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_312] = [__v_14]; record.function_queries[312].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_312] = [__v_13]; record.function_queries[312].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_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; 3] = { let __base = 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_313] = [__v_4]; record.function_queries[313].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_313] = { let __args: [G; IN_313] = [__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_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_313] = [__v_5]; record.function_queries[313].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_313] = [__v_6]; record.function_queries[313].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_314: usize = 2; -const IN_314: usize = 2; +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 __loaded: [G; 3] = { let __base = 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_312] = [__v_8]; record.function_queries[312].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_312] = [__v_8]; record.function_queries[312].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_312] = [__v_8]; record.function_queries[312].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_312] = [__v_8]; record.function_queries[312].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_313: usize = 2; +const IN_313: usize = 2; +const OUT_313: usize = 2; +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; 3] = { let __base = 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_313] = [__v_5, __v_8]; record.function_queries[313].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_313] = [__v_6, __v_8]; record.function_queries[313].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_313] = [__v_7, __v_1]; record.function_queries[313].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_4]; 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 __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_313] = [__v_7, __v_10]; record.function_queries[313].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_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 __loaded: [G; 3] = { let __base = 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_314] = [__v_0]; record.function_queries[314].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_314] = [__v_0]; record.function_queries[314].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_314] = { let __args: [G; IN_314] = [__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_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_314] = [__v_15]; record.function_queries[314].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_314] = { let __args: [G; IN_314] = [__v_0, __v_7]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_314] = [__v_14]; record.function_queries[314].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_314] = { let __args: [G; IN_314] = [__v_4, __v_7]; 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]; 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_314] = [__v_17]; 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_4, __v_7]; 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 __ret: [G; OUT_314] = [__v_15]; record.function_queries[314].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_315: usize = 3; -const IN_315: usize = 3; +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 __loaded: [G; 3] = { let __base = 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_314] = [__v_10]; record.function_queries[314].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_314] = [__v_11]; record.function_queries[314].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_314] = { let __args: [G; IN_314] = [__v_5, __v_1, __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_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_314] = [__v_12]; record.function_queries[314].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_314] = [__v_13]; record.function_queries[314].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_314] = [__v_0]; record.function_queries[314].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_315: usize = 2; +const IN_315: usize = 2; 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]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_315] = [__v_0]; record.function_queries[315].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_316] = { let __args: [G; IN_316] = [__v_0, __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_6: G = __r_arr[0]; let __ret: [G; OUT_315] = [__v_6]; record.function_queries[315].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_315] = [__v_0]; record.function_queries[315].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __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_3: G = __r_arr[0]; let __ret: [G; OUT_315] = [__v_3]; 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; +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 __loaded: [G; 3] = { let __base = 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_315] = [__v_8]; record.function_queries[315].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_315] = [__v_8]; record.function_queries[315].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_315] = [__v_8]; record.function_queries[315].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_315] = { let __args: [G; IN_315] = [__v_4, __v_7]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_315] = [__v_14]; record.function_queries[315].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_315] = [__v_14]; record.function_queries[315].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_315] = [__v_13]; record.function_queries[315].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_316: usize = 1; +const IN_316: usize = 1; 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 __loaded: [G; 3] = { let __base = 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_316] = [__v_10]; record.function_queries[316].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_307] = { let __args: [G; IN_307] = [__v_1, __v_6]; 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_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_316] = [__v_13]; record.function_queries[316].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_316] = [__v_0]; record.function_queries[316].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_316] = [__v_14]; record.function_queries[316].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(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_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_316] = [__v_12]; record.function_queries[316].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_317: usize = 4; -const IN_317: usize = 4; +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 __loaded: [G; 3] = { let __base = 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_316] = [__v_4]; record.function_queries[316].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_316] = { let __args: [G; IN_316] = [__v_3]; 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 __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_316] = [__v_5]; record.function_queries[316].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_316] = [__v_6]; record.function_queries[316].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_317: usize = 2; +const IN_317: usize = 2; 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 __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_317] = [__v_13]; record.function_queries[317].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_307] = { let __args: [G; IN_307] = [__v_1, __v_7]; 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_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_311] = { let __args: [G; IN_311] = [__v_9, __v_2, __v_3]; 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_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_317] = [__v_14]; record.function_queries[317].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_317] = [__v_17]; record.function_queries[317].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_1, __v_2, __v_3]; 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_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_317] = [__v_13]; record.function_queries[317].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_318: usize = 4; -const IN_318: usize = 4; +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 __loaded: [G; 3] = { let __base = 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_317] = [__v_0]; record.function_queries[317].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_317] = [__v_0]; record.function_queries[317].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_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; 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_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_317] = [__v_15]; record.function_queries[317].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_317] = { let __args: [G; IN_317] = [__v_0, __v_7]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_317] = [__v_14]; record.function_queries[317].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_317] = { let __args: [G; IN_317] = [__v_4, __v_7]; 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_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_317] = [__v_17]; 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_4, __v_7]; 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 __ret: [G; OUT_317] = [__v_15]; record.function_queries[317].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_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 __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_315] = { let __args: [G; IN_315] = [__v_3, __v_1, __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_7: G = __r_arr[0]; let __ret: [G; OUT_318] = [__v_7]; record.function_queries[318].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_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_8, __v_3]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_318] = [__v_9]; record.function_queries[318].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __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 __ret: [G; OUT_318] = [__v_8]; record.function_queries[318].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_6, __v_1, __v_2, __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_7: G = __r_arr[0]; let __ret: [G; OUT_318] = [__v_7]; record.function_queries[318].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1]; 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 = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3, __v_1, __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_9: G = __r_arr[0]; let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_9, __v_8, __v_5, __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_10: G = __r_arr[0]; let __ret: [G; OUT_318] = [__v_10]; record.function_queries[318].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_318] = [__v_3]; record.function_queries[318].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_3, __v_1, __v_5, __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_9: G = __r_arr[0]; let __ret: [G; OUT_318] = [__v_9]; record.function_queries[318].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_319: usize = 5; -const IN_319: usize = 5; +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]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_318] = [__v_0]; record.function_queries[318].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_319] = { let __args: [G; IN_319] = [__v_0, __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_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); }, 0u64 => { let __ret: [G; OUT_318] = [__v_0]; record.function_queries[318].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __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_3: G = __r_arr[0]; let __ret: [G; OUT_318] = [__v_3]; record.function_queries[318].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_319: usize = 3; +const IN_319: usize = 3; 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 __loaded: [G; 3] = { let __base = 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_315] = { let __args: [G; IN_315] = [__v_4, __v_2, __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_8: G = __r_arr[0]; let __ret: [G; OUT_319] = [__v_8]; record.function_queries[319].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_318] = { let __args: [G; IN_318] = [__v_0, __v_2, __v_3, __v_4]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_2, __v_9, __v_10]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_319] = [__v_11]; record.function_queries[319].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_6, __v_2, __v_3, __v_4]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_7, __v_2, __v_3, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_319] = [__v_9]; record.function_queries[319].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_6, __v_7, __v_2, __v_3, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_319] = [__v_9]; record.function_queries[319].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __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 = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_4, __v_2, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_10, __v_9, __v_6, __v_3]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0, __v_9, __v_3, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_319] = [__v_12]; record.function_queries[319].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_317] = { let __args: [G; IN_317] = [__v_4, __v_2, __v_6, __v_3]; 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_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0, __v_2, __v_3, __v_10]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_319] = [__v_11]; record.function_queries[319].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_320: usize = 2; -const IN_320: usize = 2; +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 __loaded: [G; 3] = { let __base = 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_319] = [__v_10]; record.function_queries[319].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_310] = { let __args: [G; IN_310] = [__v_1, __v_6]; 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]; 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_319] = [__v_13]; record.function_queries[319].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_319] = [__v_0]; record.function_queries[319].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_319] = [__v_14]; record.function_queries[319].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __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_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_319] = [__v_12]; record.function_queries[319].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_320: usize = 4; +const IN_320: usize = 4; 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 __loaded: [G; 3] = { let __base = 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_320] = [__v_0]; record.function_queries[320].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1]; 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 = { 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_320] = [__v_8]; record.function_queries[320].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_321: usize = 2; -const IN_321: usize = 2; +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 __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_320] = [__v_13]; record.function_queries[320].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_310] = { let __args: [G; IN_310] = [__v_1, __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_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_314] = { let __args: [G; IN_314] = [__v_9, __v_2, __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_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_320] = [__v_14]; record.function_queries[320].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_320] = [__v_17]; record.function_queries[320].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_1, __v_2, __v_3]; 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 = { 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_320] = [__v_13]; record.function_queries[320].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_321: usize = 4; +const IN_321: usize = 4; 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 __loaded: [G; 3] = { let __base = 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_321] = [__v_0]; record.function_queries[321].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_308] = { let __args: [G; IN_308] = [__v_8, __v_5]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_4]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_12]; record.function_queries[321].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_8]; 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_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_313] = { let __args: [G; IN_313] = [__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_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_314] = { let __args: [G; IN_314] = [__v_7, __v_10]; 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]; 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_321] = { let __args: [G; IN_321] = [__v_15, __v_4]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_16]; record.function_queries[321].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_322: usize = 1; -const IN_322: 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 __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_318] = { let __args: [G; IN_318] = [__v_3, __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_321] = [__v_7]; record.function_queries[321].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_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_8, __v_3]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_9]; record.function_queries[321].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_6, __v_1, __v_2, __v_7]; 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_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); }, 3u64 => { let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_5, __v_6, __v_1, __v_2, __v_3]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_7]; record.function_queries[321].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_3, __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_9: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_9, __v_8, __v_5, __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_10: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_10]; record.function_queries[321].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_321] = [__v_3]; record.function_queries[321].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_1, __v_5, __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 __ret: [G; OUT_321] = [__v_9]; record.function_queries[321].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_322: usize = 5; +const IN_322: usize = 5; 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(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_322] = [__v_0]; record.function_queries[322].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_322] = { let __args: [G; IN_322] = [__v_3]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_10]; record.function_queries[322].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_322] = [__v_0]; record.function_queries[322].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { let __ret: [G; OUT_322] = [__v_0]; record.function_queries[322].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __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_318] = { let __args: [G; IN_318] = [__v_4, __v_2, __v_3]; 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 __ret: [G; OUT_322] = [__v_8]; record.function_queries[322].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_321] = { let __args: [G; IN_321] = [__v_0, __v_2, __v_3, __v_4]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_6, __v_2, __v_9, __v_10]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_11]; record.function_queries[322].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_6, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_7, __v_2, __v_3, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_9]; record.function_queries[322].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_6, __v_7, __v_2, __v_3, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_9]; record.function_queries[322].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_6, __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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_4, __v_2, __v_3]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_10, __v_9, __v_6, __v_3]; 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_321] = { let __args: [G; IN_321] = [__v_0, __v_9, __v_3, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_12]; record.function_queries[322].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_320] = { let __args: [G; IN_320] = [__v_4, __v_2, __v_6, __v_3]; 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]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_2, __v_3, __v_10]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_11]; record.function_queries[322].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_323: usize = 2; const IN_323: usize = 2; 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 __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_2: G = __r_arr[0]; let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; 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_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_323] = [__v_10]; record.function_queries[323].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_323] = [__v_10]; record.function_queries[323].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_323] = [__v_10]; record.function_queries[323].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_307] = { let __args: [G; IN_307] = [__v_10, __v_13]; 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_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_312] = { let __args: [G; IN_312] = [__v_12, __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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_6, __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_19: G = __r_arr[0]; let __ret: [G; OUT_323] = [__v_19]; record.function_queries[323].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_323] = [__v_19]; record.function_queries[323].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_323] = [__v_18]; record.function_queries[323].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_323] = [__v_17]; record.function_queries[323].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_324: usize = 3; -const IN_324: usize = 3; +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 __loaded: [G; 3] = { let __base = 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_323] = [__v_0]; record.function_queries[323].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_1]; 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 __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_323] = [__v_8]; record.function_queries[323].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.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 __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_324] = [__v_6]; record.function_queries[324].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_308] = { let __args: [G; IN_308] = [__v_6, __v_1]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_1, __v_2]; 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 __ret: [G; OUT_324] = [__v_10]; record.function_queries[324].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_325] = { let __args: [G; IN_325] = [__v_8, __v_2]; 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_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_324] = [__v_12]; record.function_queries[324].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_1, __v_2]; 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 __ret: [G; OUT_324] = [__v_12]; record.function_queries[324].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_325: usize = 2; -const IN_325: usize = 2; +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; 3] = { let __base = 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_324] = [__v_0]; record.function_queries[324].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_311] = { let __args: [G; IN_311] = [__v_8, __v_5]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_4]; 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 __ret: [G; OUT_324] = [__v_12]; record.function_queries[324].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_8]; 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 __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_316] = { let __args: [G; IN_316] = [__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_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_317] = { let __args: [G; IN_317] = [__v_7, __v_10]; 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_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_324] = { let __args: [G; IN_324] = [__v_15, __v_4]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_324] = [__v_16]; 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 __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_325] = [__v_5]; record.function_queries[325].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_325] = [__v_10]; record.function_queries[325].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_1]; 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_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); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_326: usize = 4; -const IN_326: usize = 4; +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; 3] = { let __base = 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_325] = [__v_0]; record.function_queries[325].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_325] = { let __args: [G; IN_325] = [__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_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); }, 0u64 => { let __ret: [G; OUT_325] = [__v_0]; record.function_queries[325].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { let __ret: [G; OUT_325] = [__v_0]; 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]; 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_326] = [__v_7]; record.function_queries[326].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_308] = { let __args: [G; IN_308] = [__v_7, __v_1]; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_6, __v_1, __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_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); }, _ => { let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_9, __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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_326] = [__v_12]; record.function_queries[326].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_6, __v_1, __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_12: G = __r_arr[0]; let __ret: [G; OUT_326] = [__v_12]; record.function_queries[326].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())); }, } }) } +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 __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1]; 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_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_326] = [__v_10]; record.function_queries[326].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_326] = [__v_10]; record.function_queries[326].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_326] = [__v_10]; record.function_queries[326].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_310] = { let __args: [G; IN_310] = [__v_10, __v_13]; 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_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_315] = { let __args: [G; IN_315] = [__v_12, __v_15]; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_6, __v_9]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_326] = [__v_19]; record.function_queries[326].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_326] = [__v_19]; record.function_queries[326].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_326] = [__v_18]; record.function_queries[326].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_326] = [__v_17]; record.function_queries[326].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_327: usize = 3; const IN_327: usize = 3; 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 __loaded: [G; 3] = { let __base = 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_327] = [__v_6]; record.function_queries[327].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_327] = [__v_10]; record.function_queries[327].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_1, __v_2]; 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_10: G = __r_arr[0]; 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_9.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_327] = [__v_9]; record.function_queries[327].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_327] = [__v_6]; record.function_queries[327].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_311] = { let __args: [G; IN_311] = [__v_6, __v_1]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_1, __v_2]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_327] = [__v_10]; record.function_queries[327].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_328] = { let __args: [G; IN_328] = [__v_8, __v_2]; 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_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_327] = [__v_12]; record.function_queries[327].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_1, __v_2]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_327] = [__v_12]; record.function_queries[327].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_328: usize = 2; const IN_328: usize = 2; 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 __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_328] = [__v_5]; record.function_queries[328].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_324] = { let __args: [G; IN_324] = [__v_1, __v_5, __v_6]; 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_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_328] = [__v_9]; record.function_queries[328].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_7, __v_1, __v_5]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_328] = [__v_10]; record.function_queries[328].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __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_10: G = __r_arr[0]; let __ret: [G; OUT_328] = [__v_10]; record.function_queries[328].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_329: usize = 3; -const IN_329: usize = 3; +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 __loaded: [G; 3] = { let __base = 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_328] = [__v_5]; record.function_queries[328].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_328] = [__v_10]; record.function_queries[328].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __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_10: G = __r_arr[0]; let __ret: [G; OUT_328] = [__v_10]; record.function_queries[328].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_329: usize = 4; +const IN_329: usize = 4; 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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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_329] = [__v_6]; record.function_queries[329].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_326] = { let __args: [G; IN_326] = [__v_1, __v_2, __v_6, __v_7]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_329] = [__v_9]; record.function_queries[329].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __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_9: G = __r_arr[0]; 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_8.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_330: usize = 1; -const IN_330: 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 __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_329] = [__v_7]; record.function_queries[329].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_311] = { let __args: [G; IN_311] = [__v_7, __v_1]; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_1, __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_11: G = __r_arr[0]; let __ret: [G; OUT_329] = [__v_11]; record.function_queries[329].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_9, __v_2, __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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_329] = [__v_12]; record.function_queries[329].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_1, __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_12: G = __r_arr[0]; let __ret: [G; OUT_329] = [__v_12]; record.function_queries[329].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_330: usize = 3; +const IN_330: usize = 3; 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 = 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_318] = { let __args: [G; IN_318] = [__v_0, __v_3, __v_1, __v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_6]; 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 __ret: [G; OUT_330] = [__v_7]; record.function_queries[330].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __loaded: [G; 3] = { let __base = 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_330] = [__v_6]; record.function_queries[330].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_330] = [__v_10]; record.function_queries[330].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_5, __v_1, __v_2]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_330] = [__v_10]; record.function_queries[330].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_5, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_330] = [__v_9]; record.function_queries[330].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_331: usize = 2; const IN_331: usize = 2; 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); 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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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_331] = [__v_6]; record.function_queries[331].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__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_7: G = __r_arr[0]; let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_331] = [__v_8]; record.function_queries[331].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_332: usize = 2; -const IN_332: usize = 2; +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 __loaded: [G; 3] = { let __base = 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_331] = [__v_5]; 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_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_327] = { let __args: [G; IN_327] = [__v_1, __v_5, __v_6]; 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]; 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_331] = [__v_9]; record.function_queries[331].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_7, __v_1, __v_5]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_331] = [__v_10]; record.function_queries[331].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_331] = [__v_10]; record.function_queries[331].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_332: usize = 3; +const IN_332: usize = 3; const OUT_332: usize = 1; -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_306] = { let __args: [G; IN_306] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_332] = [__v_3]; record.function_queries[332].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__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_4: G = __r_arr[0]; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __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 __ret: [G; OUT_332] = [__v_5]; record.function_queries[332].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_333: usize = 2; -const IN_333: 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 __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_332] = [__v_6]; record.function_queries[332].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_329] = { let __args: [G; IN_329] = [__v_1, __v_2, __v_6, __v_7]; 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]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_332] = [__v_9]; record.function_queries[332].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_332] = [__v_9]; record.function_queries[332].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_333: usize = 1; +const IN_333: usize = 1; const OUT_333: usize = 1; -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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1]; 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_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_333] = [__v_1]; record.function_queries[333].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_333] = [__v_0]; record.function_queries[333].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_333] = [__v_6]; record.function_queries[333].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_333] = [__v_4]; record.function_queries[333].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 = 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_321] = { let __args: [G; IN_321] = [__v_0, __v_3, __v_1, __v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_6, __v_6]; 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_333] = [__v_7]; record.function_queries[333].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_334: usize = 2; const IN_334: usize = 2; const OUT_334: usize = 1; -fn aiur_fn_334(inp: [G; IN_334], 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 __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_334] = [__v_0]; record.function_queries[334].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_334] = [__v_1]; record.function_queries[334].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_334] = [__v_0]; record.function_queries[334].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_0]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_334] = [__v_1]; record.function_queries[334].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_334] = [__v_0]; record.function_queries[334].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_1]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_334] = [__v_11]; record.function_queries[334].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())); }, } }) } +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 __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_334] = [__v_3]; record.function_queries[334].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_334] = [__v_6]; record.function_queries[334].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0]; 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 __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_6, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_334] = [__v_8]; record.function_queries[334].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_335: usize = 2; const IN_335: usize = 2; const OUT_335: usize = 1; -fn aiur_fn_335(inp: [G; IN_335], 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 = (__v_0 - __v_1); match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_335] = [__v_3]; record.function_queries[335].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_335] = [__v_9]; record.function_queries[335].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_335] = [__v_9]; record.function_queries[335].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_335] = { let __args: [G; IN_335] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_335] = [__v_9]; record.function_queries[335].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_335] = [__v_9]; record.function_queries[335].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_335] = { let __args: [G; IN_335] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_8]; 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_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); let __ret: [G; OUT_335] = [__v_11]; record.function_queries[335].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_335] = [__v_9]; record.function_queries[335].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_335] = { let __args: [G; IN_335] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_8]; 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_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); let __ret: [G; OUT_335] = [__v_11]; record.function_queries[335].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_335] = [__v_9]; record.function_queries[335].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_335] = [__v_10]; record.function_queries[335].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_335] = [__v_10]; record.function_queries[335].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_335] = [__v_9]; record.function_queries[335].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } +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 __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_335] = [__v_3]; record.function_queries[335].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_4]; 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_335] = [__v_5]; record.function_queries[335].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_336: usize = 2; const IN_336: usize = 2; const OUT_336: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_335] = { let __args: [G; IN_335] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_336] = [__v_6]; record.function_queries[336].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; 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 __ret: [G; OUT_336] = [__v_6]; record.function_queries[336].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_336] = [__v_5]; record.function_queries[336].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__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_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_336] = [__v_1]; record.function_queries[336].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_336] = [__v_0]; record.function_queries[336].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_336] = [__v_6]; record.function_queries[336].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_1]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_336] = [__v_4]; record.function_queries[336].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_337: usize = 2; const IN_337: usize = 2; const OUT_337: usize = 1; -fn aiur_fn_337(inp: [G; IN_337], 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 = G::from_u64(0); let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_2]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_5]; 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_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_337] = [__v_1]; record.function_queries[337].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_337] = [__v_0]; record.function_queries[337].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_337] = [__v_9]; record.function_queries[337].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_338: usize = 1; -const IN_338: usize = 1; -const OUT_338: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_338] = [__v_4, __v_5]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; 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_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_338] = [__v_6, __v_7]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_338] = [__v_6, __v_6]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_338] = [__v_4, __v_4]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_337] = [__v_0]; record.function_queries[337].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_337] = [__v_1]; record.function_queries[337].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_337] = [__v_0]; record.function_queries[337].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_0]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_337] = [__v_1]; record.function_queries[337].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_0, __v_1]; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_337] = [__v_0]; record.function_queries[337].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0, __v_1]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_337] = [__v_11]; record.function_queries[337].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_338: usize = 2; +const IN_338: usize = 2; +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 = (__v_0 - __v_1); match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_338] = [__v_3]; record.function_queries[338].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_338] = [__v_9]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_338] = [__v_9]; record.function_queries[338].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_338] = { let __args: [G; IN_338] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_9]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_338] = [__v_9]; record.function_queries[338].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_338] = { let __args: [G; IN_338] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_8]; 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_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); let __ret: [G; OUT_338] = [__v_11]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_338] = [__v_9]; record.function_queries[338].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_338] = { let __args: [G; IN_338] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_8]; 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_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); let __ret: [G; OUT_338] = [__v_11]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_338] = [__v_9]; record.function_queries[338].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_338] = [__v_10]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_338] = [__v_10]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_338] = [__v_9]; record.function_queries[338].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_339: usize = 2; const IN_339: usize = 2; -const OUT_339: usize = 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 __loaded: [G; 3] = { let __base = 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_339] = { let __args: [G; IN_339] = [__v_3, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_339] = [__v_7, __v_8]; record.function_queries[339].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_339] = [__v_0, __v_1]; record.function_queries[339].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const OUT_339: usize = 1; +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 __loaded: [G; 3] = { let __base = 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_338] = { let __args: [G; IN_338] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_339] = [__v_6]; record.function_queries[339].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_339] = [__v_6]; record.function_queries[339].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_339] = [__v_5]; 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 = 1; -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; 3] = { let __base = 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_340] = [__v_6]; record.function_queries[340].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_340] = [__v_5]; record.function_queries[340].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; 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 __ret: [G; OUT_340] = [__v_6]; record.function_queries[340].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_340] = [__v_1]; record.function_queries[340].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_1]; 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]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_340] = [__v_0]; record.function_queries[340].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_340] = [__v_11]; record.function_queries[340].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())); }, } }, } }) } +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 __v_2: G = G::from_u64(0); let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_2]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3, __v_5]; 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_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_340] = [__v_1]; record.function_queries[340].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_340] = [__v_0]; record.function_queries[340].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_340] = [__v_9]; record.function_queries[340].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } const INPUT_SIZE_341: usize = 1; const IN_341: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_341] = [__v_5]; record.function_queries[341].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_341] = [__v_6]; record.function_queries[341].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; 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_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_341] = [__v_7]; record.function_queries[341].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__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 __ret: [G; OUT_341] = [__v_6]; record.function_queries[341].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_341] = [__v_6]; record.function_queries[341].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const OUT_341: usize = 2; +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 __loaded: [G; 3] = { let __base = 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_341] = [__v_4, __v_5]; record.function_queries[341].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; 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_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_341] = [__v_6, __v_7]; record.function_queries[341].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_341] = [__v_6, __v_6]; record.function_queries[341].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_341] = [__v_4, __v_4]; record.function_queries[341].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_342: usize = 2; const IN_342: usize = 2; -const OUT_342: usize = 1; -fn aiur_fn_342(inp: [G; IN_342], 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 __loaded: [G; 3] = { let __base = 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_342] = [__v_6]; record.function_queries[342].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_1]; 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_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_342] = [__v_8]; record.function_queries[342].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_342] = [__v_7]; record.function_queries[342].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_342] = [__v_7]; record.function_queries[342].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_342] = [__v_5]; record.function_queries[342].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_342] = { let __args: [G; IN_342] = [__v_3, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_342] = [__v_7, __v_8]; record.function_queries[342].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_342] = [__v_0, __v_1]; record.function_queries[342].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_343: usize = 2; const IN_343: usize = 2; 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 __loaded: [G; 3] = { let __base = 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_343] = [__v_6]; record.function_queries[343].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1]; 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_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_343] = [__v_8]; record.function_queries[343].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_344: usize = 2; -const IN_344: usize = 2; +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 __loaded: [G; 3] = { let __base = 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_343] = [__v_6]; record.function_queries[343].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_5]; record.function_queries[343].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_1]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_6]; record.function_queries[343].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_343] = [__v_1]; record.function_queries[343].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_1]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_343] = [__v_0]; record.function_queries[343].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_343] = [__v_11]; record.function_queries[343].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_344: usize = 1; +const IN_344: usize = 1; 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 __loaded: [G; 3] = { let __base = 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_344] = [__v_0]; record.function_queries[344].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_1]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_5]; record.function_queries[344].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_344] = [__v_5]; record.function_queries[344].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_344] = [__v_6]; record.function_queries[344].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_2]; 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_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_344] = [__v_7]; record.function_queries[344].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_2]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_6]; record.function_queries[344].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_2]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_6]; record.function_queries[344].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_345: usize = 2; const IN_345: usize = 2; 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 __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_345] = [__v_7]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_1]; 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_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_345] = [__v_9]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1]; 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_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_345] = [__v_9]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_1]; 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_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_345] = [__v_10]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_1]; 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_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_345] = [__v_10]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_1]; 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_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_345] = [__v_10]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_1]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_5, __v_1]; 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_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_345] = [__v_10]; record.function_queries[345].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_345] = [__v_8]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_5, __v_1]; 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_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_345] = [__v_8]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_345] = [__v_6]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_1]; 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_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_345] = [__v_8]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_345] = [__v_7]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_345] = [__v_7]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_345] = [__v_5]; record.function_queries[345].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_346: usize = 2; const IN_346: usize = 2; const OUT_346: usize = 1; -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 __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_346] = [__v_22]; record.function_queries[346].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_346] = [__v_22]; record.function_queries[346].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_346] = [__v_22]; record.function_queries[346].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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(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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_11, __v_21]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_23]; record.function_queries[346].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_346] = [__v_23]; record.function_queries[346].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())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_346] = [__v_6]; record.function_queries[346].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_1]; 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_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_346] = [__v_8]; record.function_queries[346].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_347: usize = 2; const IN_347: usize = 2; const OUT_347: usize = 1; -fn aiur_fn_347(inp: [G; IN_347], 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 __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_347] = [__v_8]; record.function_queries[347].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_347] = [__v_8]; record.function_queries[347].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_347] = [__v_8]; record.function_queries[347].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_347] = { let __args: [G; IN_347] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_347] = [__v_9]; record.function_queries[347].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_347] = [__v_9]; record.function_queries[347].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_348: usize = 4; -const IN_348: 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 __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_347] = [__v_0]; record.function_queries[347].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0, __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_5: G = __r_arr[0]; let __ret: [G; OUT_347] = [__v_5]; 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 = 1; -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 __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_346] = { let __args: [G; IN_346] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_348] = [__v_4]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_348] = [__v_4]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_348] = [__v_4]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_348] = [__v_4]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_349: usize = 1; -const IN_349: usize = 1; +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; 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_348] = [__v_7]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_1]; 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_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_348] = [__v_9]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_1]; 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_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_348] = [__v_9]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_1]; 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_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_348] = [__v_10]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_1]; 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_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_348] = [__v_10]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_1]; 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_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_348] = [__v_10]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_1]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_5, __v_1]; 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_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_348] = [__v_10]; record.function_queries[348].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_348] = [__v_8]; record.function_queries[348].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_5, __v_1]; 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_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_348] = [__v_8]; 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 = 2; +const IN_349: usize = 2; const OUT_349: usize = 1; -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 __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_349] = [__v_6]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_349] = [__v_5]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_349] = [__v_5]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_349] = [__v_5]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_7]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_8]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_8]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_2, __v_3, __v_4]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_5]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_5]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_350: usize = 3; -const IN_350: usize = 3; +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 __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_349] = [__v_22]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_349] = [__v_22]; record.function_queries[349].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_349] = [__v_22]; record.function_queries[349].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_349] = { let __args: [G; IN_349] = [__v_11, __v_21]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_23]; record.function_queries[349].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_349] = [__v_23]; record.function_queries[349].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_350: usize = 2; +const IN_350: usize = 2; const OUT_350: usize = 1; -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]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_1]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_3, __v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_2]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_350] = [__v_8]; record.function_queries[350].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_351: usize = 2; -const IN_351: 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]; let __loaded: [G; 3] = { let __base = 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_350] = [__v_8]; record.function_queries[350].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_350] = [__v_8]; record.function_queries[350].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_350] = [__v_8]; record.function_queries[350].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_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_9: G = __r_arr[0]; let __ret: [G; OUT_350] = [__v_9]; record.function_queries[350].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_350] = [__v_9]; record.function_queries[350].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_351: usize = 4; +const IN_351: usize = 4; 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 = { 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_351] = [__v_1]; record.function_queries[351].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_351] = [__v_0]; record.function_queries[351].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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]; match __v_0.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_351] = [__v_4]; record.function_queries[351].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_351] = [__v_4]; record.function_queries[351].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_351] = [__v_4]; record.function_queries[351].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_351] = [__v_4]; record.function_queries[351].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } 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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_352] = [__v_1]; record.function_queries[352].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_352] = [__v_2]; 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; +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 __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_352] = [__v_6]; record.function_queries[352].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_352] = [__v_5]; record.function_queries[352].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_352] = [__v_5]; record.function_queries[352].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_352] = [__v_5]; record.function_queries[352].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_5, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_7]; record.function_queries[352].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_8]; record.function_queries[352].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_8]; record.function_queries[352].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_2, __v_3, __v_4]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_5]; record.function_queries[352].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_4]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_5]; record.function_queries[352].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_353: usize = 3; +const IN_353: usize = 3; 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 __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_353] = [__v_0]; record.function_queries[353].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_353] = [__v_1]; record.function_queries[353].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_354: usize = 3; -const IN_354: usize = 3; +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 __v_2: G = inp[2]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_1]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_2]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_353] = [__v_8]; record.function_queries[353].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_354: usize = 2; +const IN_354: usize = 2; 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 __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 }; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_354] = [__v_8]; record.function_queries[354].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_354] = [__v_8]; record.function_queries[354].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, 1u64 => { 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); }, 2u64 => { 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); }, 7u64 => { 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); }, 3u64 => { let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_1, __v_2]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_354] = [__v_8]; record.function_queries[354].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_5, __v_1, __v_2]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_354] = [__v_8]; record.function_queries[354].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_355] = { let __args: [G; IN_355] = [__v_4, __v_5, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_354] = [__v_7]; record.function_queries[354].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_5, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_354] = [__v_7]; record.function_queries[354].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_354] = [__v_7]; record.function_queries[354].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_6, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_354] = [__v_7]; record.function_queries[354].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_355: usize = 4; -const IN_355: usize = 4; +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 = { 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_354] = [__v_1]; record.function_queries[354].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_354] = [__v_0]; record.function_queries[354].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_355: usize = 1; +const IN_355: usize = 1; 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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_2, __v_3]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_355] = [__v_5]; record.function_queries[355].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_354] = { let __args: [G; IN_354] = [__v_1, __v_6, __v_7]; 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_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); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_356: usize = 5; -const IN_356: usize = 5; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_355] = [__v_1]; record.function_queries[355].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_355] = [__v_2]; 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3, __v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_356] = [__v_6]; record.function_queries[356].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_3, __v_4]; 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_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); }, 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_354] = { let __args: [G; IN_354] = [__v_2, __v_8, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_356] = [__v_10]; record.function_queries[356].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_357: usize = 2; -const IN_357: usize = 2; +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 __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_356] = [__v_0]; record.function_queries[356].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_356] = [__v_1]; record.function_queries[356].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_357: usize = 3; +const IN_357: usize = 3; 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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2]; let __cu = unconstrained; if ((!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_3: G = __r_arr[0]; let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_357] = [__v_4]; 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; +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 __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 }; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_357] = [__v_8]; record.function_queries[357].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_357] = [__v_8]; record.function_queries[357].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_357] = [__v_7]; record.function_queries[357].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_357] = [__v_7]; record.function_queries[357].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_357] = [__v_7]; 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_4, __v_1, __v_2]; 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); }, 0u64 => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_5, __v_1, __v_2]; 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); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, 4u64 => { let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_5, __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_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_358] = { let __args: [G; IN_358] = [__v_4, __v_5, __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_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_359] = { let __args: [G; IN_359] = [__v_4, __v_5, __v_6, __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_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); }, 8u64 => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_6, __v_1, __v_2]; 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); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_358: usize = 4; +const IN_358: usize = 4; 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 __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0]; 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_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_358] = [__v_2]; record.function_queries[358].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_358] = { let __args: [G; IN_358] = [__v_4, __v_5]; 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 __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_358] = [__v_7]; record.function_queries[358].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_359: usize = 1; -const IN_359: 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_0, __v_2, __v_3]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_358] = [__v_5]; record.function_queries[358].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_357] = { let __args: [G; IN_357] = [__v_1, __v_6, __v_7]; 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_358] = [__v_8]; record.function_queries[358].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_359: usize = 5; +const IN_359: usize = 5; 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 __loaded: [G; 3] = { let __base = 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_349] = { let __args: [G; IN_349] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(360, (&__args[..]))?) { [G::ZERO; OUT_360] } else { let (__hash, __hit) = record.function_queries[360].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[360].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[360].bump_multiplicity(__i); } let __ret: [G; OUT_360] = unsafe { (*(record.function_queries[360].output_at(__i).as_ptr() as *const [G; OUT_360])) }; __ret }, _ => { aiur_fn_360::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_4 + __v_6); let __ret: [G; OUT_359] = [__v_7]; record.function_queries[359].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_0, __v_3, __v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_359] = [__v_6]; record.function_queries[359].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_1, __v_3, __v_4]; 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_359] = [__v_7]; record.function_queries[359].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_357] = { let __args: [G; IN_357] = [__v_2, __v_8, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_359] = [__v_10]; record.function_queries[359].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_360: usize = 2; const IN_360: usize = 2; 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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_360] = [__v_2]; record.function_queries[360].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0]; 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_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_360] = [__v_2]; record.function_queries[360].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_360] = { let __args: [G; IN_360] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(360, (&__args[..]))?) { [G::ZERO; OUT_360] } else { let (__hash, __hit) = record.function_queries[360].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[360].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[360].bump_multiplicity(__i); } let __ret: [G; OUT_360] = unsafe { (*(record.function_queries[360].output_at(__i).as_ptr() as *const [G; OUT_360])) }; __ret }, _ => { aiur_fn_360::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_360] = [__v_7]; record.function_queries[360].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_1, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __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 __ret: [G; OUT_360] = [__v_4]; record.function_queries[360].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_361: usize = 2; const IN_361: usize = 2; 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]; 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_361] = [__v_3]; record.function_queries[361].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_361] = [__v_0]; record.function_queries[361].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_5]; 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 __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_361] = [__v_7]; record.function_queries[361].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_362: usize = 2; -const IN_362: usize = 2; +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 __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0]; 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_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_361] = [__v_2]; record.function_queries[361].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_361] = { let __args: [G; IN_361] = [__v_4, __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_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_361] = [__v_7]; record.function_queries[361].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_362: usize = 1; +const IN_362: usize = 1; 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 __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_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_362] = [__v_6]; record.function_queries[362].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __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_6: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_6]; record.function_queries[362].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_352] = { let __args: [G; IN_352] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = (__v_4 + __v_6); let __ret: [G; OUT_362] = [__v_7]; record.function_queries[362].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_363: usize = 2; const IN_363: usize = 2; 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 __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_363] = [__v_7]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_7: G = (__v_3 - __v_1); let __ret: [G; OUT_363] = [__v_7]; record.function_queries[363].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_363] = [__v_6]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_363] = [__v_6]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_363] = [__v_6]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_363] = [__v_7]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_6, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_8]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_3, __v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_6]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_3, __v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_6]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_4, __v_5, __v_1]; 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 __ret: [G; OUT_363] = [__v_6]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_6]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_364: usize = 3; -const IN_364: usize = 3; +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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_363] = [__v_2]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0]; 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_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_363] = [__v_2]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_363] = { let __args: [G; IN_363] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_363] = [__v_7]; record.function_queries[363].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_364: usize = 2; +const IN_364: usize = 2; 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 __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_364] = [__v_4]; record.function_queries[364].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_362] = { let __args: [G; IN_362] = [__v_1, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_364] = [__v_7]; record.function_queries[364].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_365: usize = 4; -const IN_365: usize = 4; +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]; 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_364] = [__v_3]; record.function_queries[364].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_364] = [__v_0]; record.function_queries[364].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_1, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_364] = [__v_7]; record.function_queries[364].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_365: usize = 2; +const IN_365: usize = 2; 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 __v_3: G = inp[3]; let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_365] = [__v_5]; record.function_queries[365].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_1, __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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_365] = [__v_6]; record.function_queries[365].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_4, __v_5]; 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_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_362] = { let __args: [G; IN_362] = [__v_2, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_6, __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_10: G = __r_arr[0]; let __ret: [G; OUT_365] = [__v_10]; 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; +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 __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_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_365] = [__v_6]; record.function_queries[365].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_365] = [__v_6]; record.function_queries[365].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_366: usize = 2; +const IN_366: usize = 2; 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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_366] = [__v_0]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_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_366] = [__v_0]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_1, __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); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } +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 __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_366] = [__v_7]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_7: G = (__v_3 - __v_1); let __ret: [G; OUT_366] = [__v_7]; record.function_queries[366].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_366] = [__v_6]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_366] = [__v_6]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_366] = [__v_6]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_1]; 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]; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_366] = [__v_7]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_4, __v_1]; 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_356] = { let __args: [G; IN_356] = [__v_6, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_366] = [__v_8]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_3, __v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_366] = [__v_6]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_3, __v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_366] = [__v_6]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_3, __v_4, __v_5, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_366] = [__v_6]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_5, __v_1]; 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 __ret: [G; OUT_366] = [__v_6]; record.function_queries[366].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_367: usize = 3; const IN_367: usize = 3; 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 __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_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_367] = [__v_7]; record.function_queries[367].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_367] = [__v_9]; record.function_queries[367].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_367] = [__v_9]; record.function_queries[367].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_367] = [__v_11]; record.function_queries[367].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_366] = { let __args: [G; IN_366] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_367] = [__v_13]; record.function_queries[367].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_366] = { let __args: [G; IN_366] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_367] = [__v_13]; record.function_queries[367].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_367] = [__v_7]; record.function_queries[367].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_367] = [__v_9]; record.function_queries[367].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_367] = [__v_9]; record.function_queries[367].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_368: usize = 3; -const IN_368: usize = 3; +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 __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_367] = [__v_4]; record.function_queries[367].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_365] = { let __args: [G; IN_365] = [__v_1, __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_356] = { let __args: [G; IN_356] = [__v_3, __v_6]; 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_367] = [__v_7]; 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 = { 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_368] = [__v_5]; record.function_queries[368].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_368] = [__v_6]; record.function_queries[368].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_369: usize = 5; -const IN_369: usize = 5; +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 __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_3]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_368] = [__v_5]; record.function_queries[368].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_1, __v_3]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_368] = [__v_6]; record.function_queries[368].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_4, __v_5]; 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_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_365] = { let __args: [G; IN_365] = [__v_2, __v_8]; 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_356] = { let __args: [G; IN_356] = [__v_6, __v_9]; 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_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); }, } }, } }) } +const INPUT_SIZE_369: usize = 3; +const IN_369: usize = 3; 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 = G::from_u64(6); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_366] = { let __args: [G; IN_366] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_369] = [__v_11]; record.function_queries[369].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_369] = [__v_0]; record.function_queries[369].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_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_369] = [__v_0]; record.function_queries[369].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_369] = [__v_5]; record.function_queries[369].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_370: usize = 3; const IN_370: usize = 3; 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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_370] = [__v_0]; 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]; 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_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_370] = [__v_0]; record.function_queries[370].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_5]; record.function_queries[370].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } +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 __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_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; 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_370] = [__v_7]; record.function_queries[370].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_370] = [__v_9]; record.function_queries[370].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_370] = [__v_9]; record.function_queries[370].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_5, __v_1, __v_2]; 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_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_370] = [__v_11]; record.function_queries[370].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; 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 __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_5, __v_1, __v_10]; 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_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_370] = [__v_13]; record.function_queries[370].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; 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 __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_5, __v_1, __v_10]; 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_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_370] = [__v_13]; record.function_queries[370].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_7]; record.function_queries[370].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_370] = [__v_9]; record.function_queries[370].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_6, __v_1, __v_2]; 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 __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_370] = [__v_9]; record.function_queries[370].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_371: usize = 3; const IN_371: usize = 3; 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 __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_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_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_371] = [__v_0]; record.function_queries[371].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = (__v_4 - __v_1); let __v_10: G = { let __values: [G; 4] = [__v_8, __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 __ret: [G; OUT_371] = [__v_10]; record.function_queries[371].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_371] = [__v_9]; record.function_queries[371].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_371] = [__v_9]; record.function_queries[371].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_5, __v_1, __v_2]; 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_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_371] = [__v_11]; record.function_queries[371].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_4, __v_1, __v_2]; 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 __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_5, __v_1, __v_10]; 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_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_371] = [__v_13]; record.function_queries[371].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_4, __v_1, __v_2]; 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 __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_5, __v_1, __v_10]; 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_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_371] = [__v_13]; record.function_queries[371].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(6); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_5, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_6, __v_1, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_371] = [__v_13]; record.function_queries[371].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_371] = [__v_9]; record.function_queries[371].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_6, __v_1, __v_2]; 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 __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_371] = [__v_9]; record.function_queries[371].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_372: usize = 2; -const IN_372: usize = 2; +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 __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_371] = [__v_5]; record.function_queries[371].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_371] = [__v_6]; record.function_queries[371].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_372: usize = 5; +const IN_372: usize = 5; 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 __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_372] = [__v_7]; record.function_queries[372].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_372] = [__v_7]; record.function_queries[372].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_372] = [__v_7]; record.function_queries[372].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_372] = [__v_7]; record.function_queries[372].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_3, __v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_372] = [__v_6]; record.function_queries[372].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_3, __v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_372] = [__v_6]; record.function_queries[372].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_3, __v_4, __v_5, __v_1]; 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 __ret: [G; OUT_372] = [__v_6]; record.function_queries[372].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_372] = [__v_6]; record.function_queries[372].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_372] = [__v_6]; record.function_queries[372].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 = G::from_u64(6); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_3, __v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_1, __v_3, __v_4]; 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_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_369] = { let __args: [G; IN_369] = [__v_2, __v_3, __v_9]; 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_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_372] = [__v_11]; record.function_queries[372].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_373: usize = 3; const IN_373: usize = 3; 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 __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_373] = [__v_4]; record.function_queries[373].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_372] = { let __args: [G; IN_372] = [__v_1, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_373] = [__v_6]; record.function_queries[373].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_374: usize = 4; -const IN_374: usize = 4; +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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_373] = [__v_0]; record.function_queries[373].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_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_373] = [__v_0]; record.function_queries[373].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { 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_5: G = __r_arr[0]; let __ret: [G; OUT_373] = [__v_5]; record.function_queries[373].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.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 __v_3: G = inp[3]; let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_3]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_374] = [__v_5]; record.function_queries[374].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_3]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_374] = [__v_6]; record.function_queries[374].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_372] = { let __args: [G; IN_372] = [__v_2, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_8]; record.function_queries[374].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_375: usize = 3; -const IN_375: usize = 3; +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 __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_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_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_374] = [__v_0]; record.function_queries[374].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = (__v_4 - __v_1); let __v_10: G = { let __values: [G; 4] = [__v_8, __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 __ret: [G; OUT_374] = [__v_10]; record.function_queries[374].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __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_9]; record.function_queries[374].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_374] = [__v_9]; record.function_queries[374].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_5, __v_1, __v_2]; 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_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_374] = [__v_11]; record.function_queries[374].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_4, __v_1, __v_2]; 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_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_373] = { let __args: [G; IN_373] = [__v_5, __v_1, __v_10]; 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_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_374] = [__v_13]; record.function_queries[374].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_4, __v_1, __v_2]; 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_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_373] = { let __args: [G; IN_373] = [__v_5, __v_1, __v_10]; 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_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_374] = [__v_13]; record.function_queries[374].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(6); let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_5, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_6, __v_1, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __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); }, 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_374] = [__v_9]; record.function_queries[374].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_6, __v_1, __v_2]; 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_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_374] = [__v_9]; record.function_queries[374].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_375: usize = 2; +const IN_375: usize = 2; 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 __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_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_375] = [__v_0]; record.function_queries[375].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_2]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0, __v_1, __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_6: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_6]; record.function_queries[375].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_370] = { let __args: [G; IN_370] = [__v_0, __v_6, __v_7]; 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_375] = [__v_8]; record.function_queries[375].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +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 __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_375] = [__v_7]; record.function_queries[375].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_375] = [__v_7]; record.function_queries[375].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_375] = [__v_7]; record.function_queries[375].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_7]; record.function_queries[375].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_3, __v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_6]; 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_3, __v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_6]; record.function_queries[375].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_3, __v_4, __v_5, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_6]; record.function_queries[375].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_6]; record.function_queries[375].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_375] = [__v_6]; record.function_queries[375].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } 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 __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_377] = { let __args: [G; IN_377] = [__v_4, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_376] = [__v_7]; record.function_queries[376].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_376] = [__v_9]; record.function_queries[376].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_376] = [__v_9]; record.function_queries[376].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_376] = [__v_11]; record.function_queries[376].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_375] = { let __args: [G; IN_375] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_376] = [__v_13]; record.function_queries[376].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_375] = { let __args: [G; IN_375] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_376] = [__v_13]; record.function_queries[376].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_376] = [__v_7]; record.function_queries[376].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_376] = [__v_9]; record.function_queries[376].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_376] = [__v_9]; record.function_queries[376].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_377: usize = 3; -const IN_377: usize = 3; +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_375] = { let __args: [G; IN_375] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_376] = [__v_4]; record.function_queries[376].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_375] = { let __args: [G; IN_375] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_376] = [__v_6]; record.function_queries[376].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_377: usize = 4; +const IN_377: usize = 4; 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]; 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_377] = [__v_5]; record.function_queries[377].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_366] = { let __args: [G; IN_366] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_377] = [__v_6]; record.function_queries[377].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_377] = [__v_8]; record.function_queries[377].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_378: usize = 5; -const IN_378: usize = 5; +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]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_377] = [__v_5]; record.function_queries[377].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_377] = [__v_6]; record.function_queries[377].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_375] = { let __args: [G; IN_375] = [__v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_377] = [__v_8]; record.function_queries[377].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_378: usize = 3; +const IN_378: usize = 3; 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 __v_5: G = G::from_u64(6); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_375] = { let __args: [G; IN_375] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_378] = [__v_11]; record.function_queries[378].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_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_378] = [__v_0]; record.function_queries[378].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_0, __v_1, __v_2]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_378] = [__v_6]; record.function_queries[378].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_373] = { let __args: [G; IN_373] = [__v_0, __v_6, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_378] = [__v_8]; record.function_queries[378].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } const INPUT_SIZE_379: usize = 3; const IN_379: usize = 3; 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 __v_2: G = inp[2]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_379] = [__v_0]; record.function_queries[379].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_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_379] = [__v_0]; record.function_queries[379].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = (__v_2 + __v_3); let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_2, __v_6]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_0, __v_1, __v_2]; 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_379] = [__v_8]; record.function_queries[379].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = (__v_2 + __v_3); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_3, __v_8]; 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_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())); }, } }, } }) } +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 __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_380] = { let __args: [G; IN_380] = [__v_4, __v_1, __v_2]; 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_379] = [__v_7]; record.function_queries[379].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_379] = [__v_9]; record.function_queries[379].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_379] = [__v_9]; record.function_queries[379].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __v_1, __v_2]; 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_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_379] = [__v_11]; record.function_queries[379].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_4, __v_1, __v_2]; 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_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_378] = { let __args: [G; IN_378] = [__v_5, __v_1, __v_10]; 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_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_379] = [__v_13]; record.function_queries[379].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_4, __v_1, __v_2]; 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_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_378] = { let __args: [G; IN_378] = [__v_5, __v_1, __v_10]; 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_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_379] = [__v_13]; record.function_queries[379].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_379] = [__v_7]; record.function_queries[379].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_379] = [__v_9]; record.function_queries[379].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_6, __v_1, __v_2]; 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_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_379] = [__v_9]; record.function_queries[379].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_380: usize = 3; const IN_380: usize = 3; 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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_789] = { let __args: [G; IN_789] = [__v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_366] = { let __args: [G; IN_366] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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); }, 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_380] = [__v_8]; record.function_queries[380].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_381: usize = 3; -const IN_381: usize = 3; +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 __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_380] = [__v_5]; record.function_queries[380].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_369] = { let __args: [G; IN_369] = [__v_1, __v_2, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_380] = [__v_6]; record.function_queries[380].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_380] = [__v_8]; record.function_queries[380].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +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 __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_380] = { let __args: [G; IN_380] = [__v_4, __v_1, __v_2]; 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_381] = [__v_7]; record.function_queries[381].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_381] = [__v_9]; record.function_queries[381].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_381] = [__v_9]; record.function_queries[381].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_5, __v_1, __v_2]; 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 __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_381] = [__v_11]; record.function_queries[381].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_1, __v_2]; 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_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_379] = { let __args: [G; IN_379] = [__v_5, __v_1, __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_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_381] = [__v_13]; record.function_queries[381].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_1, __v_2]; 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_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_379] = { let __args: [G; IN_379] = [__v_5, __v_1, __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_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_381] = [__v_13]; record.function_queries[381].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_381] = [__v_7]; record.function_queries[381].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_381] = [__v_9]; record.function_queries[381].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_6, __v_1, __v_2]; 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_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_381] = [__v_9]; record.function_queries[381].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_382: usize = 5; -const IN_382: usize = 5; +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(6); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_1, __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_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_378] = { let __args: [G; IN_378] = [__v_2, __v_3, __v_9]; 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_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_381] = [__v_11]; record.function_queries[381].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_382: usize = 3; +const IN_382: usize = 3; 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 = inp[4]; let __v_5: G = G::from_u64(6); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_0, __v_3, __v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_1, __v_3, __v_4]; 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_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_379] = { let __args: [G; IN_379] = [__v_2, __v_3, __v_9]; 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_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_382] = [__v_11]; record.function_queries[382].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_382] = [__v_0]; record.function_queries[382].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_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_382] = [__v_0]; record.function_queries[382].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = (__v_2 + __v_3); let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_0, __v_2, __v_6]; 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 __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1, __v_2]; 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]; let __ret: [G; OUT_382] = [__v_8]; record.function_queries[382].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = (__v_2 + __v_3); let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_3, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_382] = [__v_9]; record.function_queries[382].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_383: usize = 3; const IN_383: usize = 3; -const OUT_383: usize = 3; -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 __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_383] = { let __args: [G; IN_383] = [__v_5, __v_9, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __ret: [G; OUT_383] = [__v_12, __v_13, __v_14]; record.function_queries[383].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_383] = [__v_0, __v_2, __v_1]; record.function_queries[383].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { let __ret: [G; OUT_383] = [__v_0, __v_2, __v_1]; record.function_queries[383].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_792] = { let __args: [G; IN_792] = [__v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_369] = { let __args: [G; IN_369] = [__v_6, __v_2, __v_7]; 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_383] = [__v_8]; record.function_queries[383].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_383] = [__v_8]; record.function_queries[383].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } const INPUT_SIZE_384: usize = 3; const IN_384: usize = 3; 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 = 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_383] = { let __args: [G; IN_383] = [__v_1, __v_0, __v_4]; 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 __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_1, __v_0]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_384] = [__v_9]; record.function_queries[384].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_6, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_10, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_11, __v_7, __v_2]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_384] = [__v_12]; record.function_queries[384].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_5, __v_6, __v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_10, __v_7, __v_2]; 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_384] = [__v_11]; record.function_queries[384].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_385: usize = 3; -const IN_385: usize = 3; +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 __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_383] = { let __args: [G; IN_383] = [__v_4, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_384] = [__v_7]; record.function_queries[384].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_384] = [__v_9]; record.function_queries[384].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_384] = [__v_9]; record.function_queries[384].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_5, __v_1, __v_2]; 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_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_384] = [__v_11]; record.function_queries[384].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1, __v_2]; 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_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_382] = { let __args: [G; IN_382] = [__v_5, __v_1, __v_10]; 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_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_384] = [__v_13]; record.function_queries[384].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1, __v_2]; 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_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_382] = { let __args: [G; IN_382] = [__v_5, __v_1, __v_10]; 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_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_384] = [__v_13]; record.function_queries[384].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_384] = [__v_7]; record.function_queries[384].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_384] = [__v_9]; record.function_queries[384].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_6, __v_1, __v_2]; 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_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_384] = [__v_9]; record.function_queries[384].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_385: usize = 5; +const IN_385: usize = 5; 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 __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() { 3u64 => { 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_7, __v_9, __v_2]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_10]; record.function_queries[385].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_0, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_7]; record.function_queries[385].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_5, __v_0, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_7]; record.function_queries[385].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_8, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_9]; record.function_queries[385].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_4, __v_5, __v_6, __v_1, __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_7: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_7]; record.function_queries[385].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_7: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_7]; record.function_queries[385].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_386: usize = 5; -const IN_386: usize = 5; -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 __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, __v_4]; 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 __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1, __v_7, __v_8]; 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 __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_10, __v_3, __v_4]; 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_386] = [__v_11]; record.function_queries[386].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_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_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_394] = { let __args: [G; IN_394] = [__v_7]; 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_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() { 6u64 => { let __v_28: G = (__v_22 + __v_1); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_8, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_29, __v_3, __v_4]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_386] = [__v_30]; record.function_queries[386].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_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_263] = { let __args: [G; IN_263] = [__v_29, __v_3]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_386] = [__v_30]; record.function_queries[386].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_263] = { let __args: [G; IN_263] = [__v_16, __v_3]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_386] = [__v_17]; record.function_queries[386].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_387: usize = 0; -const IN_387: usize = 0; +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 __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_3, __v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_1, __v_3, __v_4]; 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_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_382] = { let __args: [G; IN_382] = [__v_2, __v_3, __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 __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_385] = [__v_11]; record.function_queries[385].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_386: usize = 3; +const IN_386: usize = 3; +const OUT_386: usize = 3; +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 __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_386] = { let __args: [G; IN_386] = [__v_5, __v_9, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __ret: [G; OUT_386] = [__v_12, __v_13, __v_14]; record.function_queries[386].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_386] = [__v_0, __v_2, __v_1]; record.function_queries[386].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { let __ret: [G; OUT_386] = [__v_0, __v_2, __v_1]; record.function_queries[386].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_387: usize = 3; +const IN_387: usize = 3; const OUT_387: usize = 1; -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 = G::from_u64(61); let __v_1: G = G::from_u64(121); let __v_2: G = G::from_u64(123); let __v_3: G = G::from_u64(197); let __v_4: G = G::from_u64(114); let __v_5: G = G::from_u64(216); let __v_6: G = G::from_u64(243); let __v_7: G = G::from_u64(62); let __v_8: G = G::from_u64(183); let __v_9: G = G::from_u64(207); let __v_10: G = G::from_u64(245); let __v_11: G = G::from_u64(170); let __v_12: G = G::from_u64(19); let __v_13: G = G::from_u64(248); let __v_14: G = G::from_u64(220); let __v_15: G = G::from_u64(115); let __v_16: G = G::from_u64(188); let __v_17: G = G::from_u64(242); let __v_18: G = G::from_u64(16); let __v_19: G = G::from_u64(38); let __v_20: G = G::from_u64(191); let __v_21: G = G::from_u64(5); let __v_22: G = G::from_u64(208); let __v_23: G = G::from_u64(56); let __v_24: G = G::from_u64(136); let __v_25: G = G::from_u64(201); let __v_26: G = G::from_u64(3); let __v_27: G = G::from_u64(105); let __v_28: G = G::from_u64(239); let __v_29: G = { let __values: [G; 32] = [__v_0, __v_1, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_11, __v_26, __v_27, __v_14, __v_28]; 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_387] = [__v_29]; record.function_queries[387].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_388: usize = 0; -const IN_388: usize = 0; +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 __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_386] = { let __args: [G; IN_386] = [__v_1, __v_0, __v_4]; 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 = __r_arr[1]; let __v_7: G = __r_arr[2]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_1, __v_0]; 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_387] = [__v_9]; record.function_queries[387].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_6, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __v_10, __v_9]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_11, __v_7, __v_2]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_387] = [__v_12]; record.function_queries[387].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_5, __v_6, __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 __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_10, __v_7, __v_2]; 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 __ret: [G; OUT_387] = [__v_11]; record.function_queries[387].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_388: usize = 3; +const IN_388: usize = 3; const OUT_388: usize = 1; -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 = G::from_u64(22); let __v_1: G = G::from_u64(207); let __v_2: G = G::from_u64(221); let __v_3: G = G::from_u64(218); let __v_4: G = G::from_u64(156); let __v_5: G = G::from_u64(39); let __v_6: G = G::from_u64(70); let __v_7: G = G::from_u64(96); let __v_8: G = G::from_u64(243); let __v_9: G = G::from_u64(145); let __v_10: G = G::from_u64(177); let __v_11: G = G::from_u64(14); let __v_12: G = G::from_u64(239); let __v_13: G = G::from_u64(224); let __v_14: G = G::from_u64(102); let __v_15: G = G::from_u64(90); let __v_16: G = G::from_u64(255); let __v_17: G = G::from_u64(250); let __v_18: G = G::from_u64(225); let __v_19: G = G::from_u64(204); let __v_20: G = G::from_u64(212); let __v_21: G = G::from_u64(109); let __v_22: G = G::from_u64(175); let __v_23: G = G::from_u64(67); let __v_24: G = G::from_u64(184); let __v_25: G = G::from_u64(168); let __v_26: G = G::from_u64(10); let __v_27: G = G::from_u64(234); let __v_28: G = G::from_u64(133); let __v_29: 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_5, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_4, __v_21, __v_22, __v_23, __v_22, __v_24, __v_25, __v_26, __v_27, __v_28]; 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_388] = [__v_29]; record.function_queries[388].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_389: usize = 0; -const IN_389: usize = 0; +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 __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() { 3u64 => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_7, __v_9, __v_2]; 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 __ret: [G; OUT_388] = [__v_10]; record.function_queries[388].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1, __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_7: G = __r_arr[0]; let __ret: [G; OUT_388] = [__v_7]; record.function_queries[388].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_4, __v_5, __v_0, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_388] = [__v_7]; record.function_queries[388].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_6, __v_5, __v_7]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_8, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_388] = [__v_9]; record.function_queries[388].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(389, (&__args[..]))?) { [G::ZERO; OUT_389] } else { let (__hash, __hit) = record.function_queries[389].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[389].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[389].bump_multiplicity(__i); } let __ret: [G; OUT_389] = unsafe { (*(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389])) }; __ret }, _ => { aiur_fn_389::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_388] = [__v_7]; record.function_queries[388].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_388] = [__v_7]; record.function_queries[388].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_389: usize = 5; +const IN_389: usize = 5; 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 = G::from_u64(53); let __v_1: G = G::from_u64(225); let __v_2: G = G::from_u64(204); let __v_3: G = G::from_u64(128); let __v_4: G = G::from_u64(159); let __v_5: G = G::from_u64(111); let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(101); let __v_8: G = G::from_u64(33); let __v_9: G = G::from_u64(164); let __v_10: G = G::from_u64(63); let __v_11: G = G::from_u64(133); let __v_12: G = G::from_u64(6); let __v_13: G = G::from_u64(141); let __v_14: G = G::from_u64(85); let __v_15: G = G::from_u64(146); let __v_16: G = G::from_u64(34); let __v_17: G = G::from_u64(4); let __v_18: G = G::from_u64(192); let __v_19: G = G::from_u64(83); let __v_20: G = G::from_u64(43); let __v_21: G = G::from_u64(106); let __v_22: G = G::from_u64(8); let __v_23: G = G::from_u64(149); let __v_24: G = G::from_u64(47); let __v_25: G = G::from_u64(64); let __v_26: G = G::from_u64(216); let __v_27: G = G::from_u64(82); let __v_28: G = G::from_u64(61); let __v_29: G = G::from_u64(188); 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_6, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_17, __v_29]; 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_389] = [__v_30]; record.function_queries[389].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __v_4: G = inp[4]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_5, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_1, __v_7, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_10, __v_3, __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_11: G = __r_arr[0]; let __ret: [G; OUT_389] = [__v_11]; record.function_queries[389].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_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_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_397] = { let __args: [G; IN_397] = [__v_7]; 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_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() { 6u64 => { let __v_28: G = (__v_22 + __v_1); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_8, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_29, __v_3, __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_30: G = __r_arr[0]; let __ret: [G; OUT_389] = [__v_30]; record.function_queries[389].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_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_266] = { let __args: [G; IN_266] = [__v_29, __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_30: G = __r_arr[0]; let __ret: [G; OUT_389] = [__v_30]; record.function_queries[389].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_266] = { let __args: [G; IN_266] = [__v_16, __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_17: G = __r_arr[0]; let __ret: [G; OUT_389] = [__v_17]; record.function_queries[389].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_390: usize = 0; const IN_390: usize = 0; 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 = G::from_u64(129); let __v_1: G = G::from_u64(22); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(223); let __v_4: G = G::from_u64(165); let __v_5: G = G::from_u64(159); let __v_6: G = G::from_u64(54); let __v_7: G = G::from_u64(18); let __v_8: G = G::from_u64(203); let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(192); let __v_11: G = G::from_u64(240); let __v_12: G = G::from_u64(71); let __v_13: G = G::from_u64(90); let __v_14: G = G::from_u64(241); let __v_15: G = G::from_u64(82); let __v_16: G = G::from_u64(57); let __v_17: G = G::from_u64(157); let __v_18: G = G::from_u64(239); let __v_19: G = G::from_u64(255); let __v_20: G = G::from_u64(146); let __v_21: G = G::from_u64(38); let __v_22: G = G::from_u64(198); let __v_23: G = G::from_u64(225); let __v_24: G = G::from_u64(214); let __v_25: G = G::from_u64(72); let __v_26: G = G::from_u64(4); let __v_27: G = G::from_u64(26); let __v_28: G = G::from_u64(104); let __v_29: G = G::from_u64(153); let __v_30: G = G::from_u64(169); let __v_31: 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_5, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; 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_390] = [__v_31]; record.function_queries[390].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(30); let __v_1: G = G::from_u64(26); let __v_2: G = G::from_u64(43); let __v_3: G = G::from_u64(187); let __v_4: G = G::from_u64(25); let __v_5: G = G::from_u64(32); let __v_6: G = G::from_u64(237); let __v_7: G = G::from_u64(74); let __v_8: G = G::from_u64(18); let __v_9: G = G::from_u64(129); let __v_10: G = G::from_u64(163); let __v_11: G = G::from_u64(222); let __v_12: G = G::from_u64(202); let __v_13: G = G::from_u64(100); let __v_14: G = G::from_u64(106); let __v_15: G = G::from_u64(211); let __v_16: G = G::from_u64(19); let __v_17: G = G::from_u64(156); let __v_18: G = G::from_u64(123); let __v_19: G = G::from_u64(247); let __v_20: G = G::from_u64(234); let __v_21: G = G::from_u64(189); let __v_22: G = G::from_u64(195); let __v_23: G = G::from_u64(101); let __v_24: G = G::from_u64(89); let __v_25: G = G::from_u64(135); let __v_26: G = G::from_u64(121); let __v_27: G = G::from_u64(124); let __v_28: G = G::from_u64(204); let __v_29: G = G::from_u64(12); let __v_30: G = G::from_u64(85); let __v_31: 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_12, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_390] = [__v_31]; record.function_queries[390].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_391: usize = 0; const IN_391: usize = 0; 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 = G::from_u64(134); let __v_1: G = G::from_u64(179); let __v_2: G = G::from_u64(101); let __v_3: G = G::from_u64(231); let __v_4: G = G::from_u64(91); let __v_5: G = G::from_u64(180); let __v_6: G = G::from_u64(35); let __v_7: G = G::from_u64(15); let __v_8: G = G::from_u64(4); let __v_9: G = G::from_u64(198); let __v_10: G = G::from_u64(228); let __v_11: G = G::from_u64(243); let __v_12: G = G::from_u64(167); let __v_13: G = G::from_u64(202); let __v_14: G = G::from_u64(105); let __v_15: G = G::from_u64(136); let __v_16: G = G::from_u64(173); let __v_17: G = G::from_u64(245); let __v_18: G = G::from_u64(116); let __v_19: G = G::from_u64(97); let __v_20: G = G::from_u64(109); let __v_21: G = G::from_u64(121); let __v_22: G = G::from_u64(163); let __v_23: G = G::from_u64(215); let __v_24: G = G::from_u64(71); let __v_25: G = G::from_u64(122); let __v_26: G = G::from_u64(214); let __v_27: G = G::from_u64(92); let __v_28: G = G::from_u64(172); let __v_29: G = G::from_u64(16); let __v_30: G = G::from_u64(33); let __v_31: 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_29]; 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_391] = [__v_31]; record.function_queries[391].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(62); let __v_1: G = G::from_u64(167); let __v_2: G = G::from_u64(225); let __v_3: G = G::from_u64(143); let __v_4: G = G::from_u64(203); let __v_5: G = G::from_u64(183); let __v_6: G = G::from_u64(196); let __v_7: G = G::from_u64(152); let __v_8: G = G::from_u64(178); let __v_9: G = G::from_u64(164); let __v_10: G = G::from_u64(82); let __v_11: G = G::from_u64(55); let __v_12: G = G::from_u64(189); let __v_13: G = G::from_u64(166); let __v_14: G = G::from_u64(89); let __v_15: G = G::from_u64(192); let __v_16: G = G::from_u64(237); let __v_17: G = G::from_u64(201); let __v_18: G = G::from_u64(123); let __v_19: G = G::from_u64(61); let __v_20: G = G::from_u64(84); let __v_21: G = G::from_u64(173); let __v_22: G = G::from_u64(13); let __v_23: G = G::from_u64(17); let __v_24: G = G::from_u64(188); let __v_25: G = G::from_u64(46); let __v_26: G = G::from_u64(190); let __v_27: G = G::from_u64(200); let __v_28: G = G::from_u64(12); let __v_29: G = G::from_u64(250); let __v_30: G = G::from_u64(23); let __v_31: 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_9, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_391] = [__v_31]; record.function_queries[391].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_392: usize = 0; const IN_392: usize = 0; 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 = G::from_u64(23); let __v_1: G = G::from_u64(69); let __v_2: G = G::from_u64(73); let __v_3: G = G::from_u64(28); let __v_4: G = G::from_u64(13); let __v_5: G = G::from_u64(101); let __v_6: G = G::from_u64(29); let __v_7: G = G::from_u64(224); let __v_8: G = G::from_u64(190); let __v_9: G = G::from_u64(165); let __v_10: G = G::from_u64(137); let __v_11: G = G::from_u64(213); let __v_12: G = G::from_u64(255); let __v_13: G = G::from_u64(251); let __v_14: G = G::from_u64(201); let __v_15: G = G::from_u64(188); let __v_16: G = G::from_u64(77); let __v_17: G = G::from_u64(127); let __v_18: G = G::from_u64(124); let __v_19: G = G::from_u64(128); let __v_20: G = G::from_u64(91); let __v_21: G = G::from_u64(31); let __v_22: G = G::from_u64(89); let __v_23: G = G::from_u64(202); let __v_24: G = G::from_u64(150); let __v_25: G = G::from_u64(166); let __v_26: G = G::from_u64(239); let __v_27: 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_8, __v_10, __v_18, __v_6, __v_19, __v_20, __v_21, __v_17, __v_22, __v_23, __v_24, __v_24, __v_25, __v_26]; 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_392] = [__v_27]; record.function_queries[392].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_393: usize = 4; -const IN_393: usize = 4; -const OUT_393: usize = 2; -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 __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { 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_393] = [__v_6, __v_7]; record.function_queries[393].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_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_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_388] = { let __args: [G; IN_388] = []; 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 __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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { 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_393] = [__v_12, __v_13]; record.function_queries[393].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(5); let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = 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 __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_393] = [__v_15, __v_16]; record.function_queries[393].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(2); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(4); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: 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_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: 4 })?; if (!unconstrained) { __mq.bump_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() { 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_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_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; let __v_32: G = __loaded[3]; match __v_29.as_canonical_u64() { 4u64 => { let __v_33: G = G::from_u64(8); let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(4); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; 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_38: G = __loaded[0]; let __v_39: G = __loaded[1]; let __v_40: G = __loaded[2]; let __v_41: G = __loaded[3]; match __v_38.as_canonical_u64() { 4u64 => { let __v_42: G = G::from_u64(8); let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __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 __v_44: G = G::from_u64(4); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __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 __v_47: G = G::from_u64(2); let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(389, (&__args[..]))?) { [G::ZERO; OUT_389] } else { let (__hash, __hit) = record.function_queries[389].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[389].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[389].bump_multiplicity(__i); } let __ret: [G; OUT_389] = unsafe { (*(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389])) }; __ret }, _ => { aiur_fn_389::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; 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 __v_51: G = { let __values: [G; 4] = [__v_47, __v_48, __v_50, __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 __v_52: G = { let __values: [G; 4] = [__v_44, __v_26, __v_51, __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 __v_53: G = { let __values: [G; 4] = [__v_47, __v_7, __v_8, __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 __v_54: G = G::from_u64(3); let __v_55: G = { let __values: [G; 4] = [__v_54, __v_53, __v_16, __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 __v_56: G = { let __values: [G; 4] = [__v_54, __v_55, __v_52, __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 __v_57: G = { let __values: [G; 4] = [__v_54, __v_56, __v_37, __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 __v_58: G = { let __values: [G; 4] = [__v_54, __v_57, __v_46, __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 __v_59: G = { let __values: [G; 4] = [__v_54, __v_58, __v_24, __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 __v_60: G = G::from_u64(5); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_3, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_59, __v_61]; 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_62: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_49, __v_62]; record.function_queries[393].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_42, __v_42, __v_42, __v_42]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_393] = [__v_42, __v_43]; record.function_queries[393].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 4] = [__v_33, __v_33, __v_33, __v_33]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_393] = [__v_33, __v_34]; record.function_queries[393].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_393] = [__v_29, __v_30]; record.function_queries[393].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_393] = [__v_10, __v_11]; record.function_queries[393].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_393] = [__v_6, __v_7]; record.function_queries[393].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_394: usize = 1; -const IN_394: 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 = G::from_u64(53); let __v_1: G = G::from_u64(225); let __v_2: G = G::from_u64(204); let __v_3: G = G::from_u64(128); let __v_4: G = G::from_u64(159); let __v_5: G = G::from_u64(111); let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(101); let __v_8: G = G::from_u64(33); let __v_9: G = G::from_u64(164); let __v_10: G = G::from_u64(63); let __v_11: G = G::from_u64(133); let __v_12: G = G::from_u64(6); let __v_13: G = G::from_u64(141); let __v_14: G = G::from_u64(85); let __v_15: G = G::from_u64(146); let __v_16: G = G::from_u64(34); let __v_17: G = G::from_u64(4); let __v_18: G = G::from_u64(192); let __v_19: G = G::from_u64(83); let __v_20: G = G::from_u64(43); let __v_21: G = G::from_u64(106); let __v_22: G = G::from_u64(8); let __v_23: G = G::from_u64(149); let __v_24: G = G::from_u64(47); let __v_25: G = G::from_u64(64); let __v_26: G = G::from_u64(216); let __v_27: G = G::from_u64(82); let __v_28: G = G::from_u64(61); let __v_29: G = G::from_u64(188); 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_6, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_17, __v_29]; 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_392] = [__v_30]; record.function_queries[392].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_393: usize = 0; +const IN_393: usize = 0; +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 = G::from_u64(129); let __v_1: G = G::from_u64(22); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(223); let __v_4: G = G::from_u64(165); let __v_5: G = G::from_u64(159); let __v_6: G = G::from_u64(54); let __v_7: G = G::from_u64(18); let __v_8: G = G::from_u64(203); let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(192); let __v_11: G = G::from_u64(240); let __v_12: G = G::from_u64(71); let __v_13: G = G::from_u64(90); let __v_14: G = G::from_u64(241); let __v_15: G = G::from_u64(82); let __v_16: G = G::from_u64(57); let __v_17: G = G::from_u64(157); let __v_18: G = G::from_u64(239); let __v_19: G = G::from_u64(255); let __v_20: G = G::from_u64(146); let __v_21: G = G::from_u64(38); let __v_22: G = G::from_u64(198); let __v_23: G = G::from_u64(225); let __v_24: G = G::from_u64(214); let __v_25: G = G::from_u64(72); let __v_26: G = G::from_u64(4); let __v_27: G = G::from_u64(26); let __v_28: G = G::from_u64(104); let __v_29: G = G::from_u64(153); let __v_30: G = G::from_u64(169); let __v_31: 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_5, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; 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_393] = [__v_31]; record.function_queries[393].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_394: usize = 0; +const IN_394: usize = 0; 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 __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_295] = { let __args: [G; IN_295] = [__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_5: G = __r_arr[0]; let __ret: [G; OUT_394] = [__v_5]; record.function_queries[394].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_394] = [__v_9]; record.function_queries[394].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_395: usize = 2; -const IN_395: usize = 2; +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 = G::from_u64(134); let __v_1: G = G::from_u64(179); let __v_2: G = G::from_u64(101); let __v_3: G = G::from_u64(231); let __v_4: G = G::from_u64(91); let __v_5: G = G::from_u64(180); let __v_6: G = G::from_u64(35); let __v_7: G = G::from_u64(15); let __v_8: G = G::from_u64(4); let __v_9: G = G::from_u64(198); let __v_10: G = G::from_u64(228); let __v_11: G = G::from_u64(243); let __v_12: G = G::from_u64(167); let __v_13: G = G::from_u64(202); let __v_14: G = G::from_u64(105); let __v_15: G = G::from_u64(136); let __v_16: G = G::from_u64(173); let __v_17: G = G::from_u64(245); let __v_18: G = G::from_u64(116); let __v_19: G = G::from_u64(97); let __v_20: G = G::from_u64(109); let __v_21: G = G::from_u64(121); let __v_22: G = G::from_u64(163); let __v_23: G = G::from_u64(215); let __v_24: G = G::from_u64(71); let __v_25: G = G::from_u64(122); let __v_26: G = G::from_u64(214); let __v_27: G = G::from_u64(92); let __v_28: G = G::from_u64(172); let __v_29: G = G::from_u64(16); let __v_30: G = G::from_u64(33); let __v_31: 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_29]; 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_394] = [__v_31]; record.function_queries[394].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_395: usize = 0; +const IN_395: usize = 0; 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 __loaded: [G; 3] = { let __base = 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_395] = [__v_6]; record.function_queries[395].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_3, __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 = G::from_u64(0); let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_6, __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 __ret: [G; OUT_395] = [__v_8]; record.function_queries[395].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_396: usize = 3; -const IN_396: usize = 3; +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 = G::from_u64(23); let __v_1: G = G::from_u64(69); let __v_2: G = G::from_u64(73); let __v_3: G = G::from_u64(28); let __v_4: G = G::from_u64(13); let __v_5: G = G::from_u64(101); let __v_6: G = G::from_u64(29); let __v_7: G = G::from_u64(224); let __v_8: G = G::from_u64(190); let __v_9: G = G::from_u64(165); let __v_10: G = G::from_u64(137); let __v_11: G = G::from_u64(213); let __v_12: G = G::from_u64(255); let __v_13: G = G::from_u64(251); let __v_14: G = G::from_u64(201); let __v_15: G = G::from_u64(188); let __v_16: G = G::from_u64(77); let __v_17: G = G::from_u64(127); let __v_18: G = G::from_u64(124); let __v_19: G = G::from_u64(128); let __v_20: G = G::from_u64(91); let __v_21: G = G::from_u64(31); let __v_22: G = G::from_u64(89); let __v_23: G = G::from_u64(202); let __v_24: G = G::from_u64(150); let __v_25: G = G::from_u64(166); let __v_26: G = G::from_u64(239); let __v_27: 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_8, __v_10, __v_18, __v_6, __v_19, __v_20, __v_21, __v_17, __v_22, __v_23, __v_24, __v_24, __v_25, __v_26]; 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_395] = [__v_27]; record.function_queries[395].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_396: usize = 4; +const IN_396: usize = 4; const OUT_396: usize = 2; -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 __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; 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_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_6: G = __r_arr[0]; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = { let __a_val = __v_4.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_10.as_canonical_u64() { 1u64 => { 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_396] = [__v_11, __v_12]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, (&__args[..]))?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { (*(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251])) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_14]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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 __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_18, __v_16]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_396] = [__v_15, __v_19]; record.function_queries[396].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_396] = [__v_15, __v_16]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = { let __a_val = __v_4.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_10.as_canonical_u64() { 1u64 => { 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_396] = [__v_11, __v_12]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, (&__args[..]))?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { (*(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251])) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14]; 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 __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, (&__args[..]))?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { (*(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130])) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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_19: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_19, __v_16]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_396] = [__v_15, __v_20]; record.function_queries[396].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_396] = [__v_15, __v_16]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_3, __v_4]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_396] = [__v_9, __v_10]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_397: usize = 2; -const IN_397: usize = 2; +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 __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { 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_396] = [__v_6, __v_7]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_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_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_391] = { let __args: [G; IN_391] = []; 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_10: G = __r_arr[0]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { 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_396] = [__v_12, __v_13]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(5); let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = 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 __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_396] = [__v_15, __v_16]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(2); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(4); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: 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_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: 4 })?; if (!unconstrained) { __mq.bump_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() { 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_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_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; let __v_32: G = __loaded[3]; match __v_29.as_canonical_u64() { 4u64 => { let __v_33: G = G::from_u64(8); let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(4); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; 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_38: G = __loaded[0]; let __v_39: G = __loaded[1]; let __v_40: G = __loaded[2]; let __v_41: G = __loaded[3]; match __v_38.as_canonical_u64() { 4u64 => { let __v_42: G = G::from_u64(8); let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __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 __v_44: G = G::from_u64(4); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __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 __v_47: G = G::from_u64(2); let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = []; 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_48: G = __r_arr[0]; 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 __v_51: G = { let __values: [G; 4] = [__v_47, __v_48, __v_50, __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 __v_52: G = { let __values: [G; 4] = [__v_44, __v_26, __v_51, __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 __v_53: G = { let __values: [G; 4] = [__v_47, __v_7, __v_8, __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 __v_54: G = G::from_u64(3); let __v_55: G = { let __values: [G; 4] = [__v_54, __v_53, __v_16, __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 __v_56: G = { let __values: [G; 4] = [__v_54, __v_55, __v_52, __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 __v_57: G = { let __values: [G; 4] = [__v_54, __v_56, __v_37, __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 __v_58: G = { let __values: [G; 4] = [__v_54, __v_57, __v_46, __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 __v_59: G = { let __values: [G; 4] = [__v_54, __v_58, __v_24, __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 __v_60: G = G::from_u64(5); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_3, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_59, __v_61]; 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_62: G = __r_arr[0]; let __ret: [G; OUT_396] = [__v_49, __v_62]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_42, __v_42, __v_42, __v_42]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_396] = [__v_42, __v_43]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 4] = [__v_33, __v_33, __v_33, __v_33]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_396] = [__v_33, __v_34]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_396] = [__v_29, __v_30]; record.function_queries[396].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_396] = [__v_10, __v_11]; record.function_queries[396].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_396] = [__v_6, __v_7]; record.function_queries[396].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_397: usize = 1; +const IN_397: usize = 1; 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 __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1]; 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_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() { 1u64 => { let __ret: [G; OUT_397] = [__v_2]; record.function_queries[397].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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_397] = [__v_2]; record.function_queries[397].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_7]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_10, __v_1]; 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 __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_9, __v_11]; 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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_12, __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_16: G = { let __values: [G; 3] = [__v_14, __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_397] = [__v_16]; record.function_queries[397].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_398: usize = 1; -const IN_398: 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 __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_298] = { let __args: [G; IN_298] = [__v_2]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_397] = [__v_5]; record.function_queries[397].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_397] = [__v_9]; record.function_queries[397].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_398: usize = 2; +const IN_398: usize = 2; 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 __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; 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_1: G = __r_arr[0]; 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]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); break '__mc_0 [__v_3]; }, _ => { let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[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_170] = { let __args: [G; IN_170] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); break '__mc_0 [__v_7]; }, _ => { let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); break '__mc_0 [__v_9]; }, _ => { let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); break '__mc_0 [__v_11]; }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); break '__mc_0 [__v_13]; }, _ => { let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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 __v_15: G = G::from_u64(1); break '__mc_0 [__v_15]; }, _ => { let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; 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]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); break '__mc_0 [__v_17]; }, _ => { let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); break '__mc_0 [__v_19]; }, _ => { let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; 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 = G::from_u64(1); break '__mc_0 [__v_21]; }, _ => { let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); break '__mc_0 [__v_23]; }, _ => { let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); break '__mc_0 [__v_25]; }, _ => { let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); break '__mc_0 [__v_27]; }, _ => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; 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_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); break '__mc_0 [__v_29]; }, _ => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; 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_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); break '__mc_0 [__v_31]; }, _ => { let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; 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]; match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); break '__mc_0 [__v_33]; }, _ => { let __v_33: G = G::from_u64(0); break '__mc_0 [__v_33]; }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }; let __v_3: G = __mc_out___mc_0[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_398] = [__v_4]; record.function_queries[398].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_0]; 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]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(2); let __ret: [G; OUT_398] = [__v_5]; record.function_queries[398].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(3); let __ret: [G; OUT_398] = [__v_6]; record.function_queries[398].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4); 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_533] = { let __args: [G; IN_533] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(533, (&__args[..]))?) { [G::ZERO; OUT_533] } else { let (__hash, __hit) = record.function_queries[533].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[533].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { (*(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533])) }; __ret }, _ => { aiur_fn_533::(__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(5); 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_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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(6); let __ret: [G; OUT_398] = [__v_9]; record.function_queries[398].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_398] = [__v_9]; 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; +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 __loaded: [G; 3] = { let __base = 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_398] = [__v_6]; record.function_queries[398].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_6, __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 __ret: [G; OUT_398] = [__v_8]; record.function_queries[398].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_399: usize = 3; +const IN_399: usize = 3; const OUT_399: usize = 2; -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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_2, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_399] = [__v_5, __v_6]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_2, __v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_5, __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 __v_7: G = __r_arr[1]; let __ret: [G; OUT_399] = [__v_6, __v_7]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_2, __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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_399] = [__v_5, __v_6]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_0, __v_2, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_399] = [__v_5, __v_6]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(539, (&__args[..]))?) { [G::ZERO; OUT_539] } else { let (__hash, __hit) = record.function_queries[539].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[539].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { (*(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539])) }; __ret }, _ => { aiur_fn_539::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_399] = [__v_5, __v_6]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_2, __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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_399] = [__v_5, __v_6]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_399] = [__v_5, __v_6]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_400: usize = 3; -const IN_400: usize = 3; -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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_2]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_5, __v_6]; record.function_queries[400].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_2]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_7, __v_8]; record.function_queries[400].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_400] = [__v_7, __v_8]; record.function_queries[400].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_401: usize = 2; -const IN_401: usize = 2; -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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(6); 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_401] = [__v_5, __v_6]; record.function_queries[401].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_8, __v_1]; 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]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(6); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_263] = { let __args: [G; IN_263] = [__v_16, __v_12]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_401] = [__v_13, __v_17]; record.function_queries[401].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_401] = [__v_11, __v_12]; record.function_queries[401].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_402: usize = 2; -const IN_402: usize = 2; +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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_1, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; 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_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_6: G = __r_arr[0]; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = { let __a_val = __v_4.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_10.as_canonical_u64() { 1u64 => { 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_399] = [__v_11, __v_12]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_12]; 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 = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_14]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_18, __v_16]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_399] = [__v_15, __v_19]; record.function_queries[399].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_399] = [__v_15, __v_16]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = { let __a_val = __v_4.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_10.as_canonical_u64() { 1u64 => { 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_399] = [__v_11, __v_12]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_12]; 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 = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_17]; 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 __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_18]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_19, __v_16]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_399] = [__v_15, __v_20]; record.function_queries[399].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_399] = [__v_15, __v_16]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_0, __v_3, __v_4]; 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 __v_10: G = __r_arr[1]; let __ret: [G; OUT_399] = [__v_9, __v_10]; record.function_queries[399].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_400: usize = 2; +const IN_400: usize = 2; +const OUT_400: usize = 1; +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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_1]; 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_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() { 1u64 => { let __ret: [G; OUT_400] = [__v_2]; record.function_queries[400].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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_400] = [__v_2]; record.function_queries[400].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_7]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_10, __v_1]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_9, __v_11]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_1]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_12, __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_16: G = { let __values: [G; 3] = [__v_14, __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_400] = [__v_16]; record.function_queries[400].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_401: usize = 1; +const IN_401: usize = 1; +const OUT_401: usize = 1; +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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_1: G = __r_arr[0]; 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]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); break '__mc_0 [__v_3]; }, _ => { let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[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_173] = { let __args: [G; IN_173] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); break '__mc_0 [__v_7]; }, _ => { let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; 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_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); break '__mc_0 [__v_9]; }, _ => { let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); break '__mc_0 [__v_11]; }, _ => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); break '__mc_0 [__v_13]; }, _ => { let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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 __v_15: G = G::from_u64(1); break '__mc_0 [__v_15]; }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; 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]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); break '__mc_0 [__v_17]; }, _ => { let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); break '__mc_0 [__v_19]; }, _ => { let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; 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 = G::from_u64(1); break '__mc_0 [__v_21]; }, _ => { let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); break '__mc_0 [__v_23]; }, _ => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); break '__mc_0 [__v_25]; }, _ => { let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); break '__mc_0 [__v_27]; }, _ => { let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; 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_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); break '__mc_0 [__v_29]; }, _ => { let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; 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_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); break '__mc_0 [__v_31]; }, _ => { let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; 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]; match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); break '__mc_0 [__v_33]; }, _ => { let __v_33: G = G::from_u64(0); break '__mc_0 [__v_33]; }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }; let __v_3: G = __mc_out___mc_0[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_401] = [__v_4]; record.function_queries[401].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(2); let __ret: [G; OUT_401] = [__v_5]; record.function_queries[401].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(3); let __ret: [G; OUT_401] = [__v_6]; record.function_queries[401].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4); let __ret: [G; OUT_401] = [__v_7]; record.function_queries[401].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(536, (&__args[..]))?) { [G::ZERO; OUT_536] } else { let (__hash, __hit) = record.function_queries[536].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[536].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[536].bump_multiplicity(__i); } let __ret: [G; OUT_536] = unsafe { (*(record.function_queries[536].output_at(__i).as_ptr() as *const [G; OUT_536])) }; __ret }, _ => { aiur_fn_536::(__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(5); let __ret: [G; OUT_401] = [__v_8]; record.function_queries[401].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(6); let __ret: [G; OUT_401] = [__v_9]; record.function_queries[401].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_401] = [__v_9]; 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 = 2; -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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(5); 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_402] = [__v_5, __v_6]; record.function_queries[402].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_8, __v_1]; 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]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(5); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_263] = { let __args: [G; IN_263] = [__v_16, __v_12]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_402] = [__v_13, __v_17]; record.function_queries[402].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_402] = [__v_11, __v_12]; record.function_queries[402].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_403: usize = 2; -const IN_403: usize = 2; +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_401] = { let __args: [G; IN_401] = [__v_0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0, __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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_402] = [__v_5, __v_6]; record.function_queries[402].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_2, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __v_5, __v_3]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_402] = [__v_6, __v_7]; record.function_queries[402].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_2, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_402] = [__v_5, __v_6]; record.function_queries[402].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_2, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_402] = [__v_5, __v_6]; record.function_queries[402].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(542, (&__args[..]))?) { [G::ZERO; OUT_542] } else { let (__hash, __hit) = record.function_queries[542].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[542].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { (*(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542])) }; __ret }, _ => { aiur_fn_542::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_402] = [__v_5, __v_6]; record.function_queries[402].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_2, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_402] = [__v_5, __v_6]; record.function_queries[402].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_402] = [__v_5, __v_6]; record.function_queries[402].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_403: usize = 3; +const IN_403: usize = 3; const OUT_403: usize = 2; -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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __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_2: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__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_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() { 2u64 => { let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(3); let __v_13: G = (__v_11 - __v_12); match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_4, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_403] = [__v_14, __v_16]; record.function_queries[403].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_403] = [__v_14, __v_15]; record.function_queries[403].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_403] = [__v_11, __v_12]; record.function_queries[403].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_403] = [__v_9, __v_10]; record.function_queries[403].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_404: usize = 5; -const IN_404: usize = 5; -const OUT_404: usize = 1; -fn aiur_fn_404(inp: [G; IN_404], 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 __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0, __v_1, __v_3, __v_4]; 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_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_6, __v_4]; 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 __ret: [G; OUT_404] = [__v_7]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_404] = [__v_6]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; 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 __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_405] = { let __args: [G; IN_405] = [__v_11, __v_3]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_21, __v_4]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_22]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_11, __v_1]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_22, __v_3, __v_4]; 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_404] = [__v_23]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_20]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_21, __v_4]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_22]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_22]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 7u64 => { let __v_20: G = (__v_11 + __v_13); let __v_21: G = (__v_20 + __v_14); let __v_22: G = (__v_21 + __v_12); let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_16.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_10, __v_22]; 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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; break '__mc_0 [__v_25, __v_26]; }, _ => { let __v_23: G = G::from_u64(0); break '__mc_0 [__v_23, __v_2]; }, } }; let __v_23: G = __mc_out___mc_0[0]; let __v_24: G = __mc_out___mc_0[1]; match __v_23.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_404] = [__v_24]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_10, __v_11, __v_13, __v_14, __v_12]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; match __v_26.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_27, __v_4]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_28]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { match __v_16.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_404] = [__v_27]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_29, __v_4]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_30]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_404] = [__v_27]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_28]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_20]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +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 __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = []; 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_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_2]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_403] = [__v_5, __v_6]; record.function_queries[403].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = []; 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_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_2]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_403] = [__v_7, __v_8]; record.function_queries[403].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_403] = [__v_7, __v_8]; record.function_queries[403].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_404: usize = 2; +const IN_404: usize = 2; +const OUT_404: usize = 2; +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(6); 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_404] = [__v_5, __v_6]; record.function_queries[404].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_8, __v_1]; 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_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(6); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_266] = { let __args: [G; IN_266] = [__v_16, __v_12]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_13, __v_17]; record.function_queries[404].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_404] = [__v_11, __v_12]; 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 = 2; -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 __v_2: G = G::from_u64(0); let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_0, __v_2]; 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_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_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_405] = [__v_10, __v_11]; record.function_queries[405].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_798] = { let __args: [G; IN_798] = [__v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_263] = { let __args: [G; IN_263] = [__v_12, __v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_405] = [__v_14, __v_15]; record.function_queries[405].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_405] = [__v_8, __v_9]; record.function_queries[405].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(5); 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_405] = [__v_5, __v_6]; record.function_queries[405].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_8, __v_1]; 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_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(5); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_266] = { let __args: [G; IN_266] = [__v_16, __v_12]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_405] = [__v_13, __v_17]; record.function_queries[405].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_405] = [__v_11, __v_12]; record.function_queries[405].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_406: usize = 2; const IN_406: usize = 2; -const OUT_406: usize = 5; -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 __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_406] = { let __args: [G; IN_406] = [__v_4, __v_7]; 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_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_406] = [__v_8, __v_9, __v_10, __v_11, __v_12]; record.function_queries[406].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_406] = [__v_11, __v_1, __v_3, __v_4, __v_13]; record.function_queries[406].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_406] = [__v_11, __v_11, __v_12, __v_11, __v_11]; record.function_queries[406].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_406] = [__v_10, __v_10, __v_11, __v_10, __v_10]; record.function_queries[406].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_406] = [__v_6, __v_6, __v_7, __v_6, __v_6]; record.function_queries[406].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_407: usize = 1; -const IN_407: usize = 1; +const OUT_406: usize = 2; +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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; 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_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() { 2u64 => { let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(3); let __v_13: G = (__v_11 - __v_12); match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_4, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_406] = [__v_14, __v_16]; record.function_queries[406].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_406] = [__v_14, __v_15]; record.function_queries[406].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_406] = [__v_11, __v_12]; record.function_queries[406].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_406] = [__v_9, __v_10]; record.function_queries[406].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_407: usize = 5; +const IN_407: usize = 5; const OUT_407: usize = 1; -fn aiur_fn_407(inp: [G; IN_407], 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 __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() { 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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() { 1u64 => { let __v_6: G = G::from_u64(2); let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; 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_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_6, __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 __ret: [G; OUT_407] = [__v_11]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; 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]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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 = G::from_u64(7); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(2); let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; 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_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 __v_15: G = { let __values: [G; 4] = [__v_11, __v_12, __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 = G::from_u64(3); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_15, __v_10, __v_9]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_407] = [__v_17]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_407] = [__v_0]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_407] = [__v_0]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_408: usize = 9; -const IN_408: usize = 9; +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 __v_4: G = inp[4]; let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_0, __v_1, __v_3, __v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_6, __v_4]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_7]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_407] = [__v_6]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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_408] = { let __args: [G; IN_408] = [__v_11, __v_3]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_21, __v_4]; 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 __ret: [G; OUT_407] = [__v_22]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_11, __v_1]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_22, __v_3, __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_23: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_23]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_20: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_20]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_3, __v_4]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_21, __v_4]; 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 __ret: [G; OUT_407] = [__v_22]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_22: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_22]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 7u64 => { let __v_20: G = (__v_11 + __v_13); let __v_21: G = (__v_20 + __v_14); let __v_22: G = (__v_21 + __v_12); let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_16.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_10, __v_22]; 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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; break '__mc_0 [__v_25, __v_26]; }, _ => { let __v_23: G = G::from_u64(0); break '__mc_0 [__v_23, __v_2]; }, } }; let __v_23: G = __mc_out___mc_0[0]; let __v_24: G = __mc_out___mc_0[1]; match __v_23.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_407] = [__v_24]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_10, __v_11, __v_13, __v_14, __v_12]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; match __v_26.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_27, __v_4]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_28]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { match __v_16.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_407] = [__v_27]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_29, __v_4]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_30]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_407] = [__v_27]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_28: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_28]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_20: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_20]; record.function_queries[407].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_408: usize = 2; +const IN_408: usize = 2; const OUT_408: usize = 2; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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; 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_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: 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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { _ => { let __v_14: G = (__v_4 + __v_5); let __v_15: G = (__v_3 + __v_14); let __v_16: G = (__v_2 + __v_15); let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_16, __v_17]; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { 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_408] = [__v_19, __v_20]; record.function_queries[408].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_19, __v_10, __v_2, __v_7, __v_8]; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); 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 __ret: [G; OUT_408] = [__v_21, __v_22]; record.function_queries[408].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_12, __v_0]; 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_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_4); let __v_23: G = (__v_2 + __v_22); let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_1, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __v_26: G = (__v_16 + __v_25); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_1, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_21, __v_24]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_28, __v_27]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_29, __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_30: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_25, __v_30]; record.function_queries[408].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_408] = [__v_14, __v_15]; record.function_queries[408].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_409: usize = 5; -const IN_409: usize = 5; -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 __v_4: G = inp[4]; let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_4]; 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 __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_5, __v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; 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_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 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_409] = [__v_14]; record.function_queries[409].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_10]; 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_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() { 5u64 => { let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_22, __v_23, __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 __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_797] = { let __args: [G; IN_797] = [__v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_30, __v_31]; 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_32: G = __r_arr[0]; let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_32, __v_4]; 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 __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_6, __v_33, __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_34: G = __r_arr[0]; let __ret: [G; OUT_409] = [__v_34]; record.function_queries[409].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_409] = [__v_27]; record.function_queries[409].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_409] = [__v_13]; record.function_queries[409].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_410: usize = 3; -const IN_410: usize = 3; +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 __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_2]; 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_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_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_408] = [__v_10, __v_11]; record.function_queries[408].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_801] = { let __args: [G; IN_801] = [__v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_266] = { let __args: [G; IN_266] = [__v_12, __v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_14, __v_15]; record.function_queries[408].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_408] = [__v_8, __v_9]; record.function_queries[408].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_409: usize = 2; +const IN_409: usize = 2; +const OUT_409: usize = 5; +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 __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_409] = { let __args: [G; IN_409] = [__v_4, __v_7]; 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_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_409] = [__v_8, __v_9, __v_10, __v_11, __v_12]; record.function_queries[409].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_409] = [__v_11, __v_1, __v_3, __v_4, __v_13]; record.function_queries[409].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_409] = [__v_11, __v_11, __v_12, __v_11, __v_11]; record.function_queries[409].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_409] = [__v_10, __v_10, __v_11, __v_10, __v_10]; record.function_queries[409].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_409] = [__v_6, __v_6, __v_7, __v_6, __v_6]; record.function_queries[409].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_410: usize = 1; +const IN_410: usize = 1; 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 __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__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_798] = { let __args: [G; IN_798] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_786] = { let __args: [G; IN_786] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_10, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[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 = 2; -const IN_411: usize = 2; -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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __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_2: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__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_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() { 2u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_6]; 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_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_344] = { let __args: [G; IN_344] = [__v_13, __v_7]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_22, __v_4, __v_1]; 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 __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_23, __v_1]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_24]; record.function_queries[411].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_411] = [__v_2]; record.function_queries[411].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_411] = [__v_2]; record.function_queries[411].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_412: usize = 10; -const IN_412: usize = 10; -const OUT_412: usize = 2; -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 __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = 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_4 + __v_5); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_2 + __v_11); let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = 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() { 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_412] = [__v_15, __v_16]; record.function_queries[412].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_1, __v_2, __v_3, __v_4, __v_12]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_412] = [__v_17, __v_16]; record.function_queries[412].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_18, __v_7]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_19]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_20]; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_21]; 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_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]; match __v_22.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_24, __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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("iota: major's constructor belongs to a different inductive".to_string()) }); } let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_23]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; match __v_28.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_1, __v_12, __v_19]; 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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_8, __v_31]; 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_33: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_32, __v_33]; record.function_queries[412].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_30, __v_0]; 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_31: G = __r_arr[0]; let __v_32: G = (__v_3 + __v_4); let __v_33: G = (__v_2 + __v_32); let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_1, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_35 - __v_29); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_25, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_12 + __v_38); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_1, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_31, __v_34]; 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_41: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_41, __v_37]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_42, __v_40]; 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_43: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_38, __v_43]; record.function_queries[412].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_1, __v_12, __v_19]; 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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_8, __v_26]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_27, __v_28]; record.function_queries[412].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_413: usize = 1; -const IN_413: usize = 1; -const OUT_413: usize = 4; -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 __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_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_295] = { let __args: [G; IN_295] = [__v_4]; 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 __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_471] = { let __args: [G; IN_471] = [__v_11, __v_12]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_20, __v_13, __v_21, __v_2]; record.function_queries[413].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_413] = [__v_20, __v_20, __v_21, __v_23]; record.function_queries[413].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_413] = [__v_7, __v_7, __v_8, __v_10]; record.function_queries[413].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __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() { 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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() { 1u64 => { let __v_6: G = G::from_u64(2); let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; 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_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_6, __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 __ret: [G; OUT_410] = [__v_11]; record.function_queries[410].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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 = G::from_u64(7); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(2); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_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 __v_15: G = { let __values: [G; 4] = [__v_11, __v_12, __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 = G::from_u64(3); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_15, __v_10, __v_9]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_410] = [__v_17]; record.function_queries[410].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_410] = [__v_0]; record.function_queries[410].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_410] = [__v_0]; record.function_queries[410].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_411: usize = 9; +const IN_411: usize = 9; +const OUT_411: usize = 2; +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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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; 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_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: 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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { _ => { let __v_14: G = (__v_4 + __v_5); let __v_15: G = (__v_3 + __v_14); let __v_16: G = (__v_2 + __v_15); let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_16, __v_17]; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { 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_411] = [__v_19, __v_20]; record.function_queries[411].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_19, __v_10, __v_2, __v_7, __v_8]; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); 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 __ret: [G; OUT_411] = [__v_21, __v_22]; record.function_queries[411].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_12, __v_0]; 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_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_4); let __v_23: G = (__v_2 + __v_22); let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_1, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __v_26: G = (__v_16 + __v_25); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_1, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_21, __v_24]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_28, __v_27]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_29, __v_8]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_25, __v_30]; record.function_queries[411].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_411] = [__v_14, __v_15]; record.function_queries[411].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_412: usize = 5; +const IN_412: usize = 5; +const OUT_412: usize = 1; +fn aiur_fn_412(inp: [G; IN_412], 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 __v_4: G = inp[4]; let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_0, __v_4]; 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 __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_5, __v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_6]; 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_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 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_412] = [__v_14]; record.function_queries[412].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__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_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() { 5u64 => { let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_22, __v_23, __v_1]; 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_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_800] = { let __args: [G; IN_800] = [__v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_30, __v_31]; 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_32: G = __r_arr[0]; let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_32, __v_4]; 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 __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_6, __v_33, __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_34: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_34]; record.function_queries[412].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_412] = [__v_27]; record.function_queries[412].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_412] = [__v_13]; record.function_queries[412].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_413: usize = 3; +const IN_413: usize = 3; +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 __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__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_801] = { let __args: [G; IN_801] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_789] = { let __args: [G; IN_789] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_10, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_11]; record.function_queries[413].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_414: usize = 2; const IN_414: usize = 2; -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 __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_414] = [__v_7, __v_7, __v_8]; record.function_queries[414].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_414] = [__v_8, __v_4, __v_5]; record.function_queries[414].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __ret: [G; OUT_414] = [__v_8, __v_9, __v_10]; record.function_queries[414].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_415: usize = 9; -const IN_415: usize = 9; +const OUT_414: usize = 1; +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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; 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_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() { 2u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_6]; 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_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_347] = { let __args: [G; IN_347] = [__v_13, __v_7]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_22, __v_4, __v_1]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_1]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_414] = [__v_24]; record.function_queries[414].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_414] = [__v_2]; record.function_queries[414].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_414] = [__v_2]; record.function_queries[414].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_415: usize = 10; +const IN_415: usize = 10; const OUT_415: usize = 2; -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 __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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { let __v_14: G = 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_415] = [__v_14, __v_15]; record.function_queries[415].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_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: 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_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]; match __v_14.as_canonical_u64() { 0u64 => { 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_415] = [__v_19, __v_20]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { match __v_10.as_canonical_u64() { _ => { let __v_19: G = (__v_3 + __v_4); let __v_20: G = (__v_19 + __v_5); let __v_21: G = (__v_20 + __v_6); let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_21]; 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_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(0); let __v_25: G = { let __values: [G; 4] = [__v_24, __v_24, __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_415] = [__v_24, __v_25]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_23]; 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_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]; match __v_25.as_canonical_u64() { 5u64 => { let __v_37: G = G::from_u64(1); let __v_38: G = (__v_30 - __v_37); match __v_38.as_canonical_u64() { 0u64 => { match __v_29.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_23]; 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]; match __v_39.as_canonical_u64() { 1u64 => { 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_415] = [__v_40, __v_41]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_2, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_40]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_41, __v_42]; 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_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 4] = [__v_44, __v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_415] = [__v_44, __v_45]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_40, __v_8]; 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 __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_44, __v_8]; 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_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_46, __v_46, __v_46, __v_46]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_415] = [__v_46, __v_47]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_12, __v_1]; 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_46: G = __r_arr[0]; let __v_47: G = (__v_3 + __v_4); let __v_48: G = (__v_47 + __v_5); let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_2, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_46, __v_49]; 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_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_50, __v_23, __v_40, __v_11, __v_51]; 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_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_21 + __v_53); let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_2, __v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_52, __v_55]; 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_56: G = __r_arr[0]; let __ret: [G; OUT_415] = [__v_53, __v_56]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_39: G = G::from_u64(0); let __v_40: G = { let __values: [G; 4] = [__v_39, __v_39, __v_39, __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 __ret: [G; OUT_415] = [__v_39, __v_40]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_39: G = G::from_u64(0); let __v_40: G = { let __values: [G; 4] = [__v_39, __v_39, __v_39, __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 __ret: [G; OUT_415] = [__v_39, __v_40]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 4] = [__v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_415] = [__v_37, __v_38]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_416: usize = 2; -const IN_416: usize = 2; -const OUT_416: usize = 2; -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]; 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_122] = { let __args: [G; IN_122] = [__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_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_416] = [__v_12, __v_9]; record.function_queries[416].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_416] = [__v_12, __v_13]; record.function_queries[416].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_416] = [__v_6, __v_7]; record.function_queries[416].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_416] = { let __args: [G; IN_416] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_416] = [__v_8, __v_9]; record.function_queries[416].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_416] = [__v_6, __v_7]; 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 = 1; -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 __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_417] = [__v_0]; record.function_queries[417].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_417] = { let __args: [G; IN_417] = [__v_10, __v_1, __v_2, __v_3, __v_12]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_13]; record.function_queries[417].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_418: usize = 1; -const IN_418: usize = 1; -const OUT_418: usize = 1; -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 __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; 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_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_419] = { let __args: [G; IN_419] = [__v_0, __v_9]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_418] = [__v_16]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_418] = [__v_14]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 = (__v_4 + __v_5); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_2 + __v_11); let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = 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() { 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_415] = [__v_15, __v_16]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_1, __v_2, __v_3, __v_4, __v_12]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_415] = [__v_17, __v_16]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_18, __v_7]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_19]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_20]; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_21]; 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_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]; match __v_22.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_24, __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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("iota: major's constructor belongs to a different inductive".to_string()) }); } let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_23]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; match __v_28.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_12, __v_19]; 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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_8, __v_31]; 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_33: G = __r_arr[0]; let __ret: [G; OUT_415] = [__v_32, __v_33]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_30, __v_0]; 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_31: G = __r_arr[0]; let __v_32: G = (__v_3 + __v_4); let __v_33: G = (__v_2 + __v_32); let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_1, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_35 - __v_29); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_25, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_12 + __v_38); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_1, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_31, __v_34]; 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_41: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_41, __v_37]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_42, __v_40]; 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_43: G = __r_arr[0]; let __ret: [G; OUT_415] = [__v_38, __v_43]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_12, __v_19]; 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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_8, __v_26]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_415] = [__v_27, __v_28]; record.function_queries[415].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_416: usize = 1; +const IN_416: usize = 1; +const OUT_416: usize = 4; +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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_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_298] = { let __args: [G; IN_298] = [__v_4]; 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_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_474] = { let __args: [G; IN_474] = [__v_11, __v_12]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_416] = [__v_20, __v_13, __v_21, __v_2]; record.function_queries[416].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_416] = [__v_20, __v_20, __v_21, __v_23]; record.function_queries[416].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_416] = [__v_7, __v_7, __v_8, __v_10]; record.function_queries[416].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_417: usize = 2; +const IN_417: usize = 2; +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 __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_417] = [__v_7, __v_7, __v_8]; record.function_queries[417].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_417] = [__v_8, __v_4, __v_5]; record.function_queries[417].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __ret: [G; OUT_417] = [__v_8, __v_9, __v_10]; record.function_queries[417].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_418: usize = 9; +const IN_418: usize = 9; +const OUT_418: usize = 2; +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 __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; 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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { let __v_14: G = 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_418] = [__v_14, __v_15]; record.function_queries[418].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_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: 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_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]; match __v_14.as_canonical_u64() { 0u64 => { 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_418] = [__v_19, __v_20]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { match __v_10.as_canonical_u64() { _ => { let __v_19: G = (__v_3 + __v_4); let __v_20: G = (__v_19 + __v_5); let __v_21: G = (__v_20 + __v_6); let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_21]; 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_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(0); let __v_25: G = { let __values: [G; 4] = [__v_24, __v_24, __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_418] = [__v_24, __v_25]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_23]; 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_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]; match __v_25.as_canonical_u64() { 5u64 => { let __v_37: G = G::from_u64(1); let __v_38: G = (__v_30 - __v_37); match __v_38.as_canonical_u64() { 0u64 => { match __v_29.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_23]; 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_39: G = __r_arr[0]; match __v_39.as_canonical_u64() { 1u64 => { 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_418] = [__v_40, __v_41]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_2, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_40]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_41, __v_42]; 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_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 4] = [__v_44, __v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_418] = [__v_44, __v_45]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_40, __v_8]; 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 __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_44, __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_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_46, __v_46, __v_46, __v_46]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_418] = [__v_46, __v_47]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_12, __v_1]; 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_46: G = __r_arr[0]; let __v_47: G = (__v_3 + __v_4); let __v_48: G = (__v_47 + __v_5); let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_2, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_46, __v_49]; 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_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_50, __v_23, __v_40, __v_11, __v_51]; 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_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_21 + __v_53); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_2, __v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_52, __v_55]; 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_56: G = __r_arr[0]; let __ret: [G; OUT_418] = [__v_53, __v_56]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_39: G = G::from_u64(0); let __v_40: G = { let __values: [G; 4] = [__v_39, __v_39, __v_39, __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 __ret: [G; OUT_418] = [__v_39, __v_40]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_39: G = G::from_u64(0); let __v_40: G = { let __values: [G; 4] = [__v_39, __v_39, __v_39, __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 __ret: [G; OUT_418] = [__v_39, __v_40]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 4] = [__v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_418] = [__v_37, __v_38]; record.function_queries[418].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } const INPUT_SIZE_419: usize = 2; const IN_419: usize = 2; -const OUT_419: usize = 1; -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 __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_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_303] = { let __args: [G; IN_303] = [__v_3, __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_50: G = __r_arr[0]; let __ret: [G; OUT_419] = [__v_50]; record.function_queries[419].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_419] = [__v_53]; 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_419: usize = 2; +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]; 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_125] = { let __args: [G; IN_125] = [__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_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_419] = [__v_12, __v_9]; record.function_queries[419].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_419] = [__v_12, __v_13]; record.function_queries[419].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_419] = [__v_6, __v_7]; record.function_queries[419].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_419] = { let __args: [G; IN_419] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_419] = [__v_8, __v_9]; record.function_queries[419].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_419] = [__v_6, __v_7]; record.function_queries[419].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_420: usize = 5; +const IN_420: usize = 5; const OUT_420: usize = 1; -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 __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_420] = [__v_7]; record.function_queries[420].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1, __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_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_421] = { let __args: [G; IN_421] = [__v_10, __v_3]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_20, __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_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); let __ret: [G; OUT_420] = [__v_22]; record.function_queries[420].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_420] = { let __args: [G; IN_420] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_420] = [__v_24]; record.function_queries[420].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); let __ret: [G; OUT_420] = [__v_20]; record.function_queries[420].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_421: usize = 2; -const IN_421: usize = 2; +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 = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_420] = [__v_0]; record.function_queries[420].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_420] = { let __args: [G; IN_420] = [__v_10, __v_1, __v_2, __v_3, __v_12]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_420] = [__v_13]; record.function_queries[420].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_421: usize = 1; +const IN_421: usize = 1; const OUT_421: usize = 1; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_421] = [__v_0]; record.function_queries[421].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_421] = { let __args: [G; IN_421] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_421] = [__v_8]; record.function_queries[421].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_421] = [__v_0]; record.function_queries[421].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +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 __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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_422] = { let __args: [G; IN_422] = [__v_0, __v_9]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_421] = [__v_16]; record.function_queries[421].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_421] = [__v_14]; record.function_queries[421].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_422: usize = 2; const IN_422: usize = 2; const OUT_422: usize = 1; -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 __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_423] = { let __args: [G; IN_423] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_422] = [__v_7]; record.function_queries[422].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_7]; record.function_queries[422].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_422] = [__v_6]; record.function_queries[422].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_423: usize = 2; -const IN_423: usize = 2; +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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__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_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_306] = { let __args: [G; IN_306] = [__v_3, __v_1]; 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_50: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_50]; record.function_queries[422].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_422] = [__v_53]; record.function_queries[422].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_423: usize = 6; +const IN_423: usize = 6; 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 __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_424] = { let __args: [G; IN_424] = [__v_3, __v_1]; 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 __ret: [G; OUT_423] = [__v_6]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_423] = [__v_7]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_7]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_423] = [__v_7]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_7]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_423] = [__v_7]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_7]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_423] = [__v_7]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_423] = [__v_8]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_1]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_8]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, 8u64 => { let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_6]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_423] = [__v_6]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 = (__v_2 - __v_5); match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_423] = [__v_7]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_1, __v_5]; 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_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_424] = { let __args: [G; IN_424] = [__v_10, __v_3]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_20, __v_4]; 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_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); let __ret: [G; OUT_423] = [__v_22]; record.function_queries[423].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_423] = { let __args: [G; IN_423] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_24]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); let __ret: [G; OUT_423] = [__v_20]; record.function_queries[423].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_424: usize = 2; const IN_424: usize = 2; const OUT_424: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_424] = [__v_5]; record.function_queries[424].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_424] = [__v_6]; record.function_queries[424].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __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_6: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_6]; record.function_queries[424].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_424] = [__v_0]; record.function_queries[424].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_424] = { let __args: [G; IN_424] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_8]; record.function_queries[424].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_424] = [__v_0]; record.function_queries[424].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_425: usize = 2; const IN_425: usize = 2; const OUT_425: usize = 1; -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 __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() { 1u64 => { let __ret: [G; OUT_425] = [__v_0]; record.function_queries[425].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_425] = [__v_0]; record.function_queries[425].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_425] = [__v_0]; record.function_queries[425].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_425] = [__v_0]; record.function_queries[425].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_425] = [__v_0]; record.function_queries[425].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_6]; 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 __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_385] = { let __args: [G; IN_385] = [__v_0, __v_9, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_10]; record.function_queries[425].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __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_426] = { let __args: [G; IN_426] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_425] = [__v_7]; record.function_queries[425].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __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_7: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_7]; record.function_queries[425].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_425] = [__v_6]; record.function_queries[425].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_426: usize = 2; const IN_426: usize = 2; 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 = 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_385] = { let __args: [G; IN_385] = [__v_0, __v_3, __v_1]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_4]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __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_427] = { let __args: [G; IN_427] = [__v_3, __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_6: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_6]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_426] = [__v_7]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_7]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_426] = [__v_7]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_7]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_426] = [__v_7]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_7]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_426] = [__v_7]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); 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_426] = { let __args: [G; IN_426] = [__v_5, __v_1]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_8]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, 8u64 => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_6]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_426] = [__v_6]; record.function_queries[426].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_427: usize = 2; const IN_427: usize = 2; const OUT_427: usize = 1; -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 __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() { 1u64 => { let __ret: [G; OUT_427] = [__v_0]; record.function_queries[427].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_427] = [__v_0]; record.function_queries[427].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_427] = [__v_0]; record.function_queries[427].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_427] = [__v_0]; record.function_queries[427].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_427] = [__v_0]; record.function_queries[427].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_349] = { let __args: [G; IN_349] = [__v_0]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_7, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_427] = [__v_10]; record.function_queries[427].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_428: usize = 3; -const IN_428: usize = 3; +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 __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_427] = [__v_5]; record.function_queries[427].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_427] = [__v_6]; record.function_queries[427].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_0, __v_4]; 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 __ret: [G; OUT_427] = [__v_6]; record.function_queries[427].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_428: usize = 2; +const IN_428: usize = 2; const OUT_428: usize = 1; -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 __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() { 3u64 => { 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_9, __v_2]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_10]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { 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_383] = { let __args: [G; IN_383] = [__v_0, __v_1, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { 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_13: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_13]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_10, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_9, __v_14, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_15, __v_11, __v_2]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_16]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_9, __v_10, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_14, __v_11, __v_2]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_15]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_8, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_9]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_7]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_4, __v_5, __v_0, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_7]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_7: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_7]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_429: usize = 6; -const IN_429: usize = 6; +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 __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() { 1u64 => { let __ret: [G; OUT_428] = [__v_0]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_428] = [__v_0]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_428] = [__v_0]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_428] = [__v_0]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_428] = [__v_0]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_6]; 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_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 __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_9, __v_7]; 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 __ret: [G; OUT_428] = [__v_10]; record.function_queries[428].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_429: usize = 2; +const IN_429: usize = 2; 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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2, __v_4]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; 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_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 => { let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7]; 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_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() { 6u64 => { let __v_26: G = (__v_20 + __v_1); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_8, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_27, __v_3, __v_4]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_28]; record.function_queries[429].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_5, __v_3]; 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_26: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_26]; record.function_queries[429].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_5, __v_3]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_13]; record.function_queries[429].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_430: usize = 5; -const IN_430: usize = 5; +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 = 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_388] = { let __args: [G; IN_388] = [__v_0, __v_3, __v_1]; 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_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 = 2; +const IN_430: usize = 2; 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 = inp[4]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; 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_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() { 7u64 => { let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_9, __v_11, __v_12, __v_10]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_20, __v_4]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_21]; record.function_queries[430].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_21]; record.function_queries[430].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_18: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_18]; record.function_queries[430].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_431: usize = 2; -const IN_431: usize = 2; +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 __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() { 1u64 => { let __ret: [G; OUT_430] = [__v_0]; record.function_queries[430].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_430] = [__v_0]; record.function_queries[430].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_430] = [__v_0]; record.function_queries[430].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_430] = [__v_0]; record.function_queries[430].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_430] = [__v_0]; record.function_queries[430].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_352] = { let __args: [G; IN_352] = [__v_0]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_7, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_10]; 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 __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() { 1u64 => { let __ret: [G; OUT_431] = [__v_0]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_431] = [__v_0]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_431] = [__v_0]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_431] = [__v_0]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_431] = [__v_0]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_6]; 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 __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_433] = { let __args: [G; IN_433] = [__v_0, __v_9, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(433, (&__args[..]))?) { [G::ZERO; OUT_433] } else { let (__hash, __hit) = record.function_queries[433].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[433].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[433].bump_multiplicity(__i); } let __ret: [G; OUT_433] = unsafe { (*(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433])) }; __ret }, _ => { aiur_fn_433::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_10]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_432: usize = 2; -const IN_432: usize = 2; +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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_9, __v_2]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_10]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { 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_386] = { let __args: [G; IN_386] = [__v_0, __v_1, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1]; 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 __ret: [G; OUT_431] = [__v_13]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_10, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_9, __v_14, __v_13]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_15, __v_11, __v_2]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_16]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_9, __v_10, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_14, __v_11, __v_2]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_15]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_6, __v_5, __v_7]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_8, __v_1, __v_2]; 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_431] = [__v_9]; record.function_queries[431].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; 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); }, 2u64 => { let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(433, (&__args[..]))?) { [G::ZERO; OUT_433] } else { let (__hash, __hit) = record.function_queries[433].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[433].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[433].bump_multiplicity(__i); } let __ret: [G; OUT_433] = unsafe { (*(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433])) }; __ret }, _ => { aiur_fn_433::(__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); }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1]; 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_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); }, } }) } +const INPUT_SIZE_432: usize = 6; +const IN_432: usize = 6; 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 = 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_433] = { let __args: [G; IN_433] = [__v_0, __v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(433, (&__args[..]))?) { [G::ZERO; OUT_433] } else { let (__hash, __hit) = record.function_queries[433].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[433].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[433].bump_multiplicity(__i); } let __ret: [G; OUT_433] = unsafe { (*(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433])) }; __ret }, _ => { aiur_fn_433::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_432] = [__v_4]; record.function_queries[432].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_433: usize = 3; -const IN_433: usize = 3; +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 __v_5: G = inp[5]; let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_2, __v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_6]; 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_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 => { let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_7]; 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_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() { 6u64 => { let __v_26: G = (__v_20 + __v_1); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_8, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_27, __v_3, __v_4]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_432] = [__v_28]; record.function_queries[432].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_5, __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_26: G = __r_arr[0]; let __ret: [G; OUT_432] = [__v_26]; record.function_queries[432].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_5, __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_13: G = __r_arr[0]; let __ret: [G; OUT_432] = [__v_13]; record.function_queries[432].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_433: usize = 5; +const IN_433: usize = 5; 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 __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() { 3u64 => { 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(433, (&__args[..]))?) { [G::ZERO; OUT_433] } else { let (__hash, __hit) = record.function_queries[433].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[433].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[433].bump_multiplicity(__i); } let __ret: [G; OUT_433] = unsafe { (*(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433])) }; __ret }, _ => { aiur_fn_433::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_10]; record.function_queries[433].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_1, __v_0, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_7]; record.function_queries[433].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_4, __v_5, __v_0, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_7]; record.function_queries[433].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(433, (&__args[..]))?) { [G::ZERO; OUT_433] } else { let (__hash, __hit) = record.function_queries[433].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[433].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[433].bump_multiplicity(__i); } let __ret: [G; OUT_433] = unsafe { (*(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433])) }; __ret }, _ => { aiur_fn_433::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_9]; record.function_queries[433].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(435, (&__args[..]))?) { [G::ZERO; OUT_435] } else { let (__hash, __hit) = record.function_queries[435].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[435].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { (*(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435])) }; __ret }, _ => { aiur_fn_435::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_7]; record.function_queries[433].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_7: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_7]; record.function_queries[433].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_434: usize = 3; -const IN_434: usize = 3; +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 __v_4: G = inp[4]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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() { 7u64 => { let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_8, __v_9, __v_11, __v_12, __v_10]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_20, __v_4]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_21]; record.function_queries[433].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_21: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_21]; record.function_queries[433].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_18: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_18]; 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 = 1; -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 __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_383] = { let __args: [G; IN_383] = [__v_1, __v_0, __v_4]; 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 __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_1, __v_0]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_434] = [__v_9]; record.function_queries[434].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_6, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_10, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_11, __v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(433, (&__args[..]))?) { [G::ZERO; OUT_433] } else { let (__hash, __hit) = record.function_queries[433].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[433].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[433].bump_multiplicity(__i); } let __ret: [G; OUT_433] = unsafe { (*(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433])) }; __ret }, _ => { aiur_fn_433::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_434] = [__v_12]; record.function_queries[434].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_5, __v_6, __v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_10, __v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(433, (&__args[..]))?) { [G::ZERO; OUT_433] } else { let (__hash, __hit) = record.function_queries[433].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[433].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[433].bump_multiplicity(__i); } let __ret: [G; OUT_433] = unsafe { (*(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433])) }; __ret }, _ => { aiur_fn_433::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_434] = [__v_11]; record.function_queries[434].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_435: usize = 5; -const IN_435: usize = 5; +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; 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() { 1u64 => { let __ret: [G; OUT_434] = [__v_0]; record.function_queries[434].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_434] = [__v_0]; record.function_queries[434].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_434] = [__v_0]; record.function_queries[434].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_434] = [__v_0]; record.function_queries[434].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_434] = [__v_0]; record.function_queries[434].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_6]; 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_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 __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_9, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_434] = [__v_10]; record.function_queries[434].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_435: usize = 2; +const IN_435: usize = 2; 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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_2, __v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1, __v_7, __v_8]; 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 __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(433, (&__args[..]))?) { [G::ZERO; OUT_433] } else { let (__hash, __hit) = record.function_queries[433].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[433].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[433].bump_multiplicity(__i); } let __ret: [G; OUT_433] = unsafe { (*(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433])) }; __ret }, _ => { aiur_fn_433::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_435] = [__v_11]; record.function_queries[435].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_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_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_394] = { let __args: [G; IN_394] = [__v_7]; 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_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() { 6u64 => { let __v_28: G = (__v_22 + __v_1); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_8, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(433, (&__args[..]))?) { [G::ZERO; OUT_433] } else { let (__hash, __hit) = record.function_queries[433].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[433].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[433].bump_multiplicity(__i); } let __ret: [G; OUT_433] = unsafe { (*(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433])) }; __ret }, _ => { aiur_fn_433::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_435] = [__v_30]; record.function_queries[435].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_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_263] = { let __args: [G; IN_263] = [__v_29, __v_3]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_435] = [__v_30]; record.function_queries[435].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_263] = { let __args: [G; IN_263] = [__v_16, __v_3]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_435] = [__v_17]; record.function_queries[435].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_436: usize = 5; -const IN_436: usize = 5; +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 = 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_436] = { let __args: [G; IN_436] = [__v_0, __v_3, __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_4: G = __r_arr[0]; let __ret: [G; OUT_435] = [__v_4]; record.function_queries[435].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_436: usize = 3; +const IN_436: usize = 3; const OUT_436: usize = 1; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0]; 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_5: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_6]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0, __v_1, __v_3, __v_4]; 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 __v_9: G = __r_arr[1]; break '__mc_0 [__v_8, __v_9]; }, _ => { 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]; }, } }, _ => { let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0, __v_1, __v_3, __v_4]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; break '__mc_0 [__v_6, __v_7]; }, } }; let __v_6: G = __mc_out___mc_0[0]; let __v_7: G = __mc_out___mc_0[1]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_4]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_8]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_436] = [__v_7]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; 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_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_405] = { let __args: [G; IN_405] = [__v_12, __v_3]; 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 __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_22, __v_4]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_23]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_23]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_22, __v_4]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_23]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_23]; record.function_queries[436].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_1: [G; 2] = '__mc_1: { match __v_17.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_11, __v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; break '__mc_1 [__v_26, __v_27]; }, _ => { let __v_24: G = G::from_u64(0); break '__mc_1 [__v_24, __v_2]; }, } }; let __v_24: G = __mc_out___mc_1[0]; let __v_25: G = __mc_out___mc_1[1]; match __v_24.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_436] = [__v_25]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_11, __v_12, __v_14, __v_15, __v_13]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; 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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_28, __v_4]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_29]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_436] = [__v_28]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_30, __v_4]; 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_31: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_31]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_436] = [__v_28]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_29]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_21]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_437: usize = 2; -const IN_437: 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 __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() { 3u64 => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_7, __v_9, __v_2]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_10]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_1, __v_0, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_7]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_5, __v_0, __v_1, __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_7: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_7]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_6, __v_5, __v_7]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_8, __v_1, __v_2]; 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 __ret: [G; OUT_436] = [__v_9]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_7]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_7]; record.function_queries[436].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_437: usize = 3; +const IN_437: usize = 3; 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 __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_366] = { let __args: [G; IN_366] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_6]; record.function_queries[437].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_438: usize = 12; -const IN_438: usize = 12; +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 = 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_386] = { let __args: [G; IN_386] = [__v_1, __v_0, __v_4]; 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 = __r_arr[1]; let __v_7: G = __r_arr[2]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_1, __v_0]; 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_437] = [__v_9]; record.function_queries[437].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_6, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __v_10, __v_9]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_11, __v_7, __v_2]; 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 __ret: [G; OUT_437] = [__v_12]; record.function_queries[437].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_5, __v_6, __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 __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_10, __v_7, __v_2]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_11]; 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 __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_438] = [__v_1]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_438] = [__v_1]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_438] = [__v_1]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_438] = [__v_1]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_438] = [__v_1]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_438] = [__v_1]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_438] = [__v_1]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_438] = [__v_1]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_439: usize = 12; -const IN_439: usize = 12; +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_434] = { let __args: [G; IN_434] = [__v_2, __v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_5, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_1, __v_7, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_10, __v_3, __v_4]; 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_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 __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_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_397] = { let __args: [G; IN_397] = [__v_7]; 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_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() { 6u64 => { let __v_28: G = (__v_22 + __v_1); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_8, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_29, __v_3, __v_4]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_438] = [__v_30]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_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_266] = { let __args: [G; IN_266] = [__v_29, __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_30: G = __r_arr[0]; let __ret: [G; OUT_438] = [__v_30]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_266] = { let __args: [G; IN_266] = [__v_16, __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_17: G = __r_arr[0]; let __ret: [G; OUT_438] = [__v_17]; record.function_queries[438].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_439: usize = 5; +const IN_439: usize = 5; 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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_439] = [__v_2]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_439] = [__v_2]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_439] = [__v_2]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_439] = [__v_2]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_439] = [__v_2]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_439] = [__v_2]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_439] = [__v_2]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_439] = [__v_2]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +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 __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_401] = { let __args: [G; IN_401] = [__v_0]; 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_5: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_6: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_6]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_0, __v_1, __v_3, __v_4]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; break '__mc_0 [__v_8, __v_9]; }, _ => { 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]; }, } }, _ => { let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_0, __v_1, __v_3, __v_4]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; break '__mc_0 [__v_6, __v_7]; }, } }; let __v_6: G = __mc_out___mc_0[0]; let __v_7: G = __mc_out___mc_0[1]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_7, __v_4]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_8]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_439] = [__v_7]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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_408] = { let __args: [G; IN_408] = [__v_12, __v_3]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_22, __v_4]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_23]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_23: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_23]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_3, __v_4]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_22, __v_4]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_23]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_23: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_23]; record.function_queries[439].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_1: [G; 2] = '__mc_1: { match __v_17.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_11, __v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; break '__mc_1 [__v_26, __v_27]; }, _ => { let __v_24: G = G::from_u64(0); break '__mc_1 [__v_24, __v_2]; }, } }; let __v_24: G = __mc_out___mc_1[0]; let __v_25: G = __mc_out___mc_1[1]; match __v_24.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_439] = [__v_25]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_11, __v_12, __v_14, __v_15, __v_13]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; 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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_28, __v_4]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_29]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_439] = [__v_28]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_30, __v_4]; 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_31: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_31]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_439] = [__v_28]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_29: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_29]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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_21: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_21]; record.function_queries[439].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_440: usize = 2; const IN_440: usize = 2; 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 __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_2]; 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_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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_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 __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_5 + __v_9); let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_440] = [__v_12]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_8, __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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_8, __v_11, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_440] = [__v_12]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_5]; 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_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_438] = { let __args: [G; IN_438] = [__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(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_21: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; if (__v_22 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__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(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_23: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_23, __v_6]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_440] = [__v_24]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_3]; 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_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 __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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); }, _ => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_3]; 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_13: 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_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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_440] = [__v_19]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, } }, 4u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __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_440] = { let __args: [G; IN_440] = [__v_6, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(5); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __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_440] = [__v_12]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_3]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_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_442] = { let __args: [G; IN_442] = [__v_6, __v_10]; 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 __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_8, __v_11]; 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_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_12, __v_13, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_440] = [__v_14]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_9, __v_3]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_440] = [__v_10]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(389, (&__args[..]))?) { [G::ZERO; OUT_389] } else { let (__hash, __hit) = record.function_queries[389].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[389].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[389].bump_multiplicity(__i); } let __ret: [G; OUT_389] = unsafe { (*(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389])) }; __ret }, _ => { aiur_fn_389::(__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_8, __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_440] = [__v_13]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = []; 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_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_8, __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_440] = [__v_13]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 8u64 => { let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_7, __v_3]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_3]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9]; 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 __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 => { if (__v_13 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) }); } let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_13]; 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_16: 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_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: 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_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; let __v_25: G = __loaded[8]; let __v_26: G = __loaded[9]; let __v_27: G = __loaded[10]; let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 5u64 => { let __v_29: G = G::from_u64(1); if (__v_22 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) }); } let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_24, __v_25, __v_30]; 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_31: 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_31.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_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]; let __v_38: G = __loaded[6]; let __v_39: G = __loaded[7]; let __v_40: G = __loaded[8]; let __v_41: G = __loaded[9]; let __v_42: G = __loaded[10]; let __v_43: G = __loaded[11]; match __v_32.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_34, __v_14]; 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_44: G = __r_arr[0]; let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_44, __v_11, __v_20]; 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_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_45, __v_6, __v_46, __v_5, __v_7]; 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_47: G = __r_arr[0]; let __ret: [G; OUT_440] = [__v_47]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_441: usize = 2; -const IN_441: usize = 2; +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 __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_369] = { let __args: [G; IN_369] = [__v_2, __v_4, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_440] = [__v_6]; record.function_queries[440].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_441: usize = 12; +const IN_441: usize = 12; const OUT_441: usize = 1; -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]; 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_789] = { let __args: [G; IN_789] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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 __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_10]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 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_6, __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_341] = { let __args: [G; IN_341] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __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 __ret: [G; OUT_441] = [__v_10]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3]; 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_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]; let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__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(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_19: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__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(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_21: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_21, __v_4]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_22]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_3, __v_1]; 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_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 __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_12]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_6, __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_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_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_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() { 5u64 => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_17]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, } }, 4u64 => { 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_440] = { let __args: [G; IN_440] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_3, __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_441] = [__v_10]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __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_442] = { let __args: [G; IN_442] = [__v_4, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6, __v_9]; 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_11: G = __r_arr[0]; 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 __ret: [G; OUT_441] = [__v_12]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_7, __v_1]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_8]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(2); let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(389, (&__args[..]))?) { [G::ZERO; OUT_389] } else { let (__hash, __hit) = record.function_queries[389].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[389].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[389].bump_multiplicity(__i); } let __ret: [G; OUT_389] = unsafe { (*(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389])) }; __ret }, _ => { aiur_fn_389::(__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_6, __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 __ret: [G; OUT_441] = [__v_11]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(2); let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = []; 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_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_6, __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 __ret: [G; OUT_441] = [__v_11]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, 8u64 => { let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_6, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_7]; 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_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 => { if (__v_11 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".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_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() { 5u64 => { let __v_27: G = G::from_u64(1); if (__v_20 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) }); } let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_22, __v_23, __v_28]; 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_29: 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_29.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_30: G = __loaded[0]; let __v_31: G = __loaded[1]; let __v_32: G = __loaded[2]; let __v_33: G = __loaded[3]; let __v_34: G = __loaded[4]; let __v_35: G = __loaded[5]; let __v_36: G = __loaded[6]; let __v_37: G = __loaded[7]; let __v_38: G = __loaded[8]; let __v_39: G = __loaded[9]; let __v_40: G = __loaded[10]; let __v_41: G = __loaded[11]; match __v_30.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_32, __v_12]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_42, __v_9, __v_18]; 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_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_43, __v_4, __v_44, __v_3, __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_45: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_45]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_30.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_442: usize = 2; -const IN_442: usize = 2; +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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_441] = [__v_1]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_441] = [__v_1]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_441] = [__v_1]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_441] = [__v_1]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_441] = [__v_1]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_441] = [__v_1]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_441] = [__v_1]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_441] = [__v_1]; record.function_queries[441].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_442: usize = 12; +const IN_442: usize = 12; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1]; 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_2: 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_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() { 1u64 => { let __ret: [G; OUT_442] = [__v_4]; record.function_queries[442].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_2, __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_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() { 1u64 => { let __ret: [G; OUT_442] = [__v_9]; record.function_queries[442].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_443: usize = 3; -const IN_443: usize = 3; +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 __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_442] = [__v_2]; record.function_queries[442].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_442] = [__v_2]; record.function_queries[442].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_442] = [__v_2]; record.function_queries[442].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_442] = [__v_2]; record.function_queries[442].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_442] = [__v_2]; record.function_queries[442].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_442] = [__v_2]; record.function_queries[442].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_442] = [__v_2]; record.function_queries[442].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_442] = [__v_2]; record.function_queries[442].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_443: usize = 2; +const IN_443: usize = 2; 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]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_443] = [__v_0]; record.function_queries[443].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_375] = { let __args: [G; IN_375] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_443] = { let __args: [G; IN_443] = [__v_11, __v_9, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_443] = [__v_14]; record.function_queries[443].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_444: usize = 5; -const IN_444: usize = 5; +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 __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_2]; 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_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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_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 __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_5 + __v_9); let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_8, __v_10, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_443] = [__v_12]; record.function_queries[443].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_8, __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 __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_8, __v_11, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_443] = [__v_12]; record.function_queries[443].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__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_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_441] = { let __args: [G; IN_441] = [__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(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_21: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; if (__v_22 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__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(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_23: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_23, __v_6]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_443] = [__v_24]; record.function_queries[443].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_3]; 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_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 __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_11, __v_6, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_443] = [__v_14]; record.function_queries[443].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_8, __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_13: 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_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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_16, __v_6, __v_18]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_443] = [__v_19]; record.function_queries[443].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, } }, 4u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __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_443] = { let __args: [G; IN_443] = [__v_6, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(5); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __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_443] = [__v_12]; record.function_queries[443].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_5, __v_3]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_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_445] = { let __args: [G; IN_445] = [__v_6, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_8, __v_11]; 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_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_12, __v_13, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_443] = [__v_14]; record.function_queries[443].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_7, __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_9: G = __r_arr[0]; let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_3]; 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_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); }, 7u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = []; 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_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_8, __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_443] = [__v_13]; record.function_queries[443].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = []; 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_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_8, __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_443] = [__v_13]; record.function_queries[443].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 8u64 => { let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_7, __v_3]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_8, __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_9: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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_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 => { if (__v_13 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) }); } let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_13]; 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_16: 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_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: 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_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; let __v_25: G = __loaded[8]; let __v_26: G = __loaded[9]; let __v_27: G = __loaded[10]; let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 5u64 => { let __v_29: G = G::from_u64(1); if (__v_22 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) }); } let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_24, __v_25, __v_30]; 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_31: 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_31.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_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]; let __v_38: G = __loaded[6]; let __v_39: G = __loaded[7]; let __v_40: G = __loaded[8]; let __v_41: G = __loaded[9]; let __v_42: G = __loaded[10]; let __v_43: G = __loaded[11]; match __v_32.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_34, __v_14]; 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_44: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_44, __v_11, __v_20]; 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_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_45, __v_6, __v_46, __v_5, __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 __v_47: G = __r_arr[0]; let __ret: [G; OUT_443] = [__v_47]; record.function_queries[443].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_444: usize = 2; +const IN_444: usize = 2; 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]; 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_444] = [__v_6]; record.function_queries[444].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_375] = { let __args: [G; IN_375] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_444] = { let __args: [G; IN_444] = [__v_13, __v_1, __v_15, __v_3, __v_4]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_444] = [__v_16]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +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 __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_792] = { let __args: [G; IN_792] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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 __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_6, __v_8, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_444] = [__v_10]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 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_6, __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_344] = { let __args: [G; IN_344] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __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 __ret: [G; OUT_444] = [__v_10]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__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_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]; let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__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(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_19: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__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(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_21: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_21, __v_4]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_444] = [__v_22]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_1]; 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_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 __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_9, __v_4, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_444] = [__v_12]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_6, __v_1]; 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_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_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_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() { 5u64 => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_14, __v_4, __v_16]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_444] = [__v_17]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, } }, 4u64 => { 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_443] = { let __args: [G; IN_443] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_3, __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_444] = [__v_10]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __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_445] = { let __args: [G; IN_445] = [__v_4, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __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_11: G = __r_arr[0]; 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 __ret: [G; OUT_444] = [__v_12]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_7, __v_1]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_444] = [__v_8]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(2); let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = []; 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_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_6, __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 __ret: [G; OUT_444] = [__v_11]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(2); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = []; 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_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_6, __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 __ret: [G; OUT_444] = [__v_11]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, 8u64 => { let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_6, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_7]; 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_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 => { if (__v_11 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) }); } let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_11]; 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_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() { 5u64 => { let __v_27: G = G::from_u64(1); if (__v_20 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) }); } let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_22, __v_23, __v_28]; 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_29: 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_29.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_30: G = __loaded[0]; let __v_31: G = __loaded[1]; let __v_32: G = __loaded[2]; let __v_33: G = __loaded[3]; let __v_34: G = __loaded[4]; let __v_35: G = __loaded[5]; let __v_36: G = __loaded[6]; let __v_37: G = __loaded[7]; let __v_38: G = __loaded[8]; let __v_39: G = __loaded[9]; let __v_40: G = __loaded[10]; let __v_41: G = __loaded[11]; match __v_30.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_32, __v_12]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_42, __v_9, __v_18]; 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_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_43, __v_4, __v_44, __v_3, __v_5]; 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 __v_45: G = __r_arr[0]; let __ret: [G; OUT_444] = [__v_45]; record.function_queries[444].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_30.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_445: usize = 2; const IN_445: usize = 2; 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 __loaded: [G; 3] = { let __base = 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_445] = [__v_8]; record.function_queries[445].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_445] = [__v_8]; record.function_queries[445].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_445] = [__v_8]; record.function_queries[445].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_445] = [__v_9]; record.function_queries[445].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_445] = [__v_9]; record.function_queries[445].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_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 __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1]; 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_2: 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_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() { 1u64 => { let __ret: [G; OUT_445] = [__v_4]; record.function_queries[445].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_1]; 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_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() { 1u64 => { let __ret: [G; OUT_445] = [__v_9]; record.function_queries[445].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_446: usize = 3; const IN_446: usize = 3; 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 = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); 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_349] = { let __args: [G; IN_349] = [__v_0]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_1]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { 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_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_446] = [__v_9]; record.function_queries[446].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_2, __v_6]; 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 __v_7: G = __r_arr[0]; let __ret: [G; OUT_446] = [__v_7]; 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; +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]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_446] = [__v_0]; record.function_queries[446].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_378] = { let __args: [G; IN_378] = [__v_5, __v_8, __v_10]; 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_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_446] = { let __args: [G; IN_446] = [__v_11, __v_9, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_446] = [__v_14]; record.function_queries[446].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_447: usize = 5; +const IN_447: usize = 5; const OUT_447: usize = 1; -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]; let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_1, __v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_5, __v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_7, __v_8]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__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_10: G = __r_arr[0]; let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_10]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_447] = [__v_11]; record.function_queries[447].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_9, __v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_1, __v_9, __v_10]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_3 - __v_9); let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_13, __v_14]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_11, __v_12, __v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_447] = [__v_16]; record.function_queries[447].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_448: usize = 3; -const IN_448: usize = 3; +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]; 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_447] = [__v_6]; record.function_queries[447].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_378] = { let __args: [G; IN_378] = [__v_7, __v_11, __v_12]; 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_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_447] = { let __args: [G; IN_447] = [__v_13, __v_1, __v_15, __v_3, __v_4]; 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 __v_16: G = __r_arr[0]; let __ret: [G; OUT_447] = [__v_16]; record.function_queries[447].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +const INPUT_SIZE_448: usize = 2; +const IN_448: usize = 2; const OUT_448: usize = 1; -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 = { 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 __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_1, __v_2]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_448] = [__v_4]; record.function_queries[448].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_1, __v_0, __v_2]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_448] = [__v_4]; record.function_queries[448].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_448] = [__v_8]; record.function_queries[448].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_448] = [__v_8]; record.function_queries[448].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_448] = [__v_8]; record.function_queries[448].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_448] = [__v_9]; record.function_queries[448].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_4, __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_9: G = __r_arr[0]; let __ret: [G; OUT_448] = [__v_9]; record.function_queries[448].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_449: usize = 3; const IN_449: usize = 3; 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 __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_449] = [__v_4]; record.function_queries[449].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_2]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_449] = [__v_4]; record.function_queries[449].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_450: usize = 3; -const IN_450: usize = 3; +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 = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_449] = [__v_4]; record.function_queries[449].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_1]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { 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_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_8]; 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_9: G = __r_arr[0]; 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_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_2, __v_6]; 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_449] = [__v_7]; record.function_queries[449].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_450: usize = 4; +const IN_450: usize = 4; 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 __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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; 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_5: G = __r_arr[0]; let __v_6: 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_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 __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_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 __v_15: G = (__v_8 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_9, __v_13]; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_450] = [__v_17]; record.function_queries[450].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_4, __v_6, __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_20: G = __r_arr[0]; let __ret: [G; OUT_450] = [__v_20]; record.function_queries[450].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_450] = [__v_20]; record.function_queries[450].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_450] = [__v_16]; record.function_queries[450].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_450] = [__v_15]; record.function_queries[450].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_450] = [__v_11]; record.function_queries[450].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 = G::from_u64(0); let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__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_6: G = __r_arr[0]; let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_5, __v_6]; 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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_7, __v_8]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__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_10: G = __r_arr[0]; let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_10]; 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 __ret: [G; OUT_450] = [__v_11]; record.function_queries[450].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_9, __v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_1, __v_9, __v_10]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_3 - __v_9); let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_13, __v_14]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_11, __v_12, __v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_450] = [__v_16]; record.function_queries[450].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } 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 __loaded: [G; 3] = { let __base = 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 __loaded: [G; 3] = { let __base = 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(1); let __ret: [G; OUT_451] = [__v_9]; record.function_queries[451].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_451] = [__v_9]; record.function_queries[451].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_451] = [__v_9]; record.function_queries[451].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_4, __v_7, __v_2]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_451] = [__v_10]; record.function_queries[451].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_5, __v_8, __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_10: G = __r_arr[0]; let __ret: [G; OUT_451] = [__v_10]; record.function_queries[451].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_452: usize = 1; -const IN_452: 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 __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 __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __v_2]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_451] = [__v_4]; record.function_queries[451].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_1, __v_0, __v_2]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_451] = [__v_4]; record.function_queries[451].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_452: usize = 3; +const IN_452: usize = 3; const OUT_452: usize = 1; -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 __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() { 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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]; let __ret: [G; OUT_452] = [__v_5]; record.function_queries[452].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_452] = [__v_5]; record.function_queries[452].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __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_6: G = __r_arr[0]; let __ret: [G; OUT_452] = [__v_6]; record.function_queries[452].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_452] = [__v_5]; record.function_queries[452].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_453: usize = 1; -const IN_453: usize = 1; -const OUT_453: usize = 3; -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 __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() { 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { 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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_453] = [__v_5, __v_7, __v_3]; record.function_queries[453].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; 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 __ret: [G; OUT_453] = [__v_5, __v_0, __v_7]; record.function_queries[453].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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_3]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_453] = [__v_14, __v_12, __v_15]; record.function_queries[453].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_453] = [__v_11, __v_0, __v_13]; record.function_queries[453].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_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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __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 __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_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() { 0u64 => { let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_7]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_21, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_453] = [__v_22, __v_20, __v_23]; record.function_queries[453].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __ret: [G; OUT_453] = [__v_22, __v_7, __v_17]; record.function_queries[453].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__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(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_453] = [__v_19, __v_0, __v_21]; record.function_queries[453].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__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(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_453] = [__v_19, __v_0, __v_21]; record.function_queries[453].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(1); let __v_17: G = { let __values: [G; 10] = [__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(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_453] = [__v_15, __v_0, __v_17]; record.function_queries[453].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; 10] = [__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(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_453] = [__v_13, __v_0, __v_15]; 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 = 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_453] = [__v_9, __v_0, __v_11]; record.function_queries[453].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; 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 __ret: [G; OUT_453] = [__v_5, __v_0, __v_7]; record.function_queries[453].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_452] = [__v_4]; record.function_queries[452].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_452] = [__v_4]; record.function_queries[452].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_453: usize = 3; +const IN_453: usize = 3; +const OUT_453: usize = 1; +fn aiur_fn_453(inp: [G; IN_453], 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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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_5: G = __r_arr[0]; let __v_6: 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_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 __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_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 __v_15: G = (__v_8 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_9, __v_13]; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_453] = [__v_17]; record.function_queries[453].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_4, __v_6, __v_2]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_453] = [__v_20]; record.function_queries[453].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_453] = [__v_20]; record.function_queries[453].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_453] = [__v_16]; record.function_queries[453].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_453] = [__v_15]; record.function_queries[453].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_453] = [__v_11]; 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 __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_1]; 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_4: G = __r_arr[0]; let __v_5: G = (__v_3 * __v_4); match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_454] = [__v_6, __v_6]; record.function_queries[454].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __v_12: G = (__v_6 * __v_9); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_454] = [__v_13, __v_13]; record.function_queries[454].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_8, __v_11]; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_454] = [__v_14, __v_14]; record.function_queries[454].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_7, __v_10, __v_2]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_454] = [__v_14, __v_15]; record.function_queries[454].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_455: usize = 3; -const IN_455: usize = 3; +const OUT_454: usize = 1; +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 __loaded: [G; 3] = { let __base = 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 __loaded: [G; 3] = { let __base = 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(1); let __ret: [G; OUT_454] = [__v_9]; record.function_queries[454].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_454] = [__v_9]; record.function_queries[454].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_454] = [__v_9]; record.function_queries[454].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_4, __v_7, __v_2]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_454] = [__v_10]; record.function_queries[454].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_8, __v_2]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_454] = [__v_10]; record.function_queries[454].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_455: usize = 1; +const IN_455: usize = 1; const OUT_455: usize = 1; -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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_455] = [__v_4]; record.function_queries[455].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_1, __v_0, __v_2]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_455] = [__v_4]; record.function_queries[455].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_456: usize = 3; -const IN_456: usize = 3; -const OUT_456: usize = 1; -fn aiur_fn_456(inp: [G; IN_456], 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 __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() { 7u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__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_7: G = __r_arr[0]; let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_7, __v_2]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_8, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_456] = [__v_9]; record.function_queries[456].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_456] = [__v_7]; record.function_queries[456].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_456] = [__v_7]; record.function_queries[456].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __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() { 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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]; let __ret: [G; OUT_455] = [__v_5]; record.function_queries[455].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_455] = [__v_5]; record.function_queries[455].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; 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_2] = { let __args: [G; IN_2] = [__v_2, __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_6: G = __r_arr[0]; let __ret: [G; OUT_455] = [__v_6]; record.function_queries[455].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_455] = [__v_5]; record.function_queries[455].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_456: usize = 1; +const IN_456: usize = 1; +const OUT_456: usize = 3; +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 __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() { 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { 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 __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_456] = [__v_5, __v_7, __v_3]; record.function_queries[456].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; 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 __ret: [G; OUT_456] = [__v_5, __v_0, __v_7]; record.function_queries[456].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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_3]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_456] = [__v_14, __v_12, __v_15]; record.function_queries[456].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_456] = [__v_11, __v_0, __v_13]; record.function_queries[456].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_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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __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 __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_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() { 0u64 => { let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_21, __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_23: G = __r_arr[0]; let __ret: [G; OUT_456] = [__v_22, __v_20, __v_23]; record.function_queries[456].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __ret: [G; OUT_456] = [__v_22, __v_7, __v_17]; record.function_queries[456].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__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(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_456] = [__v_19, __v_0, __v_21]; record.function_queries[456].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__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(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_456] = [__v_19, __v_0, __v_21]; record.function_queries[456].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(1); let __v_17: G = { let __values: [G; 10] = [__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(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_456] = [__v_15, __v_0, __v_17]; record.function_queries[456].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; 10] = [__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(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_456] = [__v_13, __v_0, __v_15]; record.function_queries[456].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_456] = [__v_9, __v_0, __v_11]; record.function_queries[456].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; 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 __ret: [G; OUT_456] = [__v_5, __v_0, __v_7]; record.function_queries[456].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_457: usize = 3; const IN_457: usize = 3; -const OUT_457: usize = 1; -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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); break '__mc_0 [__v_4]; }, _ => { let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_1, __v_0, __v_2]; 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_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, } }; let __v_4: G = __mc_out___mc_0[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_457] = [__v_5]; record.function_queries[457].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_457] = [__v_5]; record.function_queries[457].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_1]; 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_4: G = __r_arr[0]; let __v_5: G = (__v_3 * __v_4); match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_457] = [__v_6, __v_6]; record.function_queries[457].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_1]; 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 __v_11: G = __r_arr[2]; let __v_12: G = (__v_6 * __v_9); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_457] = [__v_13, __v_13]; record.function_queries[457].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_8, __v_11]; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_457] = [__v_14, __v_14]; record.function_queries[457].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_7, __v_10, __v_2]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_457] = [__v_14, __v_15]; record.function_queries[457].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } const INPUT_SIZE_458: usize = 3; const IN_458: usize = 3; 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 __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_0, __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_3: G = __r_arr[0]; let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1, __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_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_458] = [__v_6]; record.function_queries[458].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_3, __v_4, __v_2]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_458] = [__v_7]; record.function_queries[458].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_4, __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]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_458] = [__v_8]; record.function_queries[458].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_3, __v_4, __v_2]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_458] = [__v_8]; record.function_queries[458].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_459: usize = 5; -const IN_459: usize = 5; +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 __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { 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_459] = { let __args: [G; IN_459] = [__v_1, __v_0, __v_2]; 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_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 = 3; +const IN_459: usize = 3; 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 = inp[4]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_2, __v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_3, __v_4]; 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 __v_7: G = (__v_5 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_459] = [__v_8]; record.function_queries[459].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_5, __v_6, __v_4]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_459] = [__v_9]; record.function_queries[459].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_5, __v_6, __v_4]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_459] = [__v_10]; record.function_queries[459].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_5, __v_6, __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_10: G = __r_arr[0]; let __ret: [G; OUT_459] = [__v_10]; record.function_queries[459].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +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 __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() { 7u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_8, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_459] = [__v_9]; record.function_queries[459].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_459] = [__v_7]; record.function_queries[459].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_459] = [__v_7]; record.function_queries[459].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_460: usize = 3; const IN_460: usize = 3; 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 __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() { 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_332] = { let __args: [G; IN_332] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_460] = [__v_11]; record.function_queries[460].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_460] = [__v_11]; record.function_queries[460].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_446] = { let __args: [G; IN_446] = [__v_4, __v_8, __v_2]; 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_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_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_446] = { let __args: [G; IN_446] = [__v_5, __v_9, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_460] = [__v_14]; record.function_queries[460].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_460] = [__v_12]; record.function_queries[460].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_460] = [__v_11]; record.function_queries[460].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_446] = { let __args: [G; IN_446] = [__v_4, __v_8, __v_2]; 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_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_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_446] = { let __args: [G; IN_446] = [__v_5, __v_9, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_460] = [__v_14]; record.function_queries[460].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_460] = [__v_12]; record.function_queries[460].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_460] = [__v_11]; record.function_queries[460].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_460] = [__v_7]; record.function_queries[460].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_461: usize = 5; -const IN_461: usize = 5; +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 __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); break '__mc_0 [__v_4]; }, _ => { let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_1, __v_0, __v_2]; 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_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, } }; let __v_4: G = __mc_out___mc_0[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_460] = [__v_5]; record.function_queries[460].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_460] = [__v_5]; record.function_queries[460].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_461: usize = 3; +const IN_461: usize = 3; const OUT_461: usize = 1; -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 __v_4: G = inp[4]; let __v_5: G = (__v_2 - __v_3); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_461] = [__v_6]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_3, __v_4]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_461] = [__v_7]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_461] = [__v_8]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_2, __v_3, __v_4]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_461] = [__v_9]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_3, __v_2, __v_4]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_461] = [__v_10]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_2, __v_3, __v_4]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_461] = [__v_11]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(16); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_2, __v_3, __v_12, __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_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_461] = [__v_16]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_14, __v_15, __v_4]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_461] = [__v_16]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }) } +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 __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_1, __v_2]; 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 __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_461] = [__v_6]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_3, __v_4, __v_2]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_461] = [__v_7]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_3, __v_4, __v_2]; 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]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_461] = [__v_8]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_3, __v_4, __v_2]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_461] = [__v_8]; record.function_queries[461].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } const INPUT_SIZE_462: usize = 5; const IN_462: usize = 5; const OUT_462: usize = 1; -fn aiur_fn_462(inp: [G; IN_462], 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 __v_1: G = 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(8); let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_2, __v_3, __v_5, __v_4]; 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_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 __ret: [G; OUT_462] = [__v_8]; record.function_queries[462].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_2, __v_3, __v_4]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_462] = [__v_9]; record.function_queries[462].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __v_4]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_462] = [__v_9]; record.function_queries[462].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +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 __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_434] = { let __args: [G; IN_434] = [__v_2, __v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_3, __v_4]; 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_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_462] = [__v_8]; record.function_queries[462].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_5, __v_6, __v_4]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_462] = [__v_9]; record.function_queries[462].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_6, __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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_462] = [__v_10]; record.function_queries[462].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_5, __v_6, __v_4]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_462] = [__v_10]; record.function_queries[462].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } const INPUT_SIZE_463: usize = 3; const IN_463: usize = 3; const OUT_463: usize = 1; -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 __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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_463] = [__v_8]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 - __v_9); match __v_10.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_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_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() { 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_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() { 8u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __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_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { let __v_20: G = (__v_13 - __v_17); match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_14, __v_18, __v_2]; 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_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_4, __v_6, __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_22: G = __r_arr[0]; let __ret: [G; OUT_463] = [__v_22]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_22]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_21]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_20]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_19]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_15]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_11]; 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; +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 __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() { 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_335] = { let __args: [G; IN_335] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_463] = [__v_11]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_11]; record.function_queries[463].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_449] = { let __args: [G; IN_449] = [__v_4, __v_8, __v_2]; 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_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_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_449] = { let __args: [G; IN_449] = [__v_5, __v_9, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_463] = [__v_14]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_12]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_11]; record.function_queries[463].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_449] = { let __args: [G; IN_449] = [__v_4, __v_8, __v_2]; 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_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_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_449] = { let __args: [G; IN_449] = [__v_5, __v_9, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_463] = [__v_14]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_12]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_11]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_7]; record.function_queries[463].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_464: usize = 5; +const IN_464: usize = 5; const OUT_464: usize = 1; -fn aiur_fn_464(inp: [G; IN_464], 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]; let __v_3: G = G::from_u64(8); let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_0, __v_1, __v_3, __v_2]; 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_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 __ret: [G; OUT_464] = [__v_6]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_0, __v_1, __v_2]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_464] = [__v_7]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_464] = [__v_7]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_465: usize = 3; -const IN_465: usize = 3; +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]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = (__v_2 - __v_3); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_464] = [__v_6]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_2, __v_3, __v_4]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_464] = [__v_7]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_464] = [__v_8]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_464] = [__v_9]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_3, __v_2, __v_4]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_464] = [__v_10]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_3, __v_4]; 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]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_464] = [__v_11]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(16); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_12, __v_4]; 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_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_464] = [__v_16]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_14, __v_15, __v_4]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_464] = [__v_16]; record.function_queries[464].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }) } +const INPUT_SIZE_465: usize = 5; +const IN_465: usize = 5; const OUT_465: usize = 1; -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]; 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() { 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_464] = { let __args: [G; IN_464] = [__v_4, __v_8, __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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_5, __v_9, __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_12: G = __r_arr[0]; let __ret: [G; OUT_465] = [__v_12]; record.function_queries[465].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_465] = [__v_12]; record.function_queries[465].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_465] = [__v_11]; record.function_queries[465].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_465] = [__v_7]; record.function_queries[465].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_466: usize = 4; -const IN_466: usize = 4; -const OUT_466: usize = 2; -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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 - __v_1); match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_466] = [__v_5, __v_2]; record.function_queries[466].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_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 __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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = (__v_6 - __v_10); match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_466] = [__v_14, __v_2]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_14, __v_2]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_13, __v_14]; record.function_queries[466].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_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 __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_10]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_466] = [__v_13, __v_2]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_13, __v_14]; record.function_queries[466].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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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]; match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_7, __v_11]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_466] = [__v_14, __v_2]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_14, __v_15]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_13, __v_14]; record.function_queries[466].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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_10, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_7, __v_11, __v_14, __v_3]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_15, __v_16]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_15, __v_14]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_13, __v_14]; record.function_queries[466].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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_10, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __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_466] = { let __args: [G; IN_466] = [__v_7, __v_11, __v_14, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_17, __v_18]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_15, __v_14]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_13, __v_14]; record.function_queries[466].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_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_466] = { let __args: [G; IN_466] = [__v_6, __v_10, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __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_466] = { let __args: [G; IN_466] = [__v_7, __v_11, __v_14, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_17, __v_18]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_15, __v_14]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_13, __v_14]; record.function_queries[466].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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_6, __v_7, __v_10, __v_11]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_466] = [__v_13, __v_2]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_13, __v_14]; record.function_queries[466].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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = (__v_7 - __v_11); match __v_14.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_8, __v_12, __v_2, __v_3]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_15, __v_16]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_15, __v_2]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_14, __v_15]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_13, __v_14]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_466] = [__v_9, __v_10]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_467: usize = 4; -const IN_467: usize = 4; -const OUT_467: usize = 2; -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]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_467] = [__v_4, __v_4]; record.function_queries[467].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_431] = { let __args: [G; IN_431] = [__v_0, __v_3]; 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 __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_1, __v_3]; 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_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_467] = [__v_9, __v_5]; record.function_queries[467].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_7, __v_3]; 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]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_467] = [__v_10, __v_5]; record.function_queries[467].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(8); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_6, __v_7, __v_11, __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_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 __v_15: G = G::from_u64(1); let __ret: [G; OUT_467] = [__v_15, __v_5]; record.function_queries[467].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_13, __v_14, __v_5, __v_3]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_467] = [__v_15, __v_16]; record.function_queries[467].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }) } +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]; 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(8); let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_2, __v_3, __v_5, __v_4]; 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_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 __ret: [G; OUT_465] = [__v_8]; record.function_queries[465].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_2, __v_3, __v_4]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_465] = [__v_9]; record.function_queries[465].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_4]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_465] = [__v_9]; record.function_queries[465].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_466: usize = 3; +const IN_466: usize = 3; +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 = inp[2]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_466] = [__v_8]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 - __v_9); match __v_10.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_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_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() { 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_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() { 8u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __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_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { let __v_20: G = (__v_13 - __v_17); match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_14, __v_18, __v_2]; 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_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_4, __v_6, __v_2]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_466] = [__v_22]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_22]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_21]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_20]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_19]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_15]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_11]; record.function_queries[466].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_467: usize = 3; +const IN_467: usize = 3; +const OUT_467: usize = 1; +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 = G::from_u64(8); let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_1, __v_3, __v_2]; 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_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 __ret: [G; OUT_467] = [__v_6]; record.function_queries[467].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_0, __v_1, __v_2]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_467] = [__v_7]; record.function_queries[467].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __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_7: G = __r_arr[0]; let __ret: [G; OUT_467] = [__v_7]; record.function_queries[467].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_468: usize = 3; const IN_468: usize = 3; 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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __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_3: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1, __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_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_6]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_3, __v_4, __v_2]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_7]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_3, __v_4, __v_2]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_8]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_3, __v_4, __v_2]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_9]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_4, __v_3, __v_2]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_10]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_3, __v_4, __v_2]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_468] = [__v_11]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_3, __v_4, __v_2]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_3, __v_4, __v_2]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_469: usize = 3; -const IN_469: usize = 3; -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 = inp[1]; let __v_2: G = inp[2]; 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_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() { 2u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_6]; 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_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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_16 + __v_17); let __v_24: G = (__v_22 - __v_23); match __v_24.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_13, __v_14]; 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_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_bool((__v_30 == G::ZERO)); let __v_39: G = G::from_u64(1); let __v_40: G = (__v_31 - __v_39); let __v_41: G = G::from_bool((__v_40 == G::ZERO)); let __v_42: G = (__v_38 * __v_41); match __v_42.as_canonical_u64() { 0u64 => { let __v_43: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_43]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_13, __v_14]; 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_43: G = __r_arr[0]; let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_43]; 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_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_45]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2]; 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_45: G = __r_arr[0]; let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2]; 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_46: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_45, __v_46, __v_2]; 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_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_48]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; 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_49: G = __r_arr[0]; let __ret: [G; OUT_469] = [__v_49]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_38: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_38]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_25: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_25]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_22]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_9]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_470: usize = 7; -const IN_470: usize = 7; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = 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_2 - __v_5); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_470] = [__v_8]; record.function_queries[470].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __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_10: G = (__v_1 + __v_5); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_4, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_9, __v_11, __v_6]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_470] = [__v_13]; record.function_queries[470].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_470] = [__v_15]; record.function_queries[470].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_471: usize = 2; -const IN_471: usize = 2; +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 __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() { 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_467] = { let __args: [G; IN_467] = [__v_4, __v_8, __v_2]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_5, __v_9, __v_2]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_12]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_12]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_11]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_7]; record.function_queries[468].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_469: usize = 4; +const IN_469: usize = 4; +const OUT_469: usize = 2; +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 = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 - __v_1); match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_469] = [__v_5, __v_2]; record.function_queries[469].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_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 __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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = (__v_6 - __v_10); match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_469] = [__v_14, __v_2]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_14, __v_2]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_13, __v_14]; record.function_queries[469].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_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 __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_10]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_469] = [__v_13, __v_2]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_13, __v_14]; record.function_queries[469].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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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]; match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_7, __v_11]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_469] = [__v_14, __v_2]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_14, __v_15]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_13, __v_14]; record.function_queries[469].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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_10, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_7, __v_11, __v_14, __v_3]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_15, __v_16]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_15, __v_14]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_13, __v_14]; record.function_queries[469].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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_10, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __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_469] = { let __args: [G; IN_469] = [__v_7, __v_11, __v_14, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_17, __v_18]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_15, __v_14]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_13, __v_14]; record.function_queries[469].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_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_469] = { let __args: [G; IN_469] = [__v_6, __v_10, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __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_469] = { let __args: [G; IN_469] = [__v_7, __v_11, __v_14, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_17, __v_18]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_15, __v_14]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_13, __v_14]; record.function_queries[469].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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_6, __v_7, __v_10, __v_11]; 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_469] = [__v_13, __v_2]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_13, __v_14]; record.function_queries[469].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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = (__v_7 - __v_11); match __v_14.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_8, __v_12, __v_2, __v_3]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_15, __v_16]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_15, __v_2]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_14, __v_15]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_13, __v_14]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_469] = [__v_9, __v_10]; record.function_queries[469].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_470: usize = 4; +const IN_470: usize = 4; +const OUT_470: usize = 2; +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 __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 __ret: [G; OUT_470] = [__v_4, __v_4]; record.function_queries[470].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_434] = { let __args: [G; IN_434] = [__v_0, __v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_1, __v_3]; 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_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_470] = [__v_9, __v_5]; record.function_queries[470].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_6, __v_7, __v_3]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_470] = [__v_10, __v_5]; record.function_queries[470].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(8); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_6, __v_7, __v_11, __v_3]; 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_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 __v_15: G = G::from_u64(1); let __ret: [G; OUT_470] = [__v_15, __v_5]; record.function_queries[470].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_13, __v_14, __v_5, __v_3]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_470] = [__v_15, __v_16]; record.function_queries[470].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }) } +const INPUT_SIZE_471: usize = 3; +const IN_471: usize = 3; const OUT_471: usize = 1; -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 __v_1: G = inp[1]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_1]; 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 = 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_78] = { let __args: [G; IN_78] = [__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(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_14: G = __r_arr[0]; 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 __ret: [G; OUT_471] = [__v_15]; record.function_queries[471].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_1, __v_2]; 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_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_471] = [__v_6]; record.function_queries[471].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_3, __v_4, __v_2]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_471] = [__v_7]; record.function_queries[471].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_3, __v_4, __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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_471] = [__v_8]; record.function_queries[471].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_3, __v_4, __v_2]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_471] = [__v_9]; record.function_queries[471].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_4, __v_3, __v_2]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_471] = [__v_10]; record.function_queries[471].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_3, __v_4, __v_2]; 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]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_471] = [__v_11]; record.function_queries[471].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_3, __v_4, __v_2]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_471] = [__v_13]; record.function_queries[471].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_4, __v_2]; 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 __ret: [G; OUT_471] = [__v_13]; record.function_queries[471].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }) } const INPUT_SIZE_472: usize = 3; const IN_472: usize = 3; 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 __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; 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 __v_11: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_11]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_4, __v_5, __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_11: G = __r_arr[0]; let __ret: [G; OUT_472] = [__v_11]; record.function_queries[472].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() { 4u64 => { let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_8, __v_9, __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_11: G = __r_arr[0]; let __ret: [G; OUT_472] = [__v_11]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_11]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_473: usize = 3; -const IN_473: usize = 3; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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_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() { 2u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_6]; 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_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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_16 + __v_17); let __v_24: G = (__v_22 - __v_23); match __v_24.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_13, __v_14]; 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_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_bool((__v_30 == G::ZERO)); let __v_39: G = G::from_u64(1); let __v_40: G = (__v_31 - __v_39); let __v_41: G = G::from_bool((__v_40 == G::ZERO)); let __v_42: G = (__v_38 * __v_41); match __v_42.as_canonical_u64() { 0u64 => { let __v_43: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_43]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_13, __v_14]; 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_43: G = __r_arr[0]; let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_43]; 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_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_45]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __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_45: G = __r_arr[0]; let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_1, __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_46: G = __r_arr[0]; let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_45, __v_46, __v_2]; 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_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_48]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; 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_49: G = __r_arr[0]; let __ret: [G; OUT_472] = [__v_49]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_38: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_38]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_25: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_25]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_22]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_9]; record.function_queries[472].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_473: usize = 7; +const IN_473: usize = 7; 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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_3, __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_4: G = __r_arr[0]; let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_473] = [__v_6]; record.function_queries[473].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_3, __v_6, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_473] = [__v_7]; record.function_queries[473].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_474: usize = 1; -const IN_474: 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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = 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_2 - __v_5); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_473] = [__v_8]; record.function_queries[473].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __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_10: G = (__v_1 + __v_5); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_4, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_9, __v_11, __v_6]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_473] = [__v_13]; record.function_queries[473].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_473] = [__v_15]; 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 __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_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_295] = { let __args: [G; IN_295] = [__v_4]; 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 __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_298] = { let __args: [G; IN_298] = [__v_15, __v_16, __v_22]; 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_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_474] = [__v_36]; record.function_queries[474].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_474] = [__v_36]; record.function_queries[474].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_474] = [__v_36]; record.function_queries[474].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_474] = [__v_22]; record.function_queries[474].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_474] = [__v_20]; record.function_queries[474].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_474] = [__v_20]; record.function_queries[474].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_474] = [__v_7]; record.function_queries[474].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__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_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_79] = { let __args: [G; IN_79] = [__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(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_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_474] = [__v_15]; record.function_queries[474].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_475: usize = 3; const IN_475: usize = 3; 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 __v_2: G = inp[2]; let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_3, __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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_475] = [__v_5]; record.function_queries[475].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_3, __v_5, __v_2]; 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 __ret: [G; OUT_475] = [__v_6]; record.function_queries[475].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_476: usize = 4; -const IN_476: usize = 4; +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 __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; 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 __v_11: G = G::from_u64(0); let __ret: [G; OUT_475] = [__v_11]; record.function_queries[475].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_4, __v_5, __v_1, __v_2]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_475] = [__v_11]; record.function_queries[475].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() { 4u64 => { let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_8, __v_9, __v_0, __v_2]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_475] = [__v_11]; record.function_queries[475].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_475] = [__v_11]; record.function_queries[475].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_476: usize = 3; +const IN_476: usize = 3; 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __v_3]; 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 __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() { 5u64 => { let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_7, __v_3]; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_476] = [__v_11]; record.function_queries[476].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; 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 = G::from_u64(3); let __v_16: G = { let __values: [G; 4] = [__v_15, __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 __v_17: G = { let __values: [G; 3] = [__v_12, __v_0, __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_446] = { let __args: [G; IN_446] = [__v_1, __v_16, __v_17]; 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_18: G = __r_arr[0]; let __ret: [G; OUT_476] = [__v_18]; record.function_queries[476].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_476] = [__v_10]; record.function_queries[476].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_477: usize = 2; -const IN_477: usize = 2; +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 __v_2: G = inp[2]; let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __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_3: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_3, __v_2]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_476] = [__v_6]; record.function_queries[476].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_1, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_6, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_476] = [__v_7]; 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 = 1; -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 __v_1: G = inp[1]; let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_2, __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_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 __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 __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_477] = [__v_10]; record.function_queries[477].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_477] = [__v_8]; record.function_queries[477].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_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_298] = { let __args: [G; IN_298] = [__v_4]; 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_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_301] = { let __args: [G; IN_301] = [__v_15, __v_16, __v_22]; 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_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_477] = [__v_36]; record.function_queries[477].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_477] = [__v_36]; record.function_queries[477].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_477] = [__v_36]; record.function_queries[477].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_477] = [__v_22]; record.function_queries[477].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_477] = [__v_20]; record.function_queries[477].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_477] = [__v_20]; record.function_queries[477].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_477] = [__v_7]; record.function_queries[477].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_478: usize = 3; const IN_478: usize = 3; 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 __v_2: G = inp[2]; let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __v_1, __v_2]; 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 __ret: [G; OUT_478] = [__v_3]; record.function_queries[478].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_479: usize = 3; -const IN_479: usize = 3; +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 __v_2: G = inp[2]; let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __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_3: G = __r_arr[0]; let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_3, __v_2]; 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]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_478] = [__v_5]; record.function_queries[478].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_1, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_5, __v_2]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_478] = [__v_6]; record.function_queries[478].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_479: usize = 4; +const IN_479: usize = 4; 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 __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 __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_479] = [__v_12]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_12]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_11]; record.function_queries[479].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_332] = { let __args: [G; IN_332] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_11]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_11]; record.function_queries[479].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_445] = { let __args: [G; IN_445] = [__v_5, __v_9]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_12]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_1, __v_2]; 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 __v_12: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_12]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_1, __v_2]; 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 __v_11: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_11]; record.function_queries[479].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_446] = { let __args: [G; IN_446] = [__v_4, __v_8, __v_2]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_1, __v_2]; 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 __v_12: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_12]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_5, __v_9, __v_2]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_1, __v_2]; 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 __v_13: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_13]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_479] = [__v_13]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_1, __v_2]; 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 __v_11: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_11]; record.function_queries[479].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_446] = { let __args: [G; IN_446] = [__v_4, __v_8, __v_2]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_12]; record.function_queries[479].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; 3] = [__v_12, __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_446] = { let __args: [G; IN_446] = [__v_5, __v_9, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_14]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_4, __v_5, __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_11: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_11]; record.function_queries[479].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_446] = { let __args: [G; IN_446] = [__v_4, __v_8, __v_2]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_12]; record.function_queries[479].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; 3] = [__v_12, __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_446] = { let __args: [G; IN_446] = [__v_5, __v_9, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_14]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_11]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_7]; record.function_queries[479].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_348] = { let __args: [G; IN_348] = [__v_4, __v_5, __v_8, __v_9]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_11]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_0]; 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_11: G = __r_arr[0]; let __v_12: G = (__v_11 - __v_0); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_13]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_11, __v_1, __v_2]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_13]; record.function_queries[479].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_446] = { let __args: [G; IN_446] = [__v_6, __v_10, __v_2]; 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_479] = [__v_13]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_13]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_12]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_11]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_480: usize = 4; -const IN_480: usize = 4; -const OUT_480: usize = 3; -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 __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_480] = [__v_4, __v_0, __v_1]; record.function_queries[480].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = (__v_0 - __v_1); match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_480] = [__v_5, __v_0, __v_1]; record.function_queries[480].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_480] = [__v_6, __v_0, __v_1]; record.function_queries[480].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_0]; 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 __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_1]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; 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 = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_480] = [__v_11, __v_12, __v_13]; record.function_queries[480].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_7, __v_0, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_480] = [__v_11, __v_12, __v_13]; record.function_queries[480].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_0, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_480] = [__v_11, __v_12, __v_13]; record.function_queries[480].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_1, __v_2, __v_3]; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_480] = [__v_11, __v_12, __v_13]; record.function_queries[480].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_481: usize = 12; -const IN_481: usize = 12; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __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_5: 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_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() { 5u64 => { let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_7, __v_3]; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_11]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_2, __v_11, __v_12]; 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_13: G = __r_arr[0]; 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 = G::from_u64(3); let __v_16: G = { let __values: [G; 4] = [__v_15, __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 __v_17: G = { let __values: [G; 3] = [__v_12, __v_0, __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_449] = { let __args: [G; IN_449] = [__v_1, __v_16, __v_17]; 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_18: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_18]; record.function_queries[479].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(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 = 2; +const IN_480: usize = 2; +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 __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_1]; 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_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 __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 __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_480] = [__v_10]; record.function_queries[480].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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); }, } }) } +const INPUT_SIZE_481: usize = 3; +const IN_481: usize = 3; 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_481] = [__v_5]; record.function_queries[481].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_481] = [__v_12]; record.function_queries[481].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_482: usize = 6; -const IN_482: usize = 6; -const OUT_482: usize = 3; -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 __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_295] = { let __args: [G; IN_295] = [__v_0]; 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_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]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1]; 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_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]; let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__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(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 __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if ((!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 __v_33: G = __r_arr[0]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_34: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_34, __v_2, __v_3]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_2, __v_3, __v_4, __v_5]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __ret: [G; OUT_482] = [__v_34, __v_35, __v_36]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_33.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __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 __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __ret: [G; OUT_482] = [__v_34, __v_35, __v_36]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__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(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_34: G = __r_arr[0]; let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if ((!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_35: G = __r_arr[0]; let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = 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 __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __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 __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __ret: [G; OUT_482] = [__v_37, __v_38, __v_39]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_37: G = { let __a_val = __v_34.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_484] = { let __args: [G; IN_484] = [__v_2, __v_3, __v_4, __v_5]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __ret: [G; OUT_482] = [__v_38, __v_39, __v_40]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_2, __v_3, __v_4, __v_5]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __ret: [G; OUT_482] = [__v_38, __v_39, __v_40]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }) } +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 __v_2: G = inp[2]; let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_481] = [__v_3]; record.function_queries[481].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_482: usize = 3; +const IN_482: usize = 3; +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 __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 __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_482] = [__v_12]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_12]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_11]; record.function_queries[482].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_335] = { let __args: [G; IN_335] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_11]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_11]; record.function_queries[482].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_448] = { let __args: [G; IN_448] = [__v_5, __v_9]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_12]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_2]; 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 __v_12: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_12]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_2]; 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 __v_11: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_11]; record.function_queries[482].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_449] = { let __args: [G; IN_449] = [__v_4, __v_8, __v_2]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_2]; 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 __v_12: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_12]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_5, __v_9, __v_2]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_2]; 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 __v_13: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_13]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_482] = [__v_13]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_2]; 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 __v_11: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_11]; record.function_queries[482].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_449] = { let __args: [G; IN_449] = [__v_4, __v_8, __v_2]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_12]; record.function_queries[482].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; 3] = [__v_12, __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_449] = { let __args: [G; IN_449] = [__v_5, __v_9, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_14]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_4, __v_5, __v_1, __v_2]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_11]; record.function_queries[482].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_449] = { let __args: [G; IN_449] = [__v_4, __v_8, __v_2]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_12]; record.function_queries[482].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; 3] = [__v_12, __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_449] = { let __args: [G; IN_449] = [__v_5, __v_9, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_14]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_11]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_7]; record.function_queries[482].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_351] = { let __args: [G; IN_351] = [__v_4, __v_5, __v_8, __v_9]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_11]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0]; 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_11: G = __r_arr[0]; let __v_12: G = (__v_11 - __v_0); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_13]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_11, __v_1, __v_2]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_13]; record.function_queries[482].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_449] = { let __args: [G; IN_449] = [__v_6, __v_10, __v_2]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_482] = [__v_13]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_13]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_12]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_11]; record.function_queries[482].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_483: usize = 4; const IN_483: usize = 4; const OUT_483: usize = 3; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_3]; 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 __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_6, __v_1, __v_8, __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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_483] = [__v_9, __v_10, __v_11]; record.function_queries[483].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_483] = [__v_6, __v_0, __v_1]; record.function_queries[483].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_484: usize = 4; -const IN_484: usize = 4; -const OUT_484: usize = 3; -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 = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_3]; 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 __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_6, __v_8, __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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_484] = [__v_9, __v_10, __v_11]; record.function_queries[484].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_484] = [__v_6, __v_0, __v_1]; record.function_queries[484].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_485: usize = 4; -const IN_485: usize = 4; +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 __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 __ret: [G; OUT_483] = [__v_4, __v_0, __v_1]; record.function_queries[483].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = (__v_0 - __v_1); match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_483] = [__v_5, __v_0, __v_1]; record.function_queries[483].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_483] = [__v_6, __v_0, __v_1]; record.function_queries[483].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_0]; 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 __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_1]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_483] = [__v_11, __v_12, __v_13]; record.function_queries[483].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_7, __v_0, __v_1, __v_2, __v_3]; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_483] = [__v_11, __v_12, __v_13]; record.function_queries[483].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_9, __v_0, __v_1, __v_2, __v_3]; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_483] = [__v_11, __v_12, __v_13]; record.function_queries[483].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_483] = [__v_11, __v_12, __v_13]; record.function_queries[483].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }) } +const INPUT_SIZE_484: usize = 12; +const IN_484: usize = 12; +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 = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_484] = [__v_5]; record.function_queries[484].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_484] = [__v_12]; record.function_queries[484].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_485: usize = 6; +const IN_485: usize = 6; const OUT_485: usize = 3; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_3]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_3]; 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 __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_8, __v_9, __v_11, __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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __ret: [G; OUT_485] = [__v_12, __v_13, __v_14]; record.function_queries[485].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_485] = [__v_8, __v_0, __v_1]; record.function_queries[485].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_485] = [__v_6, __v_0, __v_1]; record.function_queries[485].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_486: usize = 5; -const IN_486: usize = 5; +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 __v_1: G = inp[1]; let __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_298] = { let __args: [G; IN_298] = [__v_0]; 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 __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]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_1]; 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_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]; let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__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(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 __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if ((!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 __v_33: G = __r_arr[0]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_34: G = G::from_u64(0); let __ret: [G; OUT_485] = [__v_34, __v_2, __v_3]; record.function_queries[485].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_3, __v_4, __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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __ret: [G; OUT_485] = [__v_34, __v_35, __v_36]; record.function_queries[485].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_33.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_2, __v_3, __v_4, __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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __ret: [G; OUT_485] = [__v_34, __v_35, __v_36]; record.function_queries[485].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__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(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_34: G = __r_arr[0]; let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if ((!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_35: G = __r_arr[0]; let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = 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 __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_2, __v_3, __v_4, __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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __ret: [G; OUT_485] = [__v_37, __v_38, __v_39]; record.function_queries[485].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_37: G = { let __a_val = __v_34.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_487] = { let __args: [G; IN_487] = [__v_2, __v_3, __v_4, __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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __ret: [G; OUT_485] = [__v_38, __v_39, __v_40]; record.function_queries[485].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_2, __v_3, __v_4, __v_5]; 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 __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __ret: [G; OUT_485] = [__v_38, __v_39, __v_40]; record.function_queries[485].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }) } +const INPUT_SIZE_486: usize = 4; +const IN_486: usize = 4; const OUT_486: usize = 3; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_2, __v_4]; 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 __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 __v_8: G = (__v_3 - __v_7); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1, __v_6, __v_8, __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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_486] = [__v_9, __v_10, __v_11]; record.function_queries[486].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; 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 __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_489] = { let __args: [G; IN_489] = [__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(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 __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_486] = [__v_21, __v_1, __v_2]; record.function_queries[486].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if ((!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 __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_22, __v_2, __v_24, __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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __ret: [G; OUT_486] = [__v_25, __v_26, __v_27]; record.function_queries[486].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_486] = [__v_23, __v_1, __v_2]; record.function_queries[486].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_487: usize = 5; -const IN_487: usize = 5; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0]; 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 __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_3]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_6, __v_1, __v_8, __v_3]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_486] = [__v_9, __v_10, __v_11]; record.function_queries[486].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_486] = [__v_6, __v_0, __v_1]; record.function_queries[486].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_487: usize = 4; +const IN_487: usize = 4; const OUT_487: usize = 3; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_1, __v_4]; 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 __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 __v_8: G = (__v_3 - __v_7); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_6, __v_2, __v_8, __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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_487] = [__v_9, __v_10, __v_11]; record.function_queries[487].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; 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 __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_489] = { let __args: [G; IN_489] = [__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(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 __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_487] = [__v_21, __v_1, __v_2]; record.function_queries[487].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__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_4]; 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 __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1, __v_22, __v_24, __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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __ret: [G; OUT_487] = [__v_25, __v_26, __v_27]; record.function_queries[487].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_487] = [__v_23, __v_1, __v_2]; record.function_queries[487].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1]; 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 __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_3]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_6, __v_8, __v_3]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_487] = [__v_9, __v_10, __v_11]; record.function_queries[487].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_487] = [__v_6, __v_0, __v_1]; record.function_queries[487].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_488: usize = 4; const IN_488: usize = 4; const OUT_488: usize = 3; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_3]; 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 __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_1, __v_3]; 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 __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_5, __v_7, __v_9, __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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __ret: [G; OUT_488] = [__v_10, __v_11, __v_12]; record.function_queries[488].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_5, __v_1, __v_9, __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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __ret: [G; OUT_488] = [__v_10, __v_11, __v_12]; record.function_queries[488].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_7, __v_9, __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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __ret: [G; OUT_488] = [__v_10, __v_11, __v_12]; record.function_queries[488].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_488] = [__v_8, __v_0, __v_1]; record.function_queries[488].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_489: usize = 12; -const IN_489: usize = 12; -const OUT_489: usize = 1; -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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_489] = [__v_12]; record.function_queries[489].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_489] = [__v_12]; record.function_queries[489].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_489] = [__v_12]; 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 = 2; -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 __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_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() { 8u64 => { let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_1]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8]; 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_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() { 8u64 => { let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_7]; 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_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(8); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __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_19: G = G::from_u64(1); let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_18, __v_3]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_490] = [__v_19, __v_20]; record.function_queries[490].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_490] = [__v_17, __v_0]; record.function_queries[490].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(1); let __ret: [G; OUT_490] = [__v_15, __v_8]; record.function_queries[490].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_490] = [__v_8, __v_0]; record.function_queries[490].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_491: usize = 1; -const IN_491: usize = 1; -const OUT_491: usize = 2; -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 __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_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_295] = { let __args: [G; IN_295] = [__v_4]; 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 __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_344] = { let __args: [G; IN_344] = [__v_11, __v_5]; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_20, __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_22: G = __r_arr[0]; let __ret: [G; OUT_491] = [__v_21, __v_22]; record.function_queries[491].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_11, __v_5]; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_20, __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_22: G = __r_arr[0]; let __ret: [G; OUT_491] = [__v_21, __v_22]; record.function_queries[491].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_491] = [__v_20, __v_0]; record.function_queries[491].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_491] = [__v_7, __v_0]; record.function_queries[491].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_492: usize = 3; -const IN_492: usize = 3; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0]; 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 __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1]; 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 __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_434] = { let __args: [G; IN_434] = [__v_5, __v_3]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_7, __v_3]; 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 = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_8, __v_9, __v_11, __v_3]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __ret: [G; OUT_488] = [__v_12, __v_13, __v_14]; record.function_queries[488].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_488] = [__v_8, __v_0, __v_1]; record.function_queries[488].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_488] = [__v_6, __v_0, __v_1]; record.function_queries[488].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_489: usize = 5; +const IN_489: usize = 5; +const OUT_489: usize = 3; +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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __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 __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 __v_8: G = (__v_3 - __v_7); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_6, __v_8, __v_4]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_489] = [__v_9, __v_10, __v_11]; record.function_queries[489].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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_492] = { let __args: [G; IN_492] = [__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(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 __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_489] = [__v_21, __v_1, __v_2]; record.function_queries[489].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if ((!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 __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_22, __v_2, __v_24, __v_4]; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __ret: [G; OUT_489] = [__v_25, __v_26, __v_27]; record.function_queries[489].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_489] = [__v_23, __v_1, __v_2]; record.function_queries[489].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_490: usize = 5; +const IN_490: usize = 5; +const OUT_490: usize = 3; +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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__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 __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 __v_8: G = (__v_3 - __v_7); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_6, __v_2, __v_8, __v_4]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_490] = [__v_9, __v_10, __v_11]; record.function_queries[490].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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_492] = { let __args: [G; IN_492] = [__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(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 __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_490] = [__v_21, __v_1, __v_2]; record.function_queries[490].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__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_4]; 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 __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_22, __v_24, __v_4]; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __ret: [G; OUT_490] = [__v_25, __v_26, __v_27]; record.function_queries[490].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_490] = [__v_23, __v_1, __v_2]; record.function_queries[490].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_491: usize = 4; +const IN_491: usize = 4; +const OUT_491: usize = 3; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_0, __v_3]; 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 __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_1, __v_3]; 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 __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_5, __v_7, __v_9, __v_3]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __ret: [G; OUT_491] = [__v_10, __v_11, __v_12]; record.function_queries[491].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_5, __v_1, __v_9, __v_3]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __ret: [G; OUT_491] = [__v_10, __v_11, __v_12]; record.function_queries[491].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_7, __v_9, __v_3]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __ret: [G; OUT_491] = [__v_10, __v_11, __v_12]; record.function_queries[491].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_491] = [__v_8, __v_0, __v_1]; record.function_queries[491].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_492: usize = 12; +const IN_492: usize = 12; const OUT_492: usize = 1; -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 __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_0]; 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 __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_1]; 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 __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_4.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_492] = [__v_7]; record.function_queries[492].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_492] = [__v_7]; record.function_queries[492].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3]; 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 __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_295] = { let __args: [G; IN_295] = [__v_5]; 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_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_494] = { let __args: [G; IN_494] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; 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 __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1, __v_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]; 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 __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; match __v_33.as_canonical_u64() { 1u64 => { match __v_35.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_34, __v_36, __v_2]; 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_37: G = __r_arr[0]; let __ret: [G; OUT_492] = [__v_37]; record.function_queries[492].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_34, __v_1, __v_2]; 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_37: G = __r_arr[0]; let __ret: [G; OUT_492] = [__v_37]; record.function_queries[492].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 0u64 => { match __v_35.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_36, __v_2]; 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_37: G = __r_arr[0]; let __ret: [G; OUT_492] = [__v_37]; record.function_queries[492].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); let __ret: [G; OUT_492] = [__v_37]; record.function_queries[492].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64())); }, } }, } }, } }) } -const INPUT_SIZE_493: usize = 1; -const IN_493: usize = 1; +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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_492] = [__v_12]; record.function_queries[492].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_492] = [__v_12]; record.function_queries[492].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_492] = [__v_12]; record.function_queries[492].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_493: usize = 2; +const IN_493: usize = 2; const OUT_493: usize = 2; -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 __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_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_493] = [__v_4, __v_7]; record.function_queries[493].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_493] = [__v_8, __v_7]; record.function_queries[493].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_494: usize = 14; -const IN_494: usize = 14; +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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_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() { 8u64 => { 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_8]; 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_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() { 8u64 => { let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_7]; 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 __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(8); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __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_19: G = G::from_u64(1); let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_18, __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_20: G = __r_arr[0]; let __ret: [G; OUT_493] = [__v_19, __v_20]; record.function_queries[493].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_493] = [__v_17, __v_0]; record.function_queries[493].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(1); let __ret: [G; OUT_493] = [__v_15, __v_8]; record.function_queries[493].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_493] = [__v_8, __v_0]; record.function_queries[493].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_494: usize = 1; +const IN_494: usize = 1; const OUT_494: usize = 2; -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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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() { 1u64 => { let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0]; 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_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(1); let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_15, __v_13]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_494] = [__v_16, __v_17]; record.function_queries[494].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_494] = [__v_16, __v_0]; record.function_queries[494].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0]; 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_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(1); let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_15, __v_13]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_494] = [__v_16, __v_17]; record.function_queries[494].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_494] = [__v_16, __v_0]; record.function_queries[494].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_494] = [__v_14, __v_0]; record.function_queries[494].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_495: usize = 2; -const IN_495: usize = 2; +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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_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_298] = { let __args: [G; IN_298] = [__v_4]; 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_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_347] = { let __args: [G; IN_347] = [__v_11, __v_5]; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_20, __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_22: G = __r_arr[0]; let __ret: [G; OUT_494] = [__v_21, __v_22]; record.function_queries[494].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_11, __v_5]; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_20, __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_22: G = __r_arr[0]; let __ret: [G; OUT_494] = [__v_21, __v_22]; record.function_queries[494].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_494] = [__v_20, __v_0]; record.function_queries[494].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_494] = [__v_7, __v_0]; record.function_queries[494].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_495: usize = 3; +const IN_495: usize = 3; const OUT_495: usize = 1; -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 __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_2: G = __r_arr[0]; 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 __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_0, __v_4]; 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 __v_5: G = __r_arr[0]; let __ret: [G; OUT_495] = [__v_5]; record.function_queries[495].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_0, __v_1, __v_2]; 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 __v_3: G = __r_arr[0]; let __ret: [G; OUT_495] = [__v_3]; record.function_queries[495].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_496: usize = 3; -const IN_496: usize = 3; -const OUT_496: usize = 1; -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 = G::from_u64(0); let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __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_4: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_2]; 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_497] = { let __args: [G; IN_497] = [__v_0, __v_7]; 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 __v_8: G = __r_arr[0]; let __ret: [G; OUT_496] = [__v_8]; record.function_queries[496].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_6, __v_7]; 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 __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_2 - __v_6); let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_9, __v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_8, __v_11]; 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 __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_12, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_496] = [__v_13]; record.function_queries[496].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_497: usize = 2; -const IN_497: usize = 2; -const OUT_497: usize = 1; -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 __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_789] = { let __args: [G; IN_789] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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 __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_497] = [__v_10]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 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_6, __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_341] = { let __args: [G; IN_341] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __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 __ret: [G; OUT_497] = [__v_10]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3]; 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_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]; let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__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(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_19: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__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(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_21: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_21, __v_4]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_497] = [__v_22]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_6, __v_1]; 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 __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_509] = { let __args: [G; IN_509] = [__v_8, __v_7, __v_10, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(509, (&__args[..]))?) { [G::ZERO; OUT_509] } else { let (__hash, __hit) = record.function_queries[509].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[509].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { (*(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509])) }; __ret }, _ => { aiur_fn_509::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_497] = [__v_11]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__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_7, __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_495] = { let __args: [G; IN_495] = [__v_4, __v_8]; 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 __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_3, __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_497] = [__v_11]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__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_7, __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_517] = { let __args: [G; IN_517] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__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_340] = { let __args: [G; IN_340] = [__v_6, __v_9]; 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_11: G = __r_arr[0]; 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 __ret: [G; OUT_497] = [__v_12]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_4, __v_5, __v_1]; 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 __v_6: G = __r_arr[0]; let __ret: [G; OUT_497] = [__v_6]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(510, (&__args[..]))?) { [G::ZERO; OUT_510] } else { let (__hash, __hit) = record.function_queries[510].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[510].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { (*(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510])) }; __ret }, _ => { aiur_fn_510::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_497] = [__v_6]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(516, (&__args[..]))?) { [G::ZERO; OUT_516] } else { let (__hash, __hit) = record.function_queries[516].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[516].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[516].bump_multiplicity(__i); } let __ret: [G; OUT_516] = unsafe { (*(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516])) }; __ret }, _ => { aiur_fn_516::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_497] = [__v_6]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_498: usize = 4; -const IN_498: usize = 4; +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 __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_0]; 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 __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_1]; 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 __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_4.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_495] = [__v_7]; record.function_queries[495].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_495] = [__v_7]; record.function_queries[495].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__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_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_298] = { let __args: [G; IN_298] = [__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_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_497] = { let __args: [G; IN_497] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; 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 __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_1, __v_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]; 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 __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; match __v_33.as_canonical_u64() { 1u64 => { match __v_35.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_34, __v_36, __v_2]; 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_37: G = __r_arr[0]; let __ret: [G; OUT_495] = [__v_37]; record.function_queries[495].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_34, __v_1, __v_2]; 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_37: G = __r_arr[0]; let __ret: [G; OUT_495] = [__v_37]; record.function_queries[495].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 0u64 => { match __v_35.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_36, __v_2]; 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_37: G = __r_arr[0]; let __ret: [G; OUT_495] = [__v_37]; record.function_queries[495].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); let __ret: [G; OUT_495] = [__v_37]; record.function_queries[495].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64())); }, } }, } }, } }) } +const INPUT_SIZE_496: usize = 1; +const IN_496: usize = 1; +const OUT_496: usize = 2; +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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_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_496] = [__v_4, __v_7]; record.function_queries[496].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_496] = [__v_8, __v_7]; record.function_queries[496].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_497: usize = 14; +const IN_497: usize = 14; +const OUT_497: usize = 2; +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]; let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0]; 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 __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(1); let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_15, __v_13]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_497] = [__v_16, __v_17]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_497] = [__v_16, __v_0]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0]; 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 __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(1); let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_15, __v_13]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_497] = [__v_16, __v_17]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_497] = [__v_16, __v_0]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_497] = [__v_14, __v_0]; record.function_queries[497].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_498: usize = 2; +const IN_498: usize = 2; const OUT_498: usize = 1; -fn aiur_fn_498(inp: [G; IN_498], 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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(518, (&__args[..]))?) { [G::ZERO; OUT_518] } else { let (__hash, __hit) = record.function_queries[518].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[518].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { (*(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518])) }; __ret }, _ => { aiur_fn_518::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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; 5] = [__v_6, __v_3, __v_5, __v_6, __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 __v_8: G = G::from_u64(2); let __v_9: G = { let __values: [G; 5] = [__v_8, __v_0, __v_1, __v_7, __v_5]; 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_504] = { let __args: [G; IN_504] = [__v_2, __v_9, __v_3, __v_5]; 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 __v_10: G = __r_arr[0]; let __ret: [G; OUT_498] = [__v_10]; record.function_queries[498].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_499: usize = 4; -const IN_499: usize = 4; +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 __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_2: G = __r_arr[0]; 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 __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_4]; 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 __v_5: G = __r_arr[0]; let __ret: [G; OUT_498] = [__v_5]; record.function_queries[498].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_0, __v_1, __v_2]; 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 __v_3: G = __r_arr[0]; let __ret: [G; OUT_498] = [__v_3]; record.function_queries[498].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_499: usize = 3; +const IN_499: usize = 3; const OUT_499: usize = 1; -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 __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_1]; 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 __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_366] = { let __args: [G; IN_366] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_499] = [__v_8]; record.function_queries[499].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(0); let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_3]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_2]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_7]; 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 __v_8: G = __r_arr[0]; let __ret: [G; OUT_499] = [__v_8]; record.function_queries[499].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_6, __v_7]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_2 - __v_6); let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_8, __v_11]; 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 __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_12, __v_6, __v_7]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_499] = [__v_13]; record.function_queries[499].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_500: usize = 2; const IN_500: usize = 2; -const OUT_500: usize = 2; -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 __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_437] = { let __args: [G; IN_437] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_500] = [__v_7, __v_4]; record.function_queries[500].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_500] = [__v_3, __v_8]; record.function_queries[500].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_500] = { let __args: [G; IN_500] = [__v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_500] = [__v_3, __v_6]; record.function_queries[500].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_500] = { let __args: [G; IN_500] = [__v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_501: usize = 3; -const IN_501: usize = 3; +const OUT_500: usize = 1; +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 __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_792] = { let __args: [G; IN_792] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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 __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_6, __v_8, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_500] = [__v_10]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 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_6, __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_344] = { let __args: [G; IN_344] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __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 __ret: [G; OUT_500] = [__v_10]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__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_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]; let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__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(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_19: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__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(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_21: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_21, __v_4]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_500] = [__v_22]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_6, __v_1]; 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 __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_512] = { let __args: [G; IN_512] = [__v_8, __v_7, __v_10, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(512, (&__args[..]))?) { [G::ZERO; OUT_512] } else { let (__hash, __hit) = record.function_queries[512].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[512].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { (*(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512])) }; __ret }, _ => { aiur_fn_512::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_500] = [__v_11]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__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_7, __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_498] = { let __args: [G; IN_498] = [__v_4, __v_8]; 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 __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_3, __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_500] = [__v_11]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__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_7, __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_520] = { let __args: [G; IN_520] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__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_343] = { let __args: [G; IN_343] = [__v_6, __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_11: G = __r_arr[0]; 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 __ret: [G; OUT_500] = [__v_12]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_4, __v_5, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_500] = [__v_6]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(513, (&__args[..]))?) { [G::ZERO; OUT_513] } else { let (__hash, __hit) = record.function_queries[513].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[513].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[513].bump_multiplicity(__i); } let __ret: [G; OUT_513] = unsafe { (*(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513])) }; __ret }, _ => { aiur_fn_513::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_500] = [__v_6]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(519, (&__args[..]))?) { [G::ZERO; OUT_519] } else { let (__hash, __hit) = record.function_queries[519].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[519].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[519].bump_multiplicity(__i); } let __ret: [G; OUT_519] = unsafe { (*(record.function_queries[519].output_at(__i).as_ptr() as *const [G; OUT_519])) }; __ret }, _ => { aiur_fn_519::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_500] = [__v_6]; record.function_queries[500].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_501: usize = 4; +const IN_501: usize = 4; 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 __v_2: G = inp[2]; let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_0, __v_1]; 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 __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_366] = { let __args: [G; IN_366] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_501] = [__v_7]; record.function_queries[501].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_502: usize = 2; -const IN_502: usize = 2; -const OUT_502: usize = 2; -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 __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_502] = [__v_8, __v_4]; record.function_queries[502].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_502] = [__v_8, __v_4]; record.function_queries[502].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_502] = { let __args: [G; IN_502] = [__v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_502] = [__v_9, __v_10]; record.function_queries[502].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_503] = { let __args: [G; IN_503] = [__v_4, __v_5, __v_6, __v_7]; 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 __v_8: G = __r_arr[0]; let __ret: [G; OUT_502] = [__v_8, __v_6]; record.function_queries[502].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_502] = { let __args: [G; IN_502] = [__v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_502] = [__v_9, __v_10]; record.function_queries[502].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_503: usize = 4; -const IN_503: usize = 4; -const OUT_503: usize = 1; -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 __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_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_503] = [__v_0]; record.function_queries[503].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_503] = [__v_0]; record.function_queries[503].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = (__v_7 - __v_3); let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1, __v_11]; 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 __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_366] = { let __args: [G; IN_366] = [__v_12, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_16, __v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_503] = [__v_17]; record.function_queries[503].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __v_10: G = G::from_u64(3); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_7, __v_1, __v_2, __v_3]; 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 __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_8, __v_1, __v_2, __v_3]; 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 __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_503] = [__v_14]; record.function_queries[503].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(4); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_7, __v_1, __v_2, __v_3]; 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 __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_503] = { let __args: [G; IN_503] = [__v_8, __v_1, __v_2, __v_13]; 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 __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_503] = [__v_16]; record.function_queries[503].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_10: G = G::from_u64(5); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_7, __v_1, __v_2, __v_3]; 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 __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_503] = { let __args: [G; IN_503] = [__v_8, __v_1, __v_2, __v_13]; 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 __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_503] = [__v_16]; record.function_queries[503].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_10: G = G::from_u64(6); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_7, __v_1, __v_2, __v_3]; 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 __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_8, __v_1, __v_2, __v_3]; 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 __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_503] = { let __args: [G; IN_503] = [__v_9, __v_1, __v_2, __v_14]; 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 __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_503] = [__v_16]; record.function_queries[503].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_10: G = G::from_u64(8); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_9, __v_1, __v_2, __v_3]; 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 __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_503] = [__v_12]; record.function_queries[503].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_503] = [__v_0]; record.function_queries[503].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_504: usize = 4; -const IN_504: usize = 4; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_1, __v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(521, (&__args[..]))?) { [G::ZERO; OUT_521] } else { let (__hash, __hit) = record.function_queries[521].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[521].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { (*(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521])) }; __ret }, _ => { aiur_fn_521::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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; 5] = [__v_6, __v_3, __v_5, __v_6, __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 __v_8: G = G::from_u64(2); let __v_9: G = { let __values: [G; 5] = [__v_8, __v_0, __v_1, __v_7, __v_5]; 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_507] = { let __args: [G; IN_507] = [__v_2, __v_9, __v_3, __v_5]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_501] = [__v_10]; record.function_queries[501].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_502: usize = 4; +const IN_502: usize = 4; +const OUT_502: usize = 1; +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 __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1]; 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 __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_369] = { let __args: [G; IN_369] = [__v_4, __v_6, __v_7]; 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_502] = [__v_8]; record.function_queries[502].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_503: usize = 2; +const IN_503: usize = 2; +const OUT_503: usize = 2; +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 __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_440] = { let __args: [G; IN_440] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_503] = [__v_7, __v_4]; record.function_queries[503].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_503] = [__v_3, __v_8]; record.function_queries[503].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_503] = { let __args: [G; IN_503] = [__v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_503] = [__v_9, __v_10]; record.function_queries[503].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_503] = [__v_3, __v_6]; record.function_queries[503].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_503] = { let __args: [G; IN_503] = [__v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_503] = [__v_9, __v_10]; record.function_queries[503].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_504: usize = 3; +const IN_504: usize = 3; const OUT_504: usize = 1; -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 __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0]; 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_4: G = __r_arr[0]; match __v_4.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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_495] = { let __args: [G; IN_495] = [__v_0, __v_6]; 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 __v_7: G = __r_arr[0]; let __ret: [G; OUT_504] = [__v_7]; record.function_queries[504].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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_1]; 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 __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_0, __v_1, __v_2, __v_3]; 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 __v_10: G = __r_arr[0]; let __ret: [G; OUT_504] = [__v_10]; record.function_queries[504].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_10, __v_9]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_0, __v_1, __v_2, __v_3]; 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 __v_12: G = __r_arr[0]; let __ret: [G; OUT_504] = [__v_12]; record.function_queries[504].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_0, __v_1, __v_2, __v_3]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_504] = [__v_12]; record.function_queries[504].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, } }, _ => { let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_0, __v_1, __v_2, __v_3]; 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 __v_9: G = __r_arr[0]; let __ret: [G; OUT_504] = [__v_9]; record.function_queries[504].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_505: usize = 1; -const IN_505: usize = 1; -const OUT_505: usize = 1; -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 __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_505] = [__v_6]; record.function_queries[505].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_505] = [__v_6]; record.function_queries[505].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_4]; 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 __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_505] = [__v_7]; record.function_queries[505].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_505] = [__v_8]; record.function_queries[505].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_1]; 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 __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_369] = { let __args: [G; IN_369] = [__v_3, __v_5, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_504] = [__v_7]; record.function_queries[504].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_505: usize = 2; +const IN_505: usize = 2; +const OUT_505: usize = 2; +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 __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_505] = [__v_8, __v_4]; record.function_queries[505].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_505] = [__v_8, __v_4]; record.function_queries[505].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_505] = { let __args: [G; IN_505] = [__v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_505] = [__v_9, __v_10]; record.function_queries[505].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_506] = { let __args: [G; IN_506] = [__v_4, __v_5, __v_6, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_505] = [__v_8, __v_6]; record.function_queries[505].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_505] = { let __args: [G; IN_505] = [__v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_505] = [__v_9, __v_10]; record.function_queries[505].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_506: usize = 4; const IN_506: usize = 4; 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_1, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_7, __v_4]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_3 - __v_8); let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_9, __v_6, __v_10, __v_11]; 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 __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_12, __v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_506] = [__v_13]; record.function_queries[506].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_507: usize = 2; -const IN_507: usize = 2; -const OUT_507: usize = 3; -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]; 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_507] = [__v_0, __v_2, __v_2]; record.function_queries[507].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_507] = { let __args: [G; IN_507] = [__v_5, __v_8]; 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_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_507] = [__v_9, __v_12, __v_11]; record.function_queries[507].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_507] = { let __args: [G; IN_507] = [__v_5, __v_8]; 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_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_507] = [__v_9, __v_12, __v_13]; record.function_queries[507].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_507] = [__v_0, __v_7, __v_7]; record.function_queries[507].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_508: usize = 4; -const IN_508: usize = 4; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_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_506] = [__v_0]; record.function_queries[506].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_506] = [__v_0]; record.function_queries[506].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = (__v_7 - __v_3); let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_1, __v_11]; 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 __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_369] = { let __args: [G; IN_369] = [__v_12, __v_14, __v_15]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_16, __v_3, __v_15]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_506] = [__v_17]; record.function_queries[506].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __v_10: G = G::from_u64(3); let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_7, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_8, __v_1, __v_2, __v_3]; 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_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_506] = [__v_14]; record.function_queries[506].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(4); let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_7, __v_1, __v_2, __v_3]; 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_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_506] = { let __args: [G; IN_506] = [__v_8, __v_1, __v_2, __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_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_506] = [__v_16]; record.function_queries[506].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_10: G = G::from_u64(5); let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_7, __v_1, __v_2, __v_3]; 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_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_506] = { let __args: [G; IN_506] = [__v_8, __v_1, __v_2, __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_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_506] = [__v_16]; record.function_queries[506].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_10: G = G::from_u64(6); let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_7, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_8, __v_1, __v_2, __v_3]; 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_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_506] = { let __args: [G; IN_506] = [__v_9, __v_1, __v_2, __v_14]; 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_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_506] = [__v_16]; record.function_queries[506].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_10: G = G::from_u64(8); let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_9, __v_1, __v_2, __v_3]; 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_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_506] = [__v_12]; record.function_queries[506].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_506] = [__v_0]; record.function_queries[506].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_507: usize = 4; +const IN_507: usize = 4; +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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; 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_4: G = __r_arr[0]; match __v_4.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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_498] = { let __args: [G; IN_498] = [__v_0, __v_6]; 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 __v_7: G = __r_arr[0]; let __ret: [G; OUT_507] = [__v_7]; record.function_queries[507].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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_1]; 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 __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(511, (&__args[..]))?) { [G::ZERO; OUT_511] } else { let (__hash, __hit) = record.function_queries[511].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[511].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { (*(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511])) }; __ret }, _ => { aiur_fn_511::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_507] = [__v_10]; record.function_queries[507].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_0, __v_10, __v_9]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(511, (&__args[..]))?) { [G::ZERO; OUT_511] } else { let (__hash, __hit) = record.function_queries[511].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[511].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { (*(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511])) }; __ret }, _ => { aiur_fn_511::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_507] = [__v_12]; record.function_queries[507].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(509, (&__args[..]))?) { [G::ZERO; OUT_509] } else { let (__hash, __hit) = record.function_queries[509].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[509].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { (*(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509])) }; __ret }, _ => { aiur_fn_509::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_507] = [__v_12]; record.function_queries[507].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, } }, _ => { let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(511, (&__args[..]))?) { [G::ZERO; OUT_511] } else { let (__hash, __hit) = record.function_queries[511].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[511].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { (*(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511])) }; __ret }, _ => { aiur_fn_511::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_507] = [__v_9]; record.function_queries[507].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_508: usize = 1; +const IN_508: usize = 1; const OUT_508: usize = 1; -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 __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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_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 __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = (__v_3 - __v_9); let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_508] = [__v_12]; record.function_queries[508].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_5, __v_1, __v_3, __v_8]; 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 __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_8, __v_9, __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_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); let __v_14: G = { let __values: [G; 5] = [__v_12, __v_9, __v_13, __v_1, __v_8]; 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_504] = { let __args: [G; IN_504] = [__v_6, __v_14, __v_11, __v_13]; 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 __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(5); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_9, __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 __ret: [G; OUT_508] = [__v_17]; record.function_queries[508].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_5, __v_1, __v_3, __v_8]; 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 __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_8, __v_9, __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_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); let __v_14: G = { let __values: [G; 5] = [__v_12, __v_9, __v_13, __v_1, __v_8]; 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_504] = { let __args: [G; IN_504] = [__v_6, __v_14, __v_11, __v_13]; 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 __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_15, __v_11]; 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 __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_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: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; match __v_17.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_10, __v_18]; 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_22: G = __r_arr[0]; let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_508] = [__v_24]; record.function_queries[508].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, 6u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_5, __v_1, __v_3, __v_8]; 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 __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_6, __v_1, __v_2, __v_3]; 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 __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_11, __v_9, __v_2]; 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_12: G = __r_arr[0]; 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("delayed let value type mismatch".to_string()) }); } let __v_14: G = G::from_u64(2); let __v_15: G = { let __values: [G; 5] = [__v_14, __v_9, __v_6, __v_1, __v_3]; 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_504] = { let __args: [G; IN_504] = [__v_7, __v_15, __v_2, __v_3]; 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 __v_16: G = __r_arr[0]; let __ret: [G; OUT_508] = [__v_16]; record.function_queries[508].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_5, __v_1, __v_2, __v_3]; 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 __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __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_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_504] = { let __args: [G; IN_504] = [__v_6, __v_1, __v_2, __v_3]; 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 __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_14, __v_11, __v_2]; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("delayed application type mismatch".to_string()) }); } let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_12, __v_17, __v_16]; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_12, __v_19, __v_19]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_508] = [__v_20]; record.function_queries[508].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_6, __v_1, __v_3, __v_19]; 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 __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_12, __v_20, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_508] = [__v_21]; record.function_queries[508].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_3, __v_8]; 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 __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_9, __v_2]; 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 __v_10: G = __r_arr[0]; let __ret: [G; OUT_508] = [__v_10]; record.function_queries[508].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __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_508] = [__v_6]; record.function_queries[508].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_508] = [__v_6]; record.function_queries[508].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_4]; 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 __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_508] = [__v_7]; record.function_queries[508].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_508] = [__v_8]; record.function_queries[508].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_509: usize = 4; const IN_509: usize = 4; 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 = 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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_509] = [__v_0]; record.function_queries[509].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_0, __v_2, __v_8]; 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_509] = [__v_9]; record.function_queries[509].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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_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_787] = { let __args: [G; IN_787] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_8]; }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_8, __v_2, __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_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(518, (&__args[..]))?) { [G::ZERO; OUT_518] } else { let (__hash, __hit) = record.function_queries[518].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[518].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { (*(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518])) }; __ret }, _ => { aiur_fn_518::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __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_509] = { let __args: [G; IN_509] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(509, (&__args[..]))?) { [G::ZERO; OUT_509] } else { let (__hash, __hit) = record.function_queries[509].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[509].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { (*(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509])) }; __ret }, _ => { aiur_fn_509::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_509] = [__v_15]; record.function_queries[509].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_0]; }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_0, __v_2, __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_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_12, __v_3]; 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_13: 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_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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(518, (&__args[..]))?) { [G::ZERO; OUT_518] } else { let (__hash, __hit) = record.function_queries[518].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[518].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { (*(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518])) }; __ret }, _ => { aiur_fn_518::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = G::from_u64(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_18, __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_509] = { let __args: [G; IN_509] = [__v_16, __v_6, __v_21, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(509, (&__args[..]))?) { [G::ZERO; OUT_509] } else { let (__hash, __hit) = record.function_queries[509].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[509].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { (*(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509])) }; __ret }, _ => { aiur_fn_509::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_509] = [__v_22]; record.function_queries[509].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +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 = 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_365] = { let __args: [G; IN_365] = [__v_0, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(510, (&__args[..]))?) { [G::ZERO; OUT_510] } else { let (__hash, __hit) = record.function_queries[510].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[510].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { (*(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510])) }; __ret }, _ => { aiur_fn_510::(__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_373] = { let __args: [G; IN_373] = [__v_0, __v_7, __v_4]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_3 - __v_8); let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_9, __v_6, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(511, (&__args[..]))?) { [G::ZERO; OUT_511] } else { let (__hash, __hit) = record.function_queries[511].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[511].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { (*(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511])) }; __ret }, _ => { aiur_fn_511::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_12, __v_8, __v_4]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_509] = [__v_13]; record.function_queries[509].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_510: usize = 2; const IN_510: usize = 2; -const OUT_510: usize = 1; -fn aiur_fn_510(inp: [G; IN_510], 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 = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(389, (&__args[..]))?) { [G::ZERO; OUT_389] } else { let (__hash, __hit) = record.function_queries[389].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[389].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[389].bump_multiplicity(__i); } let __ret: [G; OUT_389] = unsafe { (*(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389])) }; __ret }, _ => { aiur_fn_389::(__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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(0); let __v_7: G = { let __values: [G; 4] = [__v_2, __v_3, __v_5, __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_510] = [__v_7]; record.function_queries[510].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(2); let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = []; 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_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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(0); let __v_7: G = { let __values: [G; 4] = [__v_2, __v_3, __v_5, __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_510] = [__v_7]; record.function_queries[510].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const OUT_510: usize = 3; +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 = 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_510] = [__v_0, __v_2, __v_2]; record.function_queries[510].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_510] = { let __args: [G; IN_510] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(510, (&__args[..]))?) { [G::ZERO; OUT_510] } else { let (__hash, __hit) = record.function_queries[510].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[510].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { (*(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510])) }; __ret }, _ => { aiur_fn_510::(__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_510] = [__v_9, __v_12, __v_11]; record.function_queries[510].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_510] = { let __args: [G; IN_510] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(510, (&__args[..]))?) { [G::ZERO; OUT_510] } else { let (__hash, __hit) = record.function_queries[510].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[510].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { (*(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510])) }; __ret }, _ => { aiur_fn_510::(__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_510] = [__v_9, __v_12, __v_13]; record.function_queries[510].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_510] = [__v_0, __v_7, __v_7]; record.function_queries[510].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_511: usize = 4; const IN_511: usize = 4; 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 = 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_344] = { let __args: [G; IN_344] = [__v_0, __v_1]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(512, (&__args[..]))?) { [G::ZERO; OUT_512] } else { let (__hash, __hit) = record.function_queries[512].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[512].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { (*(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512])) }; __ret }, _ => { aiur_fn_512::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: 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_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() { 1u64 => { 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 __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_7, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_511] = [__v_12]; record.function_queries[511].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } -const INPUT_SIZE_512: usize = 3; -const IN_512: usize = 3; +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 = 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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_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 __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = (__v_3 - __v_9); let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_8, __v_10, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_511] = [__v_12]; record.function_queries[511].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1, __v_3, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_8, __v_9, __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_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); let __v_14: G = { let __values: [G; 5] = [__v_12, __v_9, __v_13, __v_1, __v_8]; 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_507] = { let __args: [G; IN_507] = [__v_6, __v_14, __v_11, __v_13]; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(5); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_9, __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 __ret: [G; OUT_511] = [__v_17]; record.function_queries[511].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1, __v_3, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_8, __v_9, __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_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); let __v_14: G = { let __values: [G; 5] = [__v_12, __v_9, __v_13, __v_1, __v_8]; 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_507] = { let __args: [G; IN_507] = [__v_6, __v_14, __v_11, __v_13]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_15, __v_11]; 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_16: 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_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: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; match __v_17.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_10, __v_18]; 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_22: G = __r_arr[0]; let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_511] = [__v_24]; record.function_queries[511].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, 6u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1, __v_3, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_6, __v_1, __v_2, __v_3]; 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]; let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_11, __v_9, __v_2]; 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_12: G = __r_arr[0]; 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("delayed let value type mismatch".to_string()) }); } let __v_14: G = G::from_u64(2); let __v_15: G = { let __values: [G; 5] = [__v_14, __v_9, __v_6, __v_1, __v_3]; 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_507] = { let __args: [G; IN_507] = [__v_7, __v_15, __v_2, __v_3]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_511] = [__v_16]; record.function_queries[511].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_8, __v_2]; 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_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_507] = { let __args: [G; IN_507] = [__v_6, __v_1, __v_2, __v_3]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_14, __v_11, __v_2]; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("delayed application type mismatch".to_string()) }); } let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_12, __v_17, __v_16]; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_12, __v_19, __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_20: G = __r_arr[0]; let __ret: [G; OUT_511] = [__v_20]; record.function_queries[511].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_6, __v_1, __v_3, __v_19]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_12, __v_20, __v_19]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_511] = [__v_21]; record.function_queries[511].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_0, __v_1, __v_3, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_9, __v_2]; 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 __v_10: G = __r_arr[0]; let __ret: [G; OUT_511] = [__v_10]; record.function_queries[511].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_512: usize = 4; +const IN_512: usize = 4; 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 = 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_425] = { let __args: [G; IN_425] = [__v_0, __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_3: G = __r_arr[0]; let __ret: [G; OUT_512] = [__v_3]; record.function_queries[512].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __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_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() { 5u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __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 __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(512, (&__args[..]))?) { [G::ZERO; OUT_512] } else { let (__hash, __hit) = record.function_queries[512].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[512].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { (*(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512])) }; __ret }, _ => { aiur_fn_512::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_512] = [__v_12]; record.function_queries[512].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_512] = [__v_3]; record.function_queries[512].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_513: usize = 3; -const IN_513: usize = 3; -const OUT_513: usize = 0; -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 = 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_513] = []; record.function_queries[513].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__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_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_332] = { let __args: [G; IN_332] = [__v_3, __v_5]; 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 = 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("projection on a Prop structure: field is not a Prop".to_string()) }); } let __ret: [G; OUT_513] = []; record.function_queries[513].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 = 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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_512] = [__v_0]; record.function_queries[512].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_2, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_512] = [__v_9]; record.function_queries[512].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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_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_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_8]; }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_8, __v_2, __v_12]; 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_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(521, (&__args[..]))?) { [G::ZERO; OUT_521] } else { let (__hash, __hit) = record.function_queries[521].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[521].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { (*(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521])) }; __ret }, _ => { aiur_fn_521::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __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_512] = { let __args: [G; IN_512] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(512, (&__args[..]))?) { [G::ZERO; OUT_512] } else { let (__hash, __hit) = record.function_queries[512].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[512].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { (*(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512])) }; __ret }, _ => { aiur_fn_512::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_512] = [__v_15]; record.function_queries[512].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_0]; }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_2, __v_12]; 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_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_12, __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_13: 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_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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(521, (&__args[..]))?) { [G::ZERO; OUT_521] } else { let (__hash, __hit) = record.function_queries[521].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[521].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { (*(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521])) }; __ret }, _ => { aiur_fn_521::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = G::from_u64(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_18, __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_512] = { let __args: [G; IN_512] = [__v_16, __v_6, __v_21, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(512, (&__args[..]))?) { [G::ZERO; OUT_512] } else { let (__hash, __hit) = record.function_queries[512].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[512].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { (*(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512])) }; __ret }, _ => { aiur_fn_512::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_512] = [__v_22]; record.function_queries[512].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_513: usize = 2; +const IN_513: usize = 2; +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 = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = []; 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_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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(0); let __v_7: G = { let __values: [G; 4] = [__v_2, __v_3, __v_5, __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_513] = [__v_7]; record.function_queries[513].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(2); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = []; 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_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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(0); let __v_7: G = { let __values: [G; 4] = [__v_2, __v_3, __v_5, __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_513] = [__v_7]; record.function_queries[513].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_514: usize = 4; const IN_514: usize = 4; -const OUT_514: usize = 0; -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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_514] = []; record.function_queries[514].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__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_332] = { let __args: [G; IN_332] = [__v_4, __v_6]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_514] = []; record.function_queries[514].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_2]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) }); } let __ret: [G; OUT_514] = []; record.function_queries[514].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_515: usize = 7; -const IN_515: usize = 7; +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 = 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_347] = { let __args: [G; IN_347] = [__v_0, __v_1]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(515, (&__args[..]))?) { [G::ZERO; OUT_515] } else { let (__hash, __hit) = record.function_queries[515].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[515].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { (*(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515])) }; __ret }, _ => { aiur_fn_515::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: 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_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() { 1u64 => { 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 __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_7, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_514] = [__v_12]; record.function_queries[514].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } +const INPUT_SIZE_515: usize = 3; +const IN_515: usize = 3; 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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 4] = { let __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_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 __v_11: G = (__v_1 - __v_2); match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(513, (&__args[..]))?) { [G::ZERO; OUT_513] } else { let (__hash, __hit) = record.function_queries[513].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[513].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[513].bump_multiplicity(__i); } let __ret: [G; OUT_513] = unsafe { (*(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513])) }; __ret }, _ => { aiur_fn_513::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_515] = [__v_8]; record.function_queries[515].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(514, (&__args[..]))?) { [G::ZERO; OUT_514] } else { let (__hash, __hit) = record.function_queries[514].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[514].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { (*(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514])) }; __ret }, _ => { aiur_fn_514::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = G::from_u64(8); let __v_13: G = { let __values: [G; 4] = [__v_12, __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_14: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 + __v_16); let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(515, (&__args[..]))?) { [G::ZERO; OUT_515] } else { let (__hash, __hit) = record.function_queries[515].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[515].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { (*(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515])) }; __ret }, _ => { aiur_fn_515::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_515] = [__v_18]; record.function_queries[515].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_516: usize = 4; -const IN_516: usize = 4; -const OUT_516: usize = 1; -fn aiur_fn_516(inp: [G; IN_516], 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 = 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_495] = { let __args: [G; IN_495] = [__v_2, __v_3]; 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 __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __v_3]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_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 => { if (__v_9 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) }); } let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_9]; 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_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() { 5u64 => { let __v_25: G = G::from_u64(1); if (__v_18 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) }); } let __v_26: G = G::from_u64(0); let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_20, __v_21, __v_26]; 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_27: 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_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: 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_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]; match __v_28.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_30, __v_10]; 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_40: G = __r_arr[0]; let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_40, __v_7, __v_16]; 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_41: G = __r_arr[0]; let __v_42: G = (__v_16 + __v_17); let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(511, (&__args[..]))?) { [G::ZERO; OUT_511] } else { let (__hash, __hit) = record.function_queries[511].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[511].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { (*(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511])) }; __ret }, _ => { aiur_fn_511::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(515, (&__args[..]))?) { [G::ZERO; OUT_515] } else { let (__hash, __hit) = record.function_queries[515].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[515].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { (*(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515])) }; __ret }, _ => { aiur_fn_515::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_516] = [__v_45]; record.function_queries[516].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_517: usize = 2; -const IN_517: usize = 2; -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 = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1]; 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 __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_2, __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_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_517] = [__v_5]; record.function_queries[517].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_518: usize = 3; -const IN_518: usize = 3; -const OUT_518: usize = 0; -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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_2]; 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 __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_3, __v_1, __v_2]; 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_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("inferred type is not def-eq to the expected type".to_string()) }); } let __ret: [G; OUT_518] = []; 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; +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 = 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_428] = { let __args: [G; IN_428] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_515] = [__v_3]; record.function_queries[515].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]; 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_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() { 5u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __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 __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(515, (&__args[..]))?) { [G::ZERO; OUT_515] } else { let (__hash, __hit) = record.function_queries[515].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[515].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { (*(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515])) }; __ret }, _ => { aiur_fn_515::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_515] = [__v_12]; record.function_queries[515].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_515] = [__v_3]; record.function_queries[515].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_516: usize = 3; +const IN_516: usize = 3; +const OUT_516: usize = 0; +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 = 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_516] = []; record.function_queries[516].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__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_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_335] = { let __args: [G; IN_335] = [__v_3, __v_5]; 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 = 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("projection on a Prop structure: field is not a Prop".to_string()) }); } let __ret: [G; OUT_516] = []; record.function_queries[516].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_517: usize = 4; +const IN_517: usize = 4; +const OUT_517: usize = 0; +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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_517] = []; record.function_queries[517].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__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_335] = { let __args: [G; IN_335] = [__v_4, __v_6]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_517] = []; record.function_queries[517].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_2]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) }); } let __ret: [G; OUT_517] = []; record.function_queries[517].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_518: usize = 7; +const IN_518: usize = 7; +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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 4] = { let __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_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 __v_11: G = (__v_1 - __v_2); match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(516, (&__args[..]))?) { [G::ZERO; OUT_516] } else { let (__hash, __hit) = record.function_queries[516].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[516].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[516].bump_multiplicity(__i); } let __ret: [G; OUT_516] = unsafe { (*(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516])) }; __ret }, _ => { aiur_fn_516::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_518] = [__v_8]; record.function_queries[518].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = G::from_u64(8); let __v_13: G = { let __values: [G; 4] = [__v_12, __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_14: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_9, __v_13, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 + __v_16); let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(518, (&__args[..]))?) { [G::ZERO; OUT_518] } else { let (__hash, __hit) = record.function_queries[518].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[518].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { (*(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518])) }; __ret }, _ => { aiur_fn_518::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_518] = [__v_18]; record.function_queries[518].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +const INPUT_SIZE_519: usize = 4; +const IN_519: usize = 4; 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(240); let __v_1: G = G::from_u64(241); let __v_2: G = G::from_u64(94); let __v_3: G = G::from_u64(208); let __v_4: G = G::from_u64(121); let __v_5: G = G::from_u64(130); let __v_6: G = G::from_u64(47); let __v_7: G = G::from_u64(6); let __v_8: G = G::from_u64(232); let __v_9: G = G::from_u64(46); let __v_10: G = G::from_u64(54); let __v_11: G = G::from_u64(102); let __v_12: G = G::from_u64(75); let __v_13: G = G::from_u64(246); let __v_14: G = G::from_u64(30); let __v_15: G = G::from_u64(126); let __v_16: G = G::from_u64(91); let __v_17: G = G::from_u64(123); let __v_18: G = G::from_u64(11); let __v_19: G = G::from_u64(65); let __v_20: G = G::from_u64(85); let __v_21: G = G::from_u64(21); let __v_22: G = G::from_u64(39); let __v_23: G = G::from_u64(98); let __v_24: G = G::from_u64(197); let __v_25: G = G::from_u64(19); let __v_26: G = G::from_u64(254); let __v_27: G = G::from_u64(225); let __v_28: 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_4, __v_15, __v_16, __v_14, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_22, __v_12, __v_26, __v_27]; 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_519] = [__v_28]; 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; +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 = 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_498] = { let __args: [G; IN_498] = [__v_2, __v_3]; 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 __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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_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 => { if (__v_9 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) }); } let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_9]; 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_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() { 5u64 => { let __v_25: G = G::from_u64(1); if (__v_18 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) }); } let __v_26: G = G::from_u64(0); let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_20, __v_21, __v_26]; 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_27: 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_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: 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_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]; match __v_28.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_30, __v_10]; 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_40: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_40, __v_7, __v_16]; 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_41: G = __r_arr[0]; let __v_42: G = (__v_16 + __v_17); let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(514, (&__args[..]))?) { [G::ZERO; OUT_514] } else { let (__hash, __hit) = record.function_queries[514].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[514].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { (*(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514])) }; __ret }, _ => { aiur_fn_514::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(518, (&__args[..]))?) { [G::ZERO; OUT_518] } else { let (__hash, __hit) = record.function_queries[518].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[518].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { (*(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518])) }; __ret }, _ => { aiur_fn_518::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_519] = [__v_45]; record.function_queries[519].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +const INPUT_SIZE_520: usize = 2; +const IN_520: usize = 2; 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(138); let __v_1: G = G::from_u64(93); let __v_2: G = G::from_u64(94); let __v_3: G = G::from_u64(238); let __v_4: G = G::from_u64(65); let __v_5: G = G::from_u64(74); let __v_6: G = G::from_u64(47); let __v_7: G = G::from_u64(165); let __v_8: G = G::from_u64(149); let __v_9: G = G::from_u64(107); let __v_10: G = G::from_u64(116); let __v_11: G = G::from_u64(232); let __v_12: G = G::from_u64(50); let __v_13: G = G::from_u64(58); let __v_14: G = G::from_u64(32); let __v_15: G = G::from_u64(80); let __v_16: G = G::from_u64(141); let __v_17: G = G::from_u64(119); let __v_18: G = G::from_u64(78); let __v_19: G = G::from_u64(209); let __v_20: G = G::from_u64(181); let __v_21: G = G::from_u64(96); let __v_22: G = G::from_u64(63); let __v_23: G = G::from_u64(85); let __v_24: G = G::from_u64(231); let __v_25: G = G::from_u64(173); let __v_26: G = G::from_u64(137); let __v_27: G = G::from_u64(211); let __v_28: G = G::from_u64(230); let __v_29: 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_10, __v_25, __v_26, __v_9, __v_27, __v_28, __v_24]; 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_520] = [__v_29]; 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(124); let __v_1: G = G::from_u64(73); let __v_2: G = G::from_u64(119); let __v_3: G = G::from_u64(25); let __v_4: G = G::from_u64(110); let __v_5: G = G::from_u64(149); let __v_6: G = G::from_u64(190); let __v_7: G = G::from_u64(42); let __v_8: G = G::from_u64(117); let __v_9: G = G::from_u64(159); let __v_10: G = G::from_u64(201); let __v_11: G = G::from_u64(198); let __v_12: G = G::from_u64(209); let __v_13: G = G::from_u64(83); let __v_14: G = G::from_u64(61); let __v_15: G = G::from_u64(184); let __v_16: G = G::from_u64(218); let __v_17: G = G::from_u64(89); let __v_18: G = G::from_u64(47); let __v_19: G = G::from_u64(6); let __v_20: G = G::from_u64(65); let __v_21: G = G::from_u64(155); let __v_22: G = G::from_u64(21); let __v_23: G = G::from_u64(93); let __v_24: G = G::from_u64(136); let __v_25: G = G::from_u64(131); let __v_26: G = G::from_u64(51); let __v_27: G = G::from_u64(200); let __v_28: G = G::from_u64(221); let __v_29: G = G::from_u64(137); let __v_30: G = G::from_u64(49); let __v_31: 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_1, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_521] = [__v_31]; record.function_queries[521].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_0, __v_1]; 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 __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_1]; 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_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_520] = [__v_5]; record.function_queries[520].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_521: usize = 3; +const IN_521: usize = 3; +const OUT_521: usize = 0; +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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_0, __v_2]; 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 __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_1, __v_2]; 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_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("inferred type is not def-eq to the expected type".to_string()) }); } let __ret: [G; OUT_521] = []; 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(54); let __v_1: G = G::from_u64(61); let __v_2: G = G::from_u64(7); let __v_3: G = G::from_u64(17); let __v_4: G = G::from_u64(130); let __v_5: G = G::from_u64(190); let __v_6: G = G::from_u64(65); let __v_7: G = G::from_u64(78); let __v_8: G = G::from_u64(26); let __v_9: G = G::from_u64(88); let __v_10: G = G::from_u64(89); let __v_11: G = G::from_u64(155); let __v_12: G = G::from_u64(131); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(225); let __v_15: G = G::from_u64(159); let __v_16: G = G::from_u64(135); let __v_17: G = G::from_u64(55); let __v_18: G = G::from_u64(35); let __v_19: G = G::from_u64(5); let __v_20: G = G::from_u64(79); let __v_21: G = G::from_u64(66); let __v_22: G = G::from_u64(186); let __v_23: G = G::from_u64(105); let __v_24: G = G::from_u64(112); let __v_25: G = G::from_u64(90); let __v_26: G = G::from_u64(175); let __v_27: G = G::from_u64(239); let __v_28: G = G::from_u64(39); let __v_29: G = G::from_u64(218); 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_11, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_16, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_522] = [__v_30]; record.function_queries[522].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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(123); let __v_1: G = G::from_u64(182); let __v_2: G = G::from_u64(89); let __v_3: G = G::from_u64(135); let __v_4: G = G::from_u64(102); let __v_5: G = G::from_u64(113); let __v_6: G = G::from_u64(224); let __v_7: G = G::from_u64(61); let __v_8: G = G::from_u64(7); let __v_9: G = G::from_u64(49); let __v_10: G = G::from_u64(196); let __v_11: G = G::from_u64(86); let __v_12: G = G::from_u64(232); let __v_13: G = G::from_u64(148); let __v_14: G = G::from_u64(206); let __v_15: G = G::from_u64(158); let __v_16: G = G::from_u64(111); let __v_17: G = G::from_u64(125); let __v_18: G = G::from_u64(37); let __v_19: G = G::from_u64(10); let __v_20: G = G::from_u64(180); let __v_21: G = G::from_u64(174); let __v_22: G = G::from_u64(112); let __v_23: G = G::from_u64(17); let __v_24: G = G::from_u64(192); let __v_25: G = G::from_u64(142); let __v_26: G = G::from_u64(36); let __v_27: G = G::from_u64(83); let __v_28: G = G::from_u64(33); let __v_29: G = G::from_u64(39); 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_12, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_7, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_522] = [__v_30]; 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(140); let __v_1: G = G::from_u64(192); let __v_2: G = G::from_u64(225); let __v_3: G = G::from_u64(54); let __v_4: G = G::from_u64(12); let __v_5: G = G::from_u64(27); let __v_6: G = G::from_u64(41); let __v_7: G = G::from_u64(16); let __v_8: G = G::from_u64(141); let __v_9: G = G::from_u64(171); let __v_10: G = G::from_u64(61); let __v_11: G = G::from_u64(97); let __v_12: G = G::from_u64(114); let __v_13: G = G::from_u64(231); let __v_14: G = G::from_u64(252); let __v_15: G = G::from_u64(232); let __v_16: G = G::from_u64(169); let __v_17: G = G::from_u64(170); let __v_18: G = G::from_u64(150); let __v_19: G = G::from_u64(64); let __v_20: G = G::from_u64(218); let __v_21: G = G::from_u64(164); let __v_22: G = G::from_u64(187); let __v_23: G = G::from_u64(233); let __v_24: G = G::from_u64(155); let __v_25: G = G::from_u64(161); let __v_26: G = G::from_u64(48); let __v_27: G = G::from_u64(93); let __v_28: G = G::from_u64(35); let __v_29: G = G::from_u64(98); let __v_30: G = G::from_u64(75); let __v_31: 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_18, __v_28, __v_29, __v_30]; 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_523] = [__v_31]; record.function_queries[523].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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(241); let __v_1: G = G::from_u64(222); let __v_2: G = G::from_u64(113); let __v_3: G = G::from_u64(3); let __v_4: G = G::from_u64(128); let __v_5: G = G::from_u64(46); let __v_6: G = G::from_u64(188); let __v_7: G = G::from_u64(83); let __v_8: G = G::from_u64(9); let __v_9: G = G::from_u64(4); let __v_10: G = G::from_u64(27); let __v_11: G = G::from_u64(218); let __v_12: G = G::from_u64(173); let __v_13: G = G::from_u64(234); let __v_14: G = G::from_u64(74); let __v_15: G = G::from_u64(101); let __v_16: G = G::from_u64(45); let __v_17: G = G::from_u64(84); let __v_18: G = G::from_u64(175); let __v_19: G = G::from_u64(55); let __v_20: G = G::from_u64(230); let __v_21: G = G::from_u64(106); let __v_22: G = G::from_u64(170); let __v_23: G = G::from_u64(244); let __v_24: G = G::from_u64(23); let __v_25: G = G::from_u64(135); let __v_26: G = G::from_u64(177); let __v_27: G = G::from_u64(216); let __v_28: G = G::from_u64(145); let __v_29: G = G::from_u64(149); let __v_30: G = G::from_u64(87); let __v_31: 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_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_523] = [__v_31]; 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(173); let __v_1: G = G::from_u64(37); let __v_2: G = G::from_u64(191); let __v_3: G = G::from_u64(210); let __v_4: G = G::from_u64(7); let __v_5: G = G::from_u64(186); let __v_6: G = G::from_u64(232); let __v_7: G = G::from_u64(50); let __v_8: G = G::from_u64(199); let __v_9: G = G::from_u64(61); let __v_10: G = G::from_u64(92); let __v_11: G = G::from_u64(230); let __v_12: G = G::from_u64(20); let __v_13: G = G::from_u64(190); let __v_14: G = G::from_u64(34); let __v_15: G = G::from_u64(239); let __v_16: G = G::from_u64(152); let __v_17: G = G::from_u64(98); let __v_18: G = G::from_u64(225); let __v_19: G = G::from_u64(16); let __v_20: G = G::from_u64(248); let __v_21: G = G::from_u64(209); let __v_22: G = G::from_u64(122); let __v_23: G = G::from_u64(80); let __v_24: G = G::from_u64(100); let __v_25: G = G::from_u64(255); let __v_26: G = G::from_u64(183); let __v_27: G = G::from_u64(96); let __v_28: G = G::from_u64(62); let __v_29: G = G::from_u64(238); 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_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_9]; 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_524] = [__v_30]; record.function_queries[524].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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(175); let __v_1: G = G::from_u64(88); let __v_2: G = G::from_u64(107); let __v_3: G = G::from_u64(7); let __v_4: G = G::from_u64(84); let __v_5: G = G::from_u64(110); let __v_6: G = G::from_u64(31); let __v_7: G = G::from_u64(202); let __v_8: G = G::from_u64(154); let __v_9: G = G::from_u64(176); let __v_10: G = G::from_u64(120); let __v_11: G = G::from_u64(13); let __v_12: G = G::from_u64(28); let __v_13: G = G::from_u64(35); let __v_14: G = G::from_u64(106); let __v_15: G = G::from_u64(248); let __v_16: G = G::from_u64(211); let __v_17: G = G::from_u64(96); let __v_18: G = G::from_u64(196); let __v_19: G = G::from_u64(198); let __v_20: G = G::from_u64(187); let __v_21: G = G::from_u64(50); let __v_22: G = G::from_u64(12); let __v_23: G = G::from_u64(208); let __v_24: G = G::from_u64(62); let __v_25: G = G::from_u64(201); let __v_26: G = G::from_u64(99); let __v_27: G = G::from_u64(218); let __v_28: G = G::from_u64(150); let __v_29: 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_20, __v_22, __v_23, __v_24, __v_25, __v_7, __v_26, __v_16, __v_27, __v_28]; 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_524] = [__v_29]; 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(227); let __v_1: G = G::from_u64(101); let __v_2: G = G::from_u64(143); let __v_3: G = G::from_u64(80); let __v_4: G = G::from_u64(220); let __v_5: G = G::from_u64(81); let __v_6: G = G::from_u64(35); let __v_7: G = G::from_u64(239); let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(33); let __v_10: G = G::from_u64(53); let __v_11: G = G::from_u64(136); let __v_12: G = G::from_u64(222); let __v_13: G = G::from_u64(212); let __v_14: G = G::from_u64(198); let __v_15: G = G::from_u64(6); let __v_16: G = G::from_u64(63); let __v_17: G = G::from_u64(94); let __v_18: G = G::from_u64(219); let __v_19: G = G::from_u64(24); let __v_20: G = G::from_u64(149); let __v_21: G = G::from_u64(8); let __v_22: G = G::from_u64(172); let __v_23: G = G::from_u64(4); let __v_24: G = G::from_u64(144); let __v_25: G = G::from_u64(201); let __v_26: G = G::from_u64(55); let __v_27: G = G::from_u64(129); let __v_28: G = G::from_u64(9); let __v_29: 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_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_3, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_24, __v_28]; 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_525] = [__v_29]; record.function_queries[525].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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(54); let __v_1: G = G::from_u64(61); let __v_2: G = G::from_u64(7); let __v_3: G = G::from_u64(17); let __v_4: G = G::from_u64(130); let __v_5: G = G::from_u64(190); let __v_6: G = G::from_u64(65); let __v_7: G = G::from_u64(78); let __v_8: G = G::from_u64(26); let __v_9: G = G::from_u64(88); let __v_10: G = G::from_u64(89); let __v_11: G = G::from_u64(155); let __v_12: G = G::from_u64(131); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(225); let __v_15: G = G::from_u64(159); let __v_16: G = G::from_u64(135); let __v_17: G = G::from_u64(55); let __v_18: G = G::from_u64(35); let __v_19: G = G::from_u64(5); let __v_20: G = G::from_u64(79); let __v_21: G = G::from_u64(66); let __v_22: G = G::from_u64(186); let __v_23: G = G::from_u64(105); let __v_24: G = G::from_u64(112); let __v_25: G = G::from_u64(90); let __v_26: G = G::from_u64(175); let __v_27: G = G::from_u64(239); let __v_28: G = G::from_u64(39); let __v_29: G = G::from_u64(218); 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_11, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_16, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_525] = [__v_30]; 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(156); let __v_1: G = G::from_u64(145); let __v_2: G = G::from_u64(231); let __v_3: G = G::from_u64(157); let __v_4: G = G::from_u64(50); let __v_5: G = G::from_u64(34); let __v_6: G = G::from_u64(107); let __v_7: G = G::from_u64(162); let __v_8: G = G::from_u64(60); let __v_9: G = G::from_u64(189); let __v_10: G = G::from_u64(211); let __v_11: G = G::from_u64(48); let __v_12: G = G::from_u64(133); let __v_13: G = G::from_u64(27); let __v_14: G = G::from_u64(174); let __v_15: G = G::from_u64(196); let __v_16: G = G::from_u64(6); let __v_17: G = G::from_u64(104); let __v_18: G = G::from_u64(235); let __v_19: G = G::from_u64(64); let __v_20: G = G::from_u64(198); let __v_21: G = G::from_u64(243); let __v_22: G = G::from_u64(42); let __v_23: G = G::from_u64(248); let __v_24: G = G::from_u64(218); let __v_25: G = G::from_u64(197); let __v_26: G = G::from_u64(160); let __v_27: G = G::from_u64(75); let __v_28: G = G::from_u64(81); let __v_29: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_2, __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_7, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; 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_526] = [__v_29]; record.function_queries[526].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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(140); let __v_1: G = G::from_u64(192); let __v_2: G = G::from_u64(225); let __v_3: G = G::from_u64(54); let __v_4: G = G::from_u64(12); let __v_5: G = G::from_u64(27); let __v_6: G = G::from_u64(41); let __v_7: G = G::from_u64(16); let __v_8: G = G::from_u64(141); let __v_9: G = G::from_u64(171); let __v_10: G = G::from_u64(61); let __v_11: G = G::from_u64(97); let __v_12: G = G::from_u64(114); let __v_13: G = G::from_u64(231); let __v_14: G = G::from_u64(252); let __v_15: G = G::from_u64(232); let __v_16: G = G::from_u64(169); let __v_17: G = G::from_u64(170); let __v_18: G = G::from_u64(150); let __v_19: G = G::from_u64(64); let __v_20: G = G::from_u64(218); let __v_21: G = G::from_u64(164); let __v_22: G = G::from_u64(187); let __v_23: G = G::from_u64(233); let __v_24: G = G::from_u64(155); let __v_25: G = G::from_u64(161); let __v_26: G = G::from_u64(48); let __v_27: G = G::from_u64(93); let __v_28: G = G::from_u64(35); let __v_29: G = G::from_u64(98); let __v_30: G = G::from_u64(75); let __v_31: 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_18, __v_28, __v_29, __v_30]; 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_526] = [__v_31]; 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(160); let __v_1: G = G::from_u64(125); let __v_2: G = G::from_u64(181); let __v_3: G = G::from_u64(50); let __v_4: G = G::from_u64(116); let __v_5: G = G::from_u64(126); let __v_6: G = G::from_u64(101); let __v_7: G = G::from_u64(238); let __v_8: G = G::from_u64(119); let __v_9: G = G::from_u64(167); let __v_10: G = G::from_u64(186); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(80); let __v_13: G = G::from_u64(105); let __v_14: G = G::from_u64(189); let __v_15: G = G::from_u64(241); let __v_16: G = G::from_u64(247); let __v_17: G = G::from_u64(9); let __v_18: G = G::from_u64(206); let __v_19: G = G::from_u64(13); let __v_20: G = G::from_u64(96); let __v_21: G = G::from_u64(184); let __v_22: G = G::from_u64(60); let __v_23: G = G::from_u64(148); let __v_24: G = G::from_u64(244); let __v_25: G = G::from_u64(14); let __v_26: G = G::from_u64(94); let __v_27: G = G::from_u64(87); let __v_28: G = G::from_u64(89); let __v_29: G = G::from_u64(90); 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_10, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_19, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_527] = [__v_30]; record.function_queries[527].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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(92); let __v_1: G = G::from_u64(153); let __v_2: G = G::from_u64(220); let __v_3: G = G::from_u64(97); let __v_4: G = G::from_u64(136); let __v_5: G = G::from_u64(158); let __v_6: G = G::from_u64(74); let __v_7: G = G::from_u64(30); let __v_8: G = G::from_u64(6); let __v_9: G = G::from_u64(255); let __v_10: G = G::from_u64(111); let __v_11: G = G::from_u64(36); let __v_12: G = G::from_u64(209); let __v_13: G = G::from_u64(132); let __v_14: G = G::from_u64(101); let __v_15: G = G::from_u64(83); let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(140); let __v_18: G = G::from_u64(198); let __v_19: G = G::from_u64(43); let __v_20: G = G::from_u64(137); let __v_21: G = G::from_u64(250); let __v_22: G = G::from_u64(188); let __v_23: G = G::from_u64(35); let __v_24: G = G::from_u64(17); let __v_25: G = G::from_u64(91); let __v_26: G = G::from_u64(106); let __v_27: G = G::from_u64(118); let __v_28: G = G::from_u64(32); let __v_29: G = G::from_u64(104); 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_2, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_3, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_527] = [__v_30]; 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(230); let __v_1: G = G::from_u64(235); let __v_2: G = G::from_u64(163); let __v_3: G = G::from_u64(200); let __v_4: G = G::from_u64(180); let __v_5: G = G::from_u64(209); let __v_6: G = G::from_u64(159); let __v_7: G = G::from_u64(106); let __v_8: G = G::from_u64(16); let __v_9: G = G::from_u64(118); let __v_10: G = G::from_u64(179); let __v_11: G = G::from_u64(168); let __v_12: G = G::from_u64(154); let __v_13: G = G::from_u64(236); let __v_14: G = G::from_u64(97); let __v_15: G = G::from_u64(220); let __v_16: G = G::from_u64(203); let __v_17: G = G::from_u64(185); let __v_18: G = G::from_u64(96); let __v_19: G = G::from_u64(248); let __v_20: G = G::from_u64(61); let __v_21: G = G::from_u64(98); let __v_22: G = G::from_u64(172); let __v_23: G = G::from_u64(243); let __v_24: G = G::from_u64(90); let __v_25: G = G::from_u64(105); let __v_26: G = G::from_u64(201); let __v_27: G = G::from_u64(160); let __v_28: G = G::from_u64(164); let __v_29: 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_6, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_12, __v_21, __v_0, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; 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_528] = [__v_29]; record.function_queries[528].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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(147); let __v_1: G = G::from_u64(192); let __v_2: G = G::from_u64(234); let __v_3: G = G::from_u64(112); let __v_4: G = G::from_u64(197); let __v_5: G = G::from_u64(195); let __v_6: G = G::from_u64(63); let __v_7: G = G::from_u64(123); let __v_8: G = G::from_u64(206); let __v_9: G = G::from_u64(205); let __v_10: G = G::from_u64(64); let __v_11: G = G::from_u64(93); let __v_12: G = G::from_u64(253); let __v_13: G = G::from_u64(238); let __v_14: G = G::from_u64(92); let __v_15: G = G::from_u64(84); let __v_16: G = G::from_u64(113); let __v_17: G = G::from_u64(247); let __v_18: G = G::from_u64(74); let __v_19: G = G::from_u64(97); let __v_20: G = G::from_u64(248); let __v_21: G = G::from_u64(187); let __v_22: G = G::from_u64(11); let __v_23: G = G::from_u64(37); let __v_24: G = G::from_u64(82); let __v_25: G = G::from_u64(215); let __v_26: G = G::from_u64(255); let __v_27: G = G::from_u64(226); let __v_28: G = G::from_u64(129); let __v_29: G = G::from_u64(131); 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_13, __v_19, __v_20, __v_21, __v_19, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_528] = [__v_30]; 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(212); let __v_1: G = G::from_u64(148); let __v_2: G = G::from_u64(220); let __v_3: G = G::from_u64(96); let __v_4: G = G::from_u64(19); let __v_5: G = G::from_u64(134); let __v_6: G = G::from_u64(186); let __v_7: G = G::from_u64(142); let __v_8: G = G::from_u64(143); let __v_9: G = G::from_u64(11); let __v_10: G = G::from_u64(113); let __v_11: G = G::from_u64(31); let __v_12: G = G::from_u64(230); let __v_13: G = G::from_u64(42); let __v_14: G = G::from_u64(45); let __v_15: G = G::from_u64(171); let __v_16: G = G::from_u64(198); let __v_17: G = G::from_u64(72); let __v_18: G = G::from_u64(140); let __v_19: G = G::from_u64(246); let __v_20: G = G::from_u64(206); let __v_21: G = G::from_u64(151); let __v_22: G = G::from_u64(121); let __v_23: G = G::from_u64(110); let __v_24: G = G::from_u64(188); let __v_25: G = G::from_u64(58); let __v_26: G = G::from_u64(213); let __v_27: G = G::from_u64(254); let __v_28: G = G::from_u64(251); let __v_29: 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_3, __v_15, __v_3, __v_16, __v_17, __v_18, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_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_529] = [__v_29]; record.function_queries[529].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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(196); let __v_1: G = G::from_u64(76); let __v_2: G = G::from_u64(82); let __v_3: G = G::from_u64(133); let __v_4: G = G::from_u64(120); let __v_5: G = G::from_u64(218); let __v_6: G = G::from_u64(179); let __v_7: G = G::from_u64(144); let __v_8: G = G::from_u64(48); let __v_9: G = G::from_u64(136); let __v_10: G = G::from_u64(208); let __v_11: G = G::from_u64(100); let __v_12: G = G::from_u64(204); let __v_13: G = G::from_u64(155); let __v_14: G = G::from_u64(103); let __v_15: G = G::from_u64(157); let __v_16: G = G::from_u64(44); let __v_17: G = G::from_u64(14); let __v_18: G = G::from_u64(254); let __v_19: G = G::from_u64(115); let __v_20: G = G::from_u64(60); let __v_21: G = G::from_u64(28); let __v_22: G = G::from_u64(225); let __v_23: G = G::from_u64(27); let __v_24: G = G::from_u64(143); let __v_25: G = G::from_u64(173); let __v_26: G = G::from_u64(211); let __v_27: 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_6, __v_18, __v_19, __v_5, __v_20, __v_21, __v_22, __v_12, __v_15, __v_23, __v_24, __v_16, __v_25, __v_26]; 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_529] = [__v_27]; 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(252); let __v_1: G = G::from_u64(140); let __v_2: G = G::from_u64(68); let __v_3: G = G::from_u64(204); let __v_4: G = G::from_u64(151); let __v_5: G = G::from_u64(12); let __v_6: G = G::from_u64(24); let __v_7: G = G::from_u64(60); let __v_8: G = G::from_u64(205); let __v_9: G = G::from_u64(16); let __v_10: G = G::from_u64(162); let __v_11: G = G::from_u64(209); let __v_12: G = G::from_u64(235); let __v_13: G = G::from_u64(44); let __v_14: G = G::from_u64(132); let __v_15: G = G::from_u64(147); let __v_16: G = G::from_u64(7); let __v_17: G = G::from_u64(118); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(145); let __v_20: G = G::from_u64(245); let __v_21: G = G::from_u64(41); let __v_22: G = G::from_u64(176); let __v_23: G = G::from_u64(47); let __v_24: G = G::from_u64(112); let __v_25: G = G::from_u64(109); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(218); let __v_28: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_0, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_8, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_8, __v_21, __v_10, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; 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_530] = [__v_28]; record.function_queries[530].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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(106); let __v_1: G = G::from_u64(119); let __v_2: G = G::from_u64(57); let __v_3: G = G::from_u64(202); let __v_4: G = G::from_u64(116); let __v_5: G = G::from_u64(253); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(51); let __v_8: G = G::from_u64(221); let __v_9: G = G::from_u64(203); let __v_10: G = G::from_u64(28); let __v_11: G = G::from_u64(77); let __v_12: G = G::from_u64(152); let __v_13: G = G::from_u64(205); let __v_14: G = G::from_u64(228); let __v_15: G = G::from_u64(25); let __v_16: G = G::from_u64(32); let __v_17: G = G::from_u64(241); let __v_18: G = G::from_u64(115); let __v_19: G = G::from_u64(211); let __v_20: G = G::from_u64(184); let __v_21: G = G::from_u64(166); let __v_22: G = G::from_u64(250); let __v_23: G = G::from_u64(222); let __v_24: G = G::from_u64(117); let __v_25: G = G::from_u64(164); let __v_26: G = G::from_u64(155); let __v_27: G = G::from_u64(150); let __v_28: G = G::from_u64(236); let __v_29: G = G::from_u64(140); let __v_30: G = G::from_u64(173); let __v_31: 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_4, __v_27, __v_28, __v_29, __v_30]; 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_530] = [__v_31]; 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(252); let __v_1: G = G::from_u64(223); let __v_2: G = G::from_u64(24); let __v_3: G = G::from_u64(96); let __v_4: G = G::from_u64(173); let __v_5: G = G::from_u64(76); let __v_6: G = G::from_u64(214); let __v_7: G = G::from_u64(114); let __v_8: G = G::from_u64(35); let __v_9: G = G::from_u64(147); let __v_10: G = G::from_u64(146); let __v_11: G = G::from_u64(230); let __v_12: G = G::from_u64(14); let __v_13: G = G::from_u64(123); let __v_14: G = G::from_u64(73); let __v_15: G = G::from_u64(224); let __v_16: G = G::from_u64(36); let __v_17: G = G::from_u64(175); let __v_18: G = G::from_u64(4); let __v_19: G = G::from_u64(117); let __v_20: G = G::from_u64(115); let __v_21: G = G::from_u64(156); let __v_22: G = G::from_u64(58); let __v_23: G = G::from_u64(64); let __v_24: G = G::from_u64(25); let __v_25: G = G::from_u64(90); let __v_26: G = G::from_u64(145); let __v_27: G = G::from_u64(78); let __v_28: G = G::from_u64(174); let __v_29: G = G::from_u64(196); let __v_30: G = G::from_u64(44); let __v_31: 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_18]; 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_531] = [__v_31]; record.function_queries[531].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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(230); let __v_1: G = G::from_u64(235); let __v_2: G = G::from_u64(163); let __v_3: G = G::from_u64(200); let __v_4: G = G::from_u64(180); let __v_5: G = G::from_u64(209); let __v_6: G = G::from_u64(159); let __v_7: G = G::from_u64(106); let __v_8: G = G::from_u64(16); let __v_9: G = G::from_u64(118); let __v_10: G = G::from_u64(179); let __v_11: G = G::from_u64(168); let __v_12: G = G::from_u64(154); let __v_13: G = G::from_u64(236); let __v_14: G = G::from_u64(97); let __v_15: G = G::from_u64(220); let __v_16: G = G::from_u64(203); let __v_17: G = G::from_u64(185); let __v_18: G = G::from_u64(96); let __v_19: G = G::from_u64(248); let __v_20: G = G::from_u64(61); let __v_21: G = G::from_u64(98); let __v_22: G = G::from_u64(172); let __v_23: G = G::from_u64(243); let __v_24: G = G::from_u64(90); let __v_25: G = G::from_u64(105); let __v_26: G = G::from_u64(201); let __v_27: G = G::from_u64(160); let __v_28: G = G::from_u64(164); let __v_29: 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_6, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_12, __v_21, __v_0, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; 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_531] = [__v_29]; 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(29); let __v_1: G = G::from_u64(84); let __v_2: G = G::from_u64(128); let __v_3: G = G::from_u64(106); let __v_4: G = G::from_u64(177); let __v_5: G = G::from_u64(235); let __v_6: G = G::from_u64(199); let __v_7: G = G::from_u64(145); let __v_8: G = G::from_u64(225); let __v_9: G = G::from_u64(219); let __v_10: G = G::from_u64(150); let __v_11: G = G::from_u64(232); let __v_12: G = G::from_u64(141); let __v_13: G = G::from_u64(4); let __v_14: G = G::from_u64(7); let __v_15: G = G::from_u64(206); let __v_16: G = G::from_u64(243); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(57); let __v_19: G = G::from_u64(39); let __v_20: G = G::from_u64(214); let __v_21: G = G::from_u64(11); let __v_22: G = G::from_u64(166); let __v_23: G = G::from_u64(105); let __v_24: G = G::from_u64(104); let __v_25: G = G::from_u64(155); let __v_26: G = G::from_u64(146); let __v_27: G = G::from_u64(168); let __v_28: G = G::from_u64(238); let __v_29: G = G::from_u64(179); let __v_30: G = G::from_u64(100); let __v_31: G = G::from_u64(69); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_532] = [__v_32]; record.function_queries[532].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_533: usize = 1; -const IN_533: 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(212); let __v_1: G = G::from_u64(148); let __v_2: G = G::from_u64(220); let __v_3: G = G::from_u64(96); let __v_4: G = G::from_u64(19); let __v_5: G = G::from_u64(134); let __v_6: G = G::from_u64(186); let __v_7: G = G::from_u64(142); let __v_8: G = G::from_u64(143); let __v_9: G = G::from_u64(11); let __v_10: G = G::from_u64(113); let __v_11: G = G::from_u64(31); let __v_12: G = G::from_u64(230); let __v_13: G = G::from_u64(42); let __v_14: G = G::from_u64(45); let __v_15: G = G::from_u64(171); let __v_16: G = G::from_u64(198); let __v_17: G = G::from_u64(72); let __v_18: G = G::from_u64(140); let __v_19: G = G::from_u64(246); let __v_20: G = G::from_u64(206); let __v_21: G = G::from_u64(151); let __v_22: G = G::from_u64(121); let __v_23: G = G::from_u64(110); let __v_24: G = G::from_u64(188); let __v_25: G = G::from_u64(58); let __v_26: G = G::from_u64(213); let __v_27: G = G::from_u64(254); let __v_28: G = G::from_u64(251); let __v_29: 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_3, __v_15, __v_3, __v_16, __v_17, __v_18, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_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_532] = [__v_29]; 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 = inp[0]; let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(519, (&__args[..]))?) { [G::ZERO; OUT_519] } else { let (__hash, __hit) = record.function_queries[519].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[519].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[519].bump_multiplicity(__i); } let __ret: [G; OUT_519] = unsafe { (*(record.function_queries[519].output_at(__i).as_ptr() as *const [G; OUT_519])) }; __ret }, _ => { aiur_fn_519::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; 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_533] = [__v_3]; record.function_queries[533].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_533] = [__v_5]; record.function_queries[533].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(521, (&__args[..]))?) { [G::ZERO; OUT_521] } else { let (__hash, __hit) = record.function_queries[521].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[521].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { (*(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521])) }; __ret }, _ => { aiur_fn_521::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_533] = [__v_7]; record.function_queries[533].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(531, (&__args[..]))?) { [G::ZERO; OUT_531] } else { let (__hash, __hit) = record.function_queries[531].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[531].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { (*(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531])) }; __ret }, _ => { aiur_fn_531::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_533] = [__v_9]; record.function_queries[533].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(530, (&__args[..]))?) { [G::ZERO; OUT_530] } else { let (__hash, __hit) = record.function_queries[530].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[530].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { (*(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530])) }; __ret }, _ => { aiur_fn_530::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_533] = [__v_11]; record.function_queries[533].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(532, (&__args[..]))?) { [G::ZERO; OUT_532] } else { let (__hash, __hit) = record.function_queries[532].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[532].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { (*(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532])) }; __ret }, _ => { aiur_fn_532::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_533] = [__v_13]; record.function_queries[533].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_533] = [__v_13]; record.function_queries[533].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_534: usize = 1; -const IN_534: 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(53); let __v_1: G = G::from_u64(169); let __v_2: G = G::from_u64(237); let __v_3: G = G::from_u64(114); let __v_4: G = G::from_u64(2); let __v_5: G = G::from_u64(227); let __v_6: G = G::from_u64(196); let __v_7: G = G::from_u64(56); let __v_8: G = G::from_u64(87); let __v_9: G = G::from_u64(205); let __v_10: G = G::from_u64(6); let __v_11: G = G::from_u64(62); let __v_12: G = G::from_u64(172); let __v_13: G = G::from_u64(18); let __v_14: G = G::from_u64(63); let __v_15: G = G::from_u64(231); let __v_16: G = G::from_u64(183); let __v_17: G = G::from_u64(127); let __v_18: G = G::from_u64(49); let __v_19: G = G::from_u64(21); let __v_20: G = G::from_u64(74); let __v_21: G = G::from_u64(197); let __v_22: G = G::from_u64(64); let __v_23: G = G::from_u64(219); let __v_24: G = G::from_u64(162); let __v_25: G = G::from_u64(201); let __v_26: G = G::from_u64(151); let __v_27: G = G::from_u64(189); let __v_28: G = G::from_u64(242); let __v_29: G = G::from_u64(36); 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_6, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_10, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_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_533] = [__v_30]; 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 = inp[0]; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(531, (&__args[..]))?) { [G::ZERO; OUT_531] } else { let (__hash, __hit) = record.function_queries[531].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[531].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { (*(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531])) }; __ret }, _ => { aiur_fn_531::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; 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_534] = [__v_3]; record.function_queries[534].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(530, (&__args[..]))?) { [G::ZERO; OUT_530] } else { let (__hash, __hit) = record.function_queries[530].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[530].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { (*(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530])) }; __ret }, _ => { aiur_fn_530::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_534] = [__v_5]; record.function_queries[534].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(532, (&__args[..]))?) { [G::ZERO; OUT_532] } else { let (__hash, __hit) = record.function_queries[532].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[532].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { (*(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532])) }; __ret }, _ => { aiur_fn_532::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_534] = [__v_7]; record.function_queries[534].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_534] = [__v_7]; record.function_queries[534].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_535: usize = 1; -const IN_535: usize = 1; -const OUT_535: usize = 3; -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 = 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 __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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); 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; 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_535] = [__v_14, __v_14, __v_16]; record.function_queries[535].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_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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 7u64 => { match __v_15.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); let __ret: [G; OUT_535] = [__v_18, __v_12, __v_16]; record.function_queries[535].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); 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 __ret: [G; OUT_535] = [__v_18, __v_18, __v_20]; record.function_queries[535].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_18: G = G::from_u64(0); 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 __ret: [G; OUT_535] = [__v_18, __v_18, __v_20]; record.function_queries[535].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_535] = [__v_9, __v_9, __v_11]; record.function_queries[535].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; 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 __ret: [G; OUT_535] = [__v_5, __v_5, __v_7]; record.function_queries[535].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_536: usize = 2; -const IN_536: usize = 2; +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(23); let __v_1: G = G::from_u64(16); let __v_2: G = G::from_u64(3); let __v_3: G = G::from_u64(74); let __v_4: G = G::from_u64(81); let __v_5: G = G::from_u64(127); let __v_6: G = G::from_u64(36); let __v_7: G = G::from_u64(159); let __v_8: G = G::from_u64(92); let __v_9: G = G::from_u64(130); let __v_10: G = G::from_u64(101); let __v_11: G = G::from_u64(232); let __v_12: G = G::from_u64(226); let __v_13: G = G::from_u64(120); let __v_14: G = G::from_u64(59); let __v_15: G = G::from_u64(230); let __v_16: G = G::from_u64(6); let __v_17: G = G::from_u64(25); let __v_18: G = G::from_u64(240); let __v_19: G = G::from_u64(200); let __v_20: G = G::from_u64(95); let __v_21: G = G::from_u64(78); let __v_22: G = G::from_u64(171); let __v_23: G = G::from_u64(98); let __v_24: G = G::from_u64(94); let __v_25: G = G::from_u64(133); let __v_26: G = G::from_u64(152); let __v_27: G = G::from_u64(58); let __v_28: G = G::from_u64(189); let __v_29: G = G::from_u64(114); let __v_30: G = G::from_u64(46); let __v_31: 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_11, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_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_534] = [__v_31]; 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(83); let __v_1: G = G::from_u64(24); let __v_2: G = G::from_u64(135); let __v_3: G = G::from_u64(122); let __v_4: G = G::from_u64(230); let __v_5: G = G::from_u64(30); let __v_6: G = G::from_u64(29); let __v_7: G = G::from_u64(163); let __v_8: G = G::from_u64(121); let __v_9: G = G::from_u64(128); let __v_10: G = G::from_u64(216); let __v_11: G = G::from_u64(12); let __v_12: G = G::from_u64(17); let __v_13: G = G::from_u64(227); let __v_14: G = G::from_u64(228); let __v_15: G = G::from_u64(54); let __v_16: G = G::from_u64(80); let __v_17: G = G::from_u64(195); let __v_18: G = G::from_u64(62); let __v_19: G = G::from_u64(153); let __v_20: G = G::from_u64(113); let __v_21: G = G::from_u64(97); let __v_22: G = G::from_u64(34); let __v_23: G = G::from_u64(241); let __v_24: G = G::from_u64(239); let __v_25: G = G::from_u64(240); let __v_26: G = G::from_u64(159); let __v_27: 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_3, __v_15, __v_10, __v_16, __v_17, __v_14, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_4, __v_24, __v_25, __v_5, __v_26]; 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_535] = [__v_27]; record.function_queries[535].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_536: usize = 1; +const IN_536: usize = 1; 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 = inp[0]; let __v_1: G = inp[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; 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_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; 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_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, } }; let __v_2: G = __mc_out___mc_0[0]; let __v_3: G = G::from_u64(2); 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 = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_3, __v_2, __v_5, __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(7); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_6, __v_1, __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_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_7, __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 __ret: [G; OUT_536] = [__v_11]; record.function_queries[536].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_537: usize = 4; -const IN_537: usize = 4; -const OUT_537: usize = 2; -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 = 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_787] = { let __args: [G; IN_787] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_537] = [__v_7, __v_8]; record.function_queries[537].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_789] = { let __args: [G; IN_789] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(535, (&__args[..]))?) { [G::ZERO; OUT_535] } else { let (__hash, __hit) = record.function_queries[535].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[535].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { (*(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535])) }; __ret }, _ => { aiur_fn_535::(__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]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(535, (&__args[..]))?) { [G::ZERO; OUT_535] } else { let (__hash, __hit) = record.function_queries[535].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[535].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { (*(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535])) }; __ret }, _ => { aiur_fn_535::(__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(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_537] = [__v_17, __v_18]; record.function_queries[537].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(538, (&__args[..]))?) { [G::ZERO; OUT_538] } else { let (__hash, __hit) = record.function_queries[538].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[538].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { (*(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538])) }; __ret }, _ => { aiur_fn_538::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_537] = [__v_17, __v_18]; record.function_queries[537].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(538, (&__args[..]))?) { [G::ZERO; OUT_538] } else { let (__hash, __hit) = record.function_queries[538].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[538].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { (*(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538])) }; __ret }, _ => { aiur_fn_538::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_537] = [__v_14, __v_15]; record.function_queries[537].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_538: usize = 6; -const IN_538: usize = 6; -const OUT_538: usize = 2; -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 = inp[0]; let __v_1: G = inp[1]; let __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_425] = { let __args: [G; IN_425] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __v_5]; 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 __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(535, (&__args[..]))?) { [G::ZERO; OUT_535] } else { let (__hash, __hit) = record.function_queries[535].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[535].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { (*(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535])) }; __ret }, _ => { aiur_fn_535::(__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() { 1u64 => { let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(535, (&__args[..]))?) { [G::ZERO; OUT_535] } else { let (__hash, __hit) = record.function_queries[535].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[535].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { (*(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535])) }; __ret }, _ => { aiur_fn_535::(__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]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(536, (&__args[..]))?) { [G::ZERO; OUT_536] } else { let (__hash, __hit) = record.function_queries[536].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[536].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[536].bump_multiplicity(__i); } let __ret: [G; OUT_536] = unsafe { (*(record.function_queries[536].output_at(__i).as_ptr() as *const [G; OUT_536])) }; __ret }, _ => { aiur_fn_536::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(536, (&__args[..]))?) { [G::ZERO; OUT_536] } else { let (__hash, __hit) = record.function_queries[536].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[536].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[536].bump_multiplicity(__i); } let __ret: [G; OUT_536] = unsafe { (*(record.function_queries[536].output_at(__i).as_ptr() as *const [G; OUT_536])) }; __ret }, _ => { aiur_fn_536::(__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(0); let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __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_14, __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_15, __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_798] = { let __args: [G; IN_798] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_21, __v_22]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_538] = [__v_23, __v_24]; record.function_queries[538].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_538] = [__v_14, __v_15]; record.function_queries[538].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_538] = [__v_11, __v_12]; record.function_queries[538].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_539: usize = 4; -const IN_539: usize = 4; -const OUT_539: usize = 2; -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 = 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_787] = { let __args: [G; IN_787] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_539] = [__v_7, __v_8]; record.function_queries[539].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(534, (&__args[..]))?) { [G::ZERO; OUT_534] } else { let (__hash, __hit) = record.function_queries[534].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[534].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[534].bump_multiplicity(__i); } let __ret: [G; OUT_534] = unsafe { (*(record.function_queries[534].output_at(__i).as_ptr() as *const [G; OUT_534])) }; __ret }, _ => { aiur_fn_534::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(537, (&__args[..]))?) { [G::ZERO; OUT_537] } else { let (__hash, __hit) = record.function_queries[537].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[537].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[537].bump_multiplicity(__i); } let __ret: [G; OUT_537] = unsafe { (*(record.function_queries[537].output_at(__i).as_ptr() as *const [G; OUT_537])) }; __ret }, _ => { aiur_fn_537::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_539] = [__v_8, __v_9]; record.function_queries[539].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(519, (&__args[..]))?) { [G::ZERO; OUT_519] } else { let (__hash, __hit) = record.function_queries[519].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[519].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[519].bump_multiplicity(__i); } let __ret: [G; OUT_519] = unsafe { (*(record.function_queries[519].output_at(__i).as_ptr() as *const [G; OUT_519])) }; __ret }, _ => { aiur_fn_519::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_9: G = __r_arr[0]; let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_11: G = __r_arr[0]; let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(521, (&__args[..]))?) { [G::ZERO; OUT_521] } else { let (__hash, __hit) = record.function_queries[521].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[521].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { (*(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521])) }; __ret }, _ => { aiur_fn_521::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(540, (&__args[..]))?) { [G::ZERO; OUT_540] } else { let (__hash, __hit) = record.function_queries[540].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[540].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { (*(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540])) }; __ret }, _ => { aiur_fn_540::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_539] = [__v_14, __v_15]; record.function_queries[539].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(541, (&__args[..]))?) { [G::ZERO; OUT_541] } else { let (__hash, __hit) = record.function_queries[541].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[541].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { (*(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541])) }; __ret }, _ => { aiur_fn_541::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_539] = [__v_14, __v_15]; record.function_queries[539].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_540: usize = 3; -const IN_540: usize = 3; +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 = inp[0]; let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(522, (&__args[..]))?) { [G::ZERO; OUT_522] } else { let (__hash, __hit) = record.function_queries[522].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[522].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[522].bump_multiplicity(__i); } let __ret: [G; OUT_522] = unsafe { (*(record.function_queries[522].output_at(__i).as_ptr() as *const [G; OUT_522])) }; __ret }, _ => { aiur_fn_522::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; 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_536] = [__v_3]; record.function_queries[536].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(523, (&__args[..]))?) { [G::ZERO; OUT_523] } else { let (__hash, __hit) = record.function_queries[523].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[523].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[523].bump_multiplicity(__i); } let __ret: [G; OUT_523] = unsafe { (*(record.function_queries[523].output_at(__i).as_ptr() as *const [G; OUT_523])) }; __ret }, _ => { aiur_fn_523::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_536] = [__v_5]; record.function_queries[536].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(524, (&__args[..]))?) { [G::ZERO; OUT_524] } else { let (__hash, __hit) = record.function_queries[524].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[524].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[524].bump_multiplicity(__i); } let __ret: [G; OUT_524] = unsafe { (*(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524])) }; __ret }, _ => { aiur_fn_524::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_536] = [__v_7]; record.function_queries[536].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(534, (&__args[..]))?) { [G::ZERO; OUT_534] } else { let (__hash, __hit) = record.function_queries[534].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[534].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[534].bump_multiplicity(__i); } let __ret: [G; OUT_534] = unsafe { (*(record.function_queries[534].output_at(__i).as_ptr() as *const [G; OUT_534])) }; __ret }, _ => { aiur_fn_534::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_536] = [__v_9]; record.function_queries[536].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(533, (&__args[..]))?) { [G::ZERO; OUT_533] } else { let (__hash, __hit) = record.function_queries[533].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[533].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { (*(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533])) }; __ret }, _ => { aiur_fn_533::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_536] = [__v_11]; record.function_queries[536].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(535, (&__args[..]))?) { [G::ZERO; OUT_535] } else { let (__hash, __hit) = record.function_queries[535].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[535].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { (*(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535])) }; __ret }, _ => { aiur_fn_535::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_536] = [__v_13]; record.function_queries[536].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_536] = [__v_13]; record.function_queries[536].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } +const INPUT_SIZE_537: usize = 1; +const IN_537: usize = 1; +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 = inp[0]; let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(534, (&__args[..]))?) { [G::ZERO; OUT_534] } else { let (__hash, __hit) = record.function_queries[534].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[534].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[534].bump_multiplicity(__i); } let __ret: [G; OUT_534] = unsafe { (*(record.function_queries[534].output_at(__i).as_ptr() as *const [G; OUT_534])) }; __ret }, _ => { aiur_fn_534::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; 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_537] = [__v_3]; record.function_queries[537].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(533, (&__args[..]))?) { [G::ZERO; OUT_533] } else { let (__hash, __hit) = record.function_queries[533].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[533].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { (*(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533])) }; __ret }, _ => { aiur_fn_533::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_537] = [__v_5]; record.function_queries[537].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(535, (&__args[..]))?) { [G::ZERO; OUT_535] } else { let (__hash, __hit) = record.function_queries[535].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[535].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { (*(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535])) }; __ret }, _ => { aiur_fn_535::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_537] = [__v_7]; record.function_queries[537].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_537] = [__v_7]; record.function_queries[537].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_538: usize = 1; +const IN_538: usize = 1; +const OUT_538: usize = 3; +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 = 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 __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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); 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; 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_538] = [__v_14, __v_14, __v_16]; record.function_queries[538].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_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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 7u64 => { match __v_15.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); let __ret: [G; OUT_538] = [__v_18, __v_12, __v_16]; record.function_queries[538].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); 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 __ret: [G; OUT_538] = [__v_18, __v_18, __v_20]; record.function_queries[538].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_18: G = G::from_u64(0); 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 __ret: [G; OUT_538] = [__v_18, __v_18, __v_20]; record.function_queries[538].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_538] = [__v_9, __v_9, __v_11]; record.function_queries[538].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; 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 __ret: [G; OUT_538] = [__v_5, __v_5, __v_7]; record.function_queries[538].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_539: usize = 2; +const IN_539: usize = 2; +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 = inp[0]; let __v_1: G = inp[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; 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_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; 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_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, } }; let __v_2: G = __mc_out___mc_0[0]; let __v_3: G = G::from_u64(2); 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 = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_3, __v_2, __v_5, __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(7); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_6, __v_1, __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_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_7, __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 __ret: [G; OUT_539] = [__v_11]; record.function_queries[539].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_540: usize = 4; +const IN_540: usize = 4; const OUT_540: usize = 2; -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 = 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_789] = { let __args: [G; IN_789] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_789] = { let __args: [G; IN_789] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __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 __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__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_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_540] = [__v_10, __v_11]; record.function_queries[540].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_9]; 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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(519, (&__args[..]))?) { [G::ZERO; OUT_519] } else { let (__hash, __hit) = record.function_queries[519].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[519].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[519].bump_multiplicity(__i); } let __ret: [G; OUT_519] = unsafe { (*(record.function_queries[519].output_at(__i).as_ptr() as *const [G; OUT_519])) }; __ret }, _ => { aiur_fn_519::(__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; 4] = [__v_12, __v_13, __v_0, __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(3); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __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_18: G = { let __values: [G; 4] = [__v_16, __v_17, __v_6, __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_798] = { let __args: [G; IN_798] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_18, __v_19]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_540] = [__v_20, __v_21]; record.function_queries[540].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +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 = 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_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_540] = [__v_7, __v_8]; record.function_queries[540].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_792] = { let __args: [G; IN_792] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(538, (&__args[..]))?) { [G::ZERO; OUT_538] } else { let (__hash, __hit) = record.function_queries[538].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[538].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { (*(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538])) }; __ret }, _ => { aiur_fn_538::(__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]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(538, (&__args[..]))?) { [G::ZERO; OUT_538] } else { let (__hash, __hit) = record.function_queries[538].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[538].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { (*(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538])) }; __ret }, _ => { aiur_fn_538::(__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(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_540] = [__v_17, __v_18]; record.function_queries[540].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(541, (&__args[..]))?) { [G::ZERO; OUT_541] } else { let (__hash, __hit) = record.function_queries[541].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[541].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { (*(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541])) }; __ret }, _ => { aiur_fn_541::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_540] = [__v_17, __v_18]; record.function_queries[540].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(541, (&__args[..]))?) { [G::ZERO; OUT_541] } else { let (__hash, __hit) = record.function_queries[541].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[541].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { (*(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541])) }; __ret }, _ => { aiur_fn_541::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_540] = [__v_14, __v_15]; record.function_queries[540].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_541: usize = 6; const IN_541: usize = 6; const OUT_541: usize = 2; -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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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_789] = { let __args: [G; IN_789] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_789] = { let __args: [G; IN_789] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_7, __v_5]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_9, __v_5]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_10]; 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_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_541] = [__v_14, __v_15]; record.function_queries[541].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_11]; 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 __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_541] = [__v_16, __v_17]; record.function_queries[541].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_13, __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]; break '__mc_0 [__v_16]; }, _ => { let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_13, __v_15]; 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_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(542, (&__args[..]))?) { [G::ZERO; OUT_542] } else { let (__hash, __hit) = record.function_queries[542].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[542].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { (*(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542])) }; __ret }, _ => { aiur_fn_542::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_541] = [__v_17, __v_18]; record.function_queries[541].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_542: usize = 9; -const IN_542: usize = 9; +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 = inp[0]; let __v_1: G = inp[1]; let __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_428] = { let __args: [G; IN_428] = [__v_3, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(538, (&__args[..]))?) { [G::ZERO; OUT_538] } else { let (__hash, __hit) = record.function_queries[538].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[538].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { (*(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538])) }; __ret }, _ => { aiur_fn_538::(__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() { 1u64 => { let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(538, (&__args[..]))?) { [G::ZERO; OUT_538] } else { let (__hash, __hit) = record.function_queries[538].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[538].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { (*(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538])) }; __ret }, _ => { aiur_fn_538::(__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]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(539, (&__args[..]))?) { [G::ZERO; OUT_539] } else { let (__hash, __hit) = record.function_queries[539].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[539].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { (*(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539])) }; __ret }, _ => { aiur_fn_539::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(539, (&__args[..]))?) { [G::ZERO; OUT_539] } else { let (__hash, __hit) = record.function_queries[539].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[539].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { (*(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539])) }; __ret }, _ => { aiur_fn_539::(__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(0); let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __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_14, __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_15, __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_801] = { let __args: [G; IN_801] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_21, __v_22]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_541] = [__v_23, __v_24]; record.function_queries[541].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_541] = [__v_14, __v_15]; record.function_queries[541].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_541] = [__v_11, __v_12]; record.function_queries[541].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_542: usize = 4; +const IN_542: usize = 4; const OUT_542: usize = 2; -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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = 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 = (__v_9 - __v_2); let __v_11: G = (__v_0 * __v_10); match __v_11.as_canonical_u64() { 1u64 => { 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_542] = [__v_12, __v_13]; record.function_queries[542].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 __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_12, __v_14, __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_16: 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_17: G = { let __values: [G; 3] = [__v_13, __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 __v_18: G = G::from_u64(2); let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(529, (&__args[..]))?) { [G::ZERO; OUT_529] } else { let (__hash, __hit) = record.function_queries[529].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[529].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { (*(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529])) }; __ret }, _ => { aiur_fn_529::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_18, __v_19, __v_17, __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 __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(528, (&__args[..]))?) { [G::ZERO; OUT_528] } else { let (__hash, __hit) = record.function_queries[528].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[528].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { (*(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528])) }; __ret }, _ => { aiur_fn_528::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_18, __v_21, __v_16, __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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; 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_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, _ => { let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; 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_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, } }; let __v_23: G = __mc_out___mc_0[0]; 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_23, __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 = G::from_u64(3); let __v_30: G = { let __values: [G; 4] = [__v_29, __v_20, __v_22, __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_29, __v_30, __v_28, __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 __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() { 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(524, (&__args[..]))?) { [G::ZERO; OUT_524] } else { let (__hash, __hit) = record.function_queries[524].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[524].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[524].bump_multiplicity(__i); } let __ret: [G; OUT_524] = unsafe { (*(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524])) }; __ret }, _ => { aiur_fn_524::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; break '__mc_1 [__v_32]; }, _ => { let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(525, (&__args[..]))?) { [G::ZERO; OUT_525] } else { let (__hash, __hit) = record.function_queries[525].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[525].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[525].bump_multiplicity(__i); } let __ret: [G; OUT_525] = unsafe { (*(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525])) }; __ret }, _ => { aiur_fn_525::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; break '__mc_1 [__v_32]; }, } }, _ => { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(526, (&__args[..]))?) { [G::ZERO; OUT_526] } else { let (__hash, __hit) = record.function_queries[526].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[526].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[526].bump_multiplicity(__i); } let __ret: [G; OUT_526] = unsafe { (*(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526])) }; __ret }, _ => { aiur_fn_526::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; break '__mc_1 [__v_32]; }, _ => { let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(527, (&__args[..]))?) { [G::ZERO; OUT_527] } else { let (__hash, __hit) = record.function_queries[527].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[527].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { (*(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527])) }; __ret }, _ => { aiur_fn_527::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; break '__mc_1 [__v_32]; }, } }, } }; let __v_32: G = __mc_out___mc_1[0]; let __v_33: G = G::from_u64(2); let __v_34: G = G::from_u64(1); let __v_35: G = { let __values: [G; 3] = [__v_34, __v_34, __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 __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_33, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(3); let __v_39: G = { let __values: [G; 4] = [__v_38, __v_37, __v_3, __v_36]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_38, __v_39, __v_4, __v_36]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_38, __v_40, __v_31, __v_36]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_545] = { let __args: [G; IN_545] = [__v_2, __v_41, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(545, (&__args[..]))?) { [G::ZERO; OUT_545] } else { let (__hash, __hit) = record.function_queries[545].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[545].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { (*(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545])) }; __ret }, _ => { aiur_fn_545::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __ret: [G; OUT_542] = [__v_42, __v_43]; record.function_queries[542].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 = 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_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_542] = [__v_7, __v_8]; record.function_queries[542].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(537, (&__args[..]))?) { [G::ZERO; OUT_537] } else { let (__hash, __hit) = record.function_queries[537].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[537].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[537].bump_multiplicity(__i); } let __ret: [G; OUT_537] = unsafe { (*(record.function_queries[537].output_at(__i).as_ptr() as *const [G; OUT_537])) }; __ret }, _ => { aiur_fn_537::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(540, (&__args[..]))?) { [G::ZERO; OUT_540] } else { let (__hash, __hit) = record.function_queries[540].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[540].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { (*(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540])) }; __ret }, _ => { aiur_fn_540::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_542] = [__v_8, __v_9]; record.function_queries[542].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(522, (&__args[..]))?) { [G::ZERO; OUT_522] } else { let (__hash, __hit) = record.function_queries[522].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[522].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[522].bump_multiplicity(__i); } let __ret: [G; OUT_522] = unsafe { (*(record.function_queries[522].output_at(__i).as_ptr() as *const [G; OUT_522])) }; __ret }, _ => { aiur_fn_522::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_9: G = __r_arr[0]; let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(523, (&__args[..]))?) { [G::ZERO; OUT_523] } else { let (__hash, __hit) = record.function_queries[523].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[523].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[523].bump_multiplicity(__i); } let __ret: [G; OUT_523] = unsafe { (*(record.function_queries[523].output_at(__i).as_ptr() as *const [G; OUT_523])) }; __ret }, _ => { aiur_fn_523::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_11: G = __r_arr[0]; let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(524, (&__args[..]))?) { [G::ZERO; OUT_524] } else { let (__hash, __hit) = record.function_queries[524].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[524].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[524].bump_multiplicity(__i); } let __ret: [G; OUT_524] = unsafe { (*(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524])) }; __ret }, _ => { aiur_fn_524::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(543, (&__args[..]))?) { [G::ZERO; OUT_543] } else { let (__hash, __hit) = record.function_queries[543].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[543].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { (*(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543])) }; __ret }, _ => { aiur_fn_543::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_542] = [__v_14, __v_15]; record.function_queries[542].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(544, (&__args[..]))?) { [G::ZERO; OUT_544] } else { let (__hash, __hit) = record.function_queries[544].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[544].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { (*(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544])) }; __ret }, _ => { aiur_fn_544::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_542] = [__v_14, __v_15]; record.function_queries[542].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } const INPUT_SIZE_543: usize = 3; const IN_543: usize = 3; const OUT_543: usize = 2; -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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(2); 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_543] = [__v_6, __v_7]; record.function_queries[543].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_789] = { let __args: [G; IN_789] = [__v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_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() { 7u64 => { match __v_11.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_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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_12, __v_16]; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { 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_543] = [__v_19, __v_20]; record.function_queries[543].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(544, (&__args[..]))?) { [G::ZERO; OUT_544] } else { let (__hash, __hit) = record.function_queries[544].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[544].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { (*(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544])) }; __ret }, _ => { aiur_fn_544::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_19, __v_20]; record.function_queries[543].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { 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_543] = [__v_18, __v_19]; record.function_queries[543].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { 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_543] = [__v_18, __v_19]; record.function_queries[543].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_543] = [__v_14, __v_15]; record.function_queries[543].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_543] = [__v_14, __v_15]; record.function_queries[543].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_544: usize = 4; -const IN_544: usize = 4; +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 = 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_792] = { let __args: [G; IN_792] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_792] = { let __args: [G; IN_792] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_2]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_7]; 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 __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_543] = [__v_10, __v_11]; record.function_queries[543].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__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(2); let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(522, (&__args[..]))?) { [G::ZERO; OUT_522] } else { let (__hash, __hit) = record.function_queries[522].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[522].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[522].bump_multiplicity(__i); } let __ret: [G; OUT_522] = unsafe { (*(record.function_queries[522].output_at(__i).as_ptr() as *const [G; OUT_522])) }; __ret }, _ => { aiur_fn_522::(__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; 4] = [__v_12, __v_13, __v_0, __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(3); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __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_18: G = { let __values: [G; 4] = [__v_16, __v_17, __v_6, __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_801] = { let __args: [G; IN_801] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_18, __v_19]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_543] = [__v_20, __v_21]; record.function_queries[543].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +const INPUT_SIZE_544: usize = 6; +const IN_544: usize = 6; const OUT_544: usize = 2; -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 = 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 = { 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_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 __v_10: G = G::from_u64(2); let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(529, (&__args[..]))?) { [G::ZERO; OUT_529] } else { let (__hash, __hit) = record.function_queries[529].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[529].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { (*(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529])) }; __ret }, _ => { aiur_fn_529::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_10, __v_11, __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 __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = []; 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_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_10, __v_13, __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_15: G = G::from_u64(7); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_4, __v_0, __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_12, __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_19: G = { let __values: [G; 4] = [__v_17, __v_18, __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_20: G = { let __values: [G; 4] = [__v_10, __v_1, __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_797] = { let __args: [G; IN_797] = [__v_2, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_20, __v_21]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_22, __v_3]; 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 __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_23, __v_3]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_24]; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __a_val = __v_27.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_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_544] = [__v_29, __v_30]; record.function_queries[544].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_26, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(2); let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(522, (&__args[..]))?) { [G::ZERO; OUT_522] } else { let (__hash, __hit) = record.function_queries[522].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[522].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[522].bump_multiplicity(__i); } let __ret: [G; OUT_522] = unsafe { (*(record.function_queries[522].output_at(__i).as_ptr() as *const [G; OUT_522])) }; __ret }, _ => { aiur_fn_522::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; 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 __v_35: G = { let __values: [G; 4] = [__v_31, __v_32, __v_34, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(3); let __v_37: G = { let __values: [G; 4] = [__v_36, __v_35, __v_30, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_36, __v_37, __v_19, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_798] = { let __args: [G; IN_798] = [__v_2, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_38, __v_39]; 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_40: G = __r_arr[0]; let __ret: [G; OUT_544] = [__v_33, __v_40]; record.function_queries[544].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_545: usize = 6; -const IN_545: usize = 6; +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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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_792] = { let __args: [G; IN_792] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_792] = { let __args: [G; IN_792] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __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_11: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_10]; 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_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_544] = [__v_14, __v_15]; record.function_queries[544].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_11]; 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_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_544] = [__v_16, __v_17]; record.function_queries[544].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_13, __v_15]; 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_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, _ => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_13, __v_15]; 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_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(545, (&__args[..]))?) { [G::ZERO; OUT_545] } else { let (__hash, __hit) = record.function_queries[545].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[545].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { (*(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545])) }; __ret }, _ => { aiur_fn_545::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_544] = [__v_17, __v_18]; record.function_queries[544].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_545: usize = 9; +const IN_545: usize = 9; const OUT_545: usize = 2; -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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(522, (&__args[..]))?) { [G::ZERO; OUT_522] } else { let (__hash, __hit) = record.function_queries[522].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[522].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[522].bump_multiplicity(__i); } let __ret: [G; OUT_522] = unsafe { (*(record.function_queries[522].output_at(__i).as_ptr() as *const [G; OUT_522])) }; __ret }, _ => { aiur_fn_522::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, _ => { let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(523, (&__args[..]))?) { [G::ZERO; OUT_523] } else { let (__hash, __hit) = record.function_queries[523].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[523].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[523].bump_multiplicity(__i); } let __ret: [G; OUT_523] = unsafe { (*(record.function_queries[523].output_at(__i).as_ptr() as *const [G; OUT_523])) }; __ret }, _ => { aiur_fn_523::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, } }; let __v_6: G = __mc_out___mc_0[0]; 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_2, __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_797] = { let __args: [G; IN_797] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_9, __v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_11, __v_5]; 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 __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_12, __v_5]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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 __a_val = __v_16.as_canonical_u64(); let __b_val = __v_17.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_18.as_canonical_u64() { 1u64 => { 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_545] = [__v_19, __v_20]; record.function_queries[545].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_15, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(2); 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 = { let __values: [G; 4] = [__v_21, __v_6, __v_23, __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 = G::from_u64(3); let __v_26: G = { let __values: [G; 4] = [__v_25, __v_24, __v_20, __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_27: G = { let __values: [G; 4] = [__v_25, __v_26, __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 __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_4, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_27, __v_28]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_545] = [__v_22, __v_29]; record.function_queries[545].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_546: usize = 2; -const IN_546: usize = 2; -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 = 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_546] = [__v_3]; record.function_queries[546].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_546] = [__v_4]; record.function_queries[546].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __ret: [G; OUT_546] = [__v_4]; record.function_queries[546].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_547: usize = 2; -const IN_547: usize = 2; -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 = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_547] = [__v_1]; record.function_queries[547].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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; +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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = 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 = (__v_9 - __v_2); let __v_11: G = (__v_0 * __v_10); match __v_11.as_canonical_u64() { 1u64 => { 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_545] = [__v_12, __v_13]; record.function_queries[545].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 __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_12, __v_14, __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_16: 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_17: G = { let __values: [G; 3] = [__v_13, __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 __v_18: G = G::from_u64(2); let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(532, (&__args[..]))?) { [G::ZERO; OUT_532] } else { let (__hash, __hit) = record.function_queries[532].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[532].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { (*(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532])) }; __ret }, _ => { aiur_fn_532::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_18, __v_19, __v_17, __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 __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(531, (&__args[..]))?) { [G::ZERO; OUT_531] } else { let (__hash, __hit) = record.function_queries[531].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[531].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { (*(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531])) }; __ret }, _ => { aiur_fn_531::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_18, __v_21, __v_16, __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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, _ => { let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; 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_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, } }; let __v_23: G = __mc_out___mc_0[0]; 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_23, __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 = G::from_u64(3); let __v_30: G = { let __values: [G; 4] = [__v_29, __v_20, __v_22, __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_29, __v_30, __v_28, __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 __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() { 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(527, (&__args[..]))?) { [G::ZERO; OUT_527] } else { let (__hash, __hit) = record.function_queries[527].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[527].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { (*(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527])) }; __ret }, _ => { aiur_fn_527::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; break '__mc_1 [__v_32]; }, _ => { let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(528, (&__args[..]))?) { [G::ZERO; OUT_528] } else { let (__hash, __hit) = record.function_queries[528].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[528].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { (*(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528])) }; __ret }, _ => { aiur_fn_528::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; break '__mc_1 [__v_32]; }, } }, _ => { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(529, (&__args[..]))?) { [G::ZERO; OUT_529] } else { let (__hash, __hit) = record.function_queries[529].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[529].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { (*(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529])) }; __ret }, _ => { aiur_fn_529::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; break '__mc_1 [__v_32]; }, _ => { let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(530, (&__args[..]))?) { [G::ZERO; OUT_530] } else { let (__hash, __hit) = record.function_queries[530].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[530].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { (*(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530])) }; __ret }, _ => { aiur_fn_530::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; break '__mc_1 [__v_32]; }, } }, } }; let __v_32: G = __mc_out___mc_1[0]; let __v_33: G = G::from_u64(2); let __v_34: G = G::from_u64(1); let __v_35: G = { let __values: [G; 3] = [__v_34, __v_34, __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 __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_33, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(3); let __v_39: G = { let __values: [G; 4] = [__v_38, __v_37, __v_3, __v_36]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_38, __v_39, __v_4, __v_36]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_38, __v_40, __v_31, __v_36]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_548] = { let __args: [G; IN_548] = [__v_2, __v_41, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __ret: [G; OUT_545] = [__v_42, __v_43]; record.function_queries[545].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_546: usize = 3; +const IN_546: usize = 3; +const OUT_546: usize = 2; +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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(2); 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_546] = [__v_6, __v_7]; record.function_queries[546].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_792] = { let __args: [G; IN_792] = [__v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_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() { 7u64 => { match __v_11.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_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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_12, __v_16]; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { 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_546] = [__v_19, __v_20]; record.function_queries[546].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_546] = [__v_19, __v_20]; record.function_queries[546].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { 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_546] = [__v_18, __v_19]; record.function_queries[546].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { 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_546] = [__v_18, __v_19]; record.function_queries[546].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_546] = [__v_14, __v_15]; record.function_queries[546].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_546] = [__v_14, __v_15]; record.function_queries[546].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_547: usize = 4; +const IN_547: usize = 4; +const OUT_547: usize = 2; +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 = 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 = { 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_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 __v_10: G = G::from_u64(2); let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(532, (&__args[..]))?) { [G::ZERO; OUT_532] } else { let (__hash, __hit) = record.function_queries[532].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[532].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { (*(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532])) }; __ret }, _ => { aiur_fn_532::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_10, __v_11, __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 __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = []; 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_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_10, __v_13, __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_15: G = G::from_u64(7); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_4, __v_0, __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_12, __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_19: G = { let __values: [G; 4] = [__v_17, __v_18, __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_20: G = { let __values: [G; 4] = [__v_10, __v_1, __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_800] = { let __args: [G; IN_800] = [__v_2, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_20, __v_21]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_22, __v_3]; 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 __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_23, __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_24: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __a_val = __v_27.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_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_547] = [__v_29, __v_30]; record.function_queries[547].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_26, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(2); let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(525, (&__args[..]))?) { [G::ZERO; OUT_525] } else { let (__hash, __hit) = record.function_queries[525].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[525].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[525].bump_multiplicity(__i); } let __ret: [G; OUT_525] = unsafe { (*(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525])) }; __ret }, _ => { aiur_fn_525::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; 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 __v_35: G = { let __values: [G; 4] = [__v_31, __v_32, __v_34, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(3); let __v_37: G = { let __values: [G; 4] = [__v_36, __v_35, __v_30, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_36, __v_37, __v_19, __v_29]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_801] = { let __args: [G; IN_801] = [__v_2, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_38, __v_39]; 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_40: G = __r_arr[0]; let __ret: [G; OUT_547] = [__v_33, __v_40]; record.function_queries[547].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_548: usize = 6; +const IN_548: usize = 6; const OUT_548: usize = 2; -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(0); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_548] = [__v_0, __v_1]; record.function_queries[548].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_549: usize = 0; -const IN_549: usize = 0; -const OUT_549: usize = 2; -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 = G::from_u64(1); let __ret: [G; OUT_549] = [__v_0, __v_0]; record.function_queries[549].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_550: usize = 0; -const IN_550: usize = 0; -const OUT_550: usize = 2; -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 = G::from_u64(2); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_550] = [__v_0, __v_1]; record.function_queries[550].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_551: usize = 4; -const IN_551: usize = 4; +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 = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(525, (&__args[..]))?) { [G::ZERO; OUT_525] } else { let (__hash, __hit) = record.function_queries[525].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[525].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[525].bump_multiplicity(__i); } let __ret: [G; OUT_525] = unsafe { (*(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525])) }; __ret }, _ => { aiur_fn_525::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, _ => { let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(526, (&__args[..]))?) { [G::ZERO; OUT_526] } else { let (__hash, __hit) = record.function_queries[526].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[526].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[526].bump_multiplicity(__i); } let __ret: [G; OUT_526] = unsafe { (*(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526])) }; __ret }, _ => { aiur_fn_526::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, } }; let __v_6: G = __mc_out___mc_0[0]; 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_2, __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_800] = { let __args: [G; IN_800] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_9, __v_10]; 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]; let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_11, __v_5]; 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 __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_12, __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_13: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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 __a_val = __v_16.as_canonical_u64(); let __b_val = __v_17.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_18.as_canonical_u64() { 1u64 => { 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_548] = [__v_19, __v_20]; record.function_queries[548].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_15, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(2); 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 = { let __values: [G; 4] = [__v_21, __v_6, __v_23, __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 = G::from_u64(3); let __v_26: G = { let __values: [G; 4] = [__v_25, __v_24, __v_20, __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_27: G = { let __values: [G; 4] = [__v_25, __v_26, __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 __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_4, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_27, __v_28]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_548] = [__v_22, __v_29]; record.function_queries[548].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_549: usize = 2; +const IN_549: usize = 2; +const OUT_549: usize = 1; +fn aiur_fn_549(inp: [G; IN_549], 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]; 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_549] = [__v_3]; record.function_queries[549].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __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_549] = [__v_4]; record.function_queries[549].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __ret: [G; OUT_549] = [__v_4]; record.function_queries[549].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_550: usize = 2; +const IN_550: usize = 2; +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]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_550] = [__v_1]; record.function_queries[550].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_550] = [__v_0]; record.function_queries[550].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_551: usize = 0; +const IN_551: usize = 0; const OUT_551: usize = 2; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); let __ret: [G; OUT_551] = [__v_2, __v_4]; record.function_queries[551].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_551] = [__v_0, __v_1]; 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; +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 = G::from_u64(0); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_551] = [__v_0, __v_1]; record.function_queries[551].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_552: usize = 0; +const IN_552: usize = 0; const OUT_552: usize = 2; -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]; let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_0, __v_1]; record.function_queries[552].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_553: usize = 2; -const IN_553: usize = 2; -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]; 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 __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; 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_66: G = __r_arr[0]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; 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_67: G = __r_arr[0]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; 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_68: G = __r_arr[0]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; 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_69: G = __r_arr[0]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; 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_70: G = __r_arr[0]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; 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_71: G = __r_arr[0]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; 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_72: G = __r_arr[0]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; 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_73: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_72, __v_73]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_71, __v_74]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_70, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_69, __v_76]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_68, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_67, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_66, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __ret: [G; OUT_553] = [__v_80]; record.function_queries[553].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_554: usize = 8; -const IN_554: usize = 8; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = 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(16777216); let __v_9: G = (__v_0 * __v_8); let __v_10: G = G::from_u64(65536); let __v_11: G = (__v_1 * __v_10); let __v_12: G = G::from_u64(256); let __v_13: G = (__v_2 * __v_12); let __v_14: G = (__v_13 + __v_3); let __v_15: G = (__v_11 + __v_14); let __v_16: G = (__v_9 + __v_15); let __v_17: G = (__v_4 * __v_8); let __v_18: G = (__v_5 * __v_10); let __v_19: G = (__v_6 * __v_12); let __v_20: G = (__v_19 + __v_7); let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_17 + __v_21); let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_16, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_554] = [__v_23]; record.function_queries[554].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_555: usize = 2; -const IN_555: usize = 2; -const OUT_555: usize = 1; -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]; 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() { 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_555] = [__v_6]; record.function_queries[555].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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_4); let __ret: [G; OUT_555] = [__v_8]; record.function_queries[555].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_5]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_555] = [__v_7]; record.function_queries[555].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_556: usize = 3; -const IN_556: usize = 3; -const OUT_556: usize = 2; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = []; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __ret: [G; OUT_556] = [__v_4, __v_5]; record.function_queries[556].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __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_4: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_1, __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_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_556] = [__v_7, __v_8]; record.function_queries[556].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_556] = [__v_6, __v_7]; record.function_queries[556].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_556] = [__v_6, __v_7]; record.function_queries[556].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __ret: [G; OUT_556] = [__v_6, __v_7]; 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; +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 = G::from_u64(1); let __ret: [G; OUT_552] = [__v_0, __v_0]; record.function_queries[552].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_553: usize = 0; +const IN_553: usize = 0; +const OUT_553: usize = 2; +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 = G::from_u64(2); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_0, __v_1]; record.function_queries[553].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_554: usize = 4; +const IN_554: usize = 4; +const OUT_554: usize = 2; +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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); let __ret: [G; OUT_554] = [__v_2, __v_4]; record.function_queries[554].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_554] = [__v_0, __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 = 2; +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]; let __v_1: G = G::from_u64(1); let __ret: [G; OUT_555] = [__v_0, __v_1]; record.function_queries[555].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_556: usize = 2; +const IN_556: usize = 2; +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]; 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 __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; 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_66: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; 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_67: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; 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_68: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; 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_69: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; 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_70: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; 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_71: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; 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_72: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; 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_73: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_72, __v_73]; 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_74: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_71, __v_74]; 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_75: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_70, __v_75]; 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_76: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_69, __v_76]; 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_77: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_68, __v_77]; 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_78: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_67, __v_78]; 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_79: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_66, __v_79]; 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_80: G = __r_arr[0]; let __ret: [G; OUT_556] = [__v_80]; record.function_queries[556].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_557: usize = 8; +const IN_557: usize = 8; 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]; let __loaded: [G; 3] = { let __base = 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_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].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() { 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].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() { 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_557] = [__v_10]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].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() { 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_557] = [__v_10]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_557] = [__v_8]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = 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(16777216); let __v_9: G = (__v_0 * __v_8); let __v_10: G = G::from_u64(65536); let __v_11: G = (__v_1 * __v_10); let __v_12: G = G::from_u64(256); let __v_13: G = (__v_2 * __v_12); let __v_14: G = (__v_13 + __v_3); let __v_15: G = (__v_11 + __v_14); let __v_16: G = (__v_9 + __v_15); let __v_17: G = (__v_4 * __v_8); let __v_18: G = (__v_5 * __v_10); let __v_19: G = (__v_6 * __v_12); let __v_20: G = (__v_19 + __v_7); let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_17 + __v_21); let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_16, __v_22]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_557] = [__v_23]; record.function_queries[557].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_558: usize = 2; const IN_558: usize = 2; 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]; 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_558] = [__v_8]; record.function_queries[558].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_558] = [__v_8]; record.function_queries[558].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(2); let __ret: [G; OUT_558] = [__v_8]; record.function_queries[558].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_558] = [__v_10]; record.function_queries[558].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_559: usize = 4; -const IN_559: usize = 4; -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]; 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_560] = { let __args: [G; IN_560] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_559] = [__v_4]; record.function_queries[559].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_559] = [__v_4]; record.function_queries[559].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); let __ret: [G; OUT_559] = [__v_4]; record.function_queries[559].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_559] = [__v_4]; record.function_queries[559].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())); }, } }) } +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]; 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() { 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_558] = [__v_6]; record.function_queries[558].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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_4); let __ret: [G; OUT_558] = [__v_8]; record.function_queries[558].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __v_5]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_558] = [__v_7]; record.function_queries[558].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_559: usize = 3; +const IN_559: usize = 3; +const OUT_559: usize = 2; +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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = []; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __ret: [G; OUT_559] = [__v_4, __v_5]; record.function_queries[559].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __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_4: G = __r_arr[0]; let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_1, __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_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_559] = [__v_7, __v_8]; record.function_queries[559].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_559] = [__v_6, __v_7]; record.function_queries[559].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = []; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_559] = [__v_6, __v_7]; record.function_queries[559].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __ret: [G; OUT_559] = [__v_6, __v_7]; record.function_queries[559].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } const INPUT_SIZE_560: usize = 2; const IN_560: usize = 2; 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 __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; 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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_3]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_560] = [__v_7]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_560] = [__v_6]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].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() { 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].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() { 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_560] = [__v_10]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].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() { 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_560] = [__v_10]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_560] = [__v_8]; record.function_queries[560].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_561: usize = 2; const IN_561: usize = 2; 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 __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 __ret: [G; OUT_561] = [__v_12]; record.function_queries[561].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() { 0u64 => { let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_11, __v_21]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__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(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_23: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_561] = [__v_24]; record.function_queries[561].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_562: usize = 16; -const IN_562: usize = 16; +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 __loaded: [G; 3] = { let __base = 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_561] = [__v_8]; record.function_queries[561].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_561] = [__v_8]; record.function_queries[561].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(2); let __ret: [G; OUT_561] = [__v_8]; record.function_queries[561].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_561] = [__v_10]; record.function_queries[561].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_562: usize = 4; +const IN_562: usize = 4; 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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_546] = { let __args: [G; IN_546] = [__v_7, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_6, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_5, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_4, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_21, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_20, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_19, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_18, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_17, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_16, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_562] = [__v_30]; record.function_queries[562].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = inp[3]; match __v_0.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_562] = [__v_4]; record.function_queries[562].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_562] = [__v_4]; record.function_queries[562].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); let __ret: [G; OUT_562] = [__v_4]; record.function_queries[562].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_562] = [__v_4]; record.function_queries[562].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_563: usize = 2; const IN_563: usize = 2; 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]; 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_563] = [__v_8]; record.function_queries[563].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_563] = [__v_8]; record.function_queries[563].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(2); let __ret: [G; OUT_563] = [__v_8]; record.function_queries[563].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(547, (&__args[..]))?) { [G::ZERO; OUT_547] } else { let (__hash, __hit) = record.function_queries[547].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[547].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { (*(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547])) }; __ret }, _ => { aiur_fn_547::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_563] = [__v_10]; record.function_queries[563].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_564: usize = 3; -const IN_564: usize = 3; -const OUT_564: usize = 2; -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 = inp[2]; let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = []; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __ret: [G; OUT_564] = [__v_4, __v_5]; record.function_queries[564].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]; 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]; let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_564] = [__v_12, __v_13]; record.function_queries[564].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_565: usize = 9; -const IN_565: usize = 9; -const OUT_565: usize = 2; -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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; match __v_0.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_10, __v_11]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_5]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_10, __v_11]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_5, __v_8]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_14, __v_15]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_1, __v_5, __v_8]; 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 = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_13, __v_14]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_1, __v_5, __v_8]; 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 = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_13, __v_14]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_1, __v_5, __v_8]; 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 = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_13, __v_14]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_1, __v_5, __v_8]; 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 = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_3, __v_7, __v_8]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_11, __v_12, __v_13, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_9, __v_10, __v_15, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_17, __v_18]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_1, __v_2, __v_5, __v_6]; 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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_10, __v_11]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_3, __v_7, __v_8]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_12, __v_13, __v_14, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_9, __v_10, __v_16, __v_17]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_18, __v_19]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_565] = [__v_9, __v_10]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_566: usize = 7; -const IN_566: usize = 7; -const OUT_566: usize = 2; -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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; match __v_0.as_canonical_u64() { _ => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_5, __v_6]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_8, __v_9, __v_10, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_566] = [__v_12, __v_13]; record.function_queries[566].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +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]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(793, (&__args[..]))?) { [G::ZERO; OUT_793] } else { let (__hash, __hit) = record.function_queries[793].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[793].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[793].bump_multiplicity(__i); } let __ret: [G; OUT_793] = unsafe { (*(record.function_queries[793].output_at(__i).as_ptr() as *const [G; OUT_793])) }; __ret }, _ => { aiur_fn_793::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(793, (&__args[..]))?) { [G::ZERO; OUT_793] } else { let (__hash, __hit) = record.function_queries[793].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[793].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[793].bump_multiplicity(__i); } let __ret: [G; OUT_793] = unsafe { (*(record.function_queries[793].output_at(__i).as_ptr() as *const [G; OUT_793])) }; __ret }, _ => { aiur_fn_793::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_3]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_563] = [__v_7]; record.function_queries[563].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_563] = [__v_6]; 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 __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 __ret: [G; OUT_564] = [__v_12]; record.function_queries[564].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() { 0u64 => { let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_11, __v_21]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__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(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_23: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_22, __v_23]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_564] = [__v_24]; record.function_queries[564].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_565: usize = 16; +const IN_565: usize = 16; +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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_549] = { let __args: [G; IN_549] = [__v_7, __v_15]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_6, __v_14]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_5, __v_13]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_12]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_11]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_2, __v_10]; 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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_1, __v_9]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_8]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_22, __v_23]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_21, __v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_20, __v_25]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_19, __v_26]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_18, __v_27]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_17, __v_28]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_16, __v_29]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_565] = [__v_30]; record.function_queries[565].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_566: usize = 2; +const IN_566: usize = 2; +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 __loaded: [G; 3] = { let __base = 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_566] = [__v_8]; record.function_queries[566].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_566] = [__v_8]; record.function_queries[566].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(2); let __ret: [G; OUT_566] = [__v_8]; record.function_queries[566].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_566] = [__v_10]; record.function_queries[566].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_567: usize = 3; const IN_567: usize = 3; const OUT_567: usize = 2; -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 __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 __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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = []; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_567] = [__v_13, __v_14]; record.function_queries[567].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = []; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(548, (&__args[..]))?) { [G::ZERO; OUT_548] } else { let (__hash, __hit) = record.function_queries[548].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[548].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { (*(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548])) }; __ret }, _ => { aiur_fn_548::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_567] = [__v_13, __v_14]; record.function_queries[567].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_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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = []; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_567] = [__v_13, __v_14]; record.function_queries[567].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_7, __v_12, __v_2]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_13, __v_14, __v_15, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_567] = [__v_17, __v_18]; record.function_queries[567].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_568: usize = 12; -const IN_568: usize = 12; -const OUT_568: usize = 1; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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(0); let __ret: [G; OUT_568] = [__v_12]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_568] = [__v_12]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_568] = [__v_12]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_568] = [__v_12]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); let __ret: [G; OUT_568] = [__v_12]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); let __ret: [G; OUT_568] = [__v_12]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); let __ret: [G; OUT_568] = [__v_12]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); let __ret: [G; OUT_568] = [__v_12]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_569: usize = 25; -const IN_569: usize = 25; +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 = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = []; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __ret: [G; OUT_567] = [__v_4, __v_5]; record.function_queries[567].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]; 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]; let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_567] = [__v_12, __v_13]; record.function_queries[567].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_568: usize = 9; +const IN_568: usize = 9; +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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; match __v_0.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_1, __v_5]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_10, __v_11]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_1, __v_5]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_10, __v_11]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_1, __v_5, __v_8]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_14, __v_15]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_13, __v_14]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_13, __v_14]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_13, __v_14]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3, __v_7, __v_8]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_11, __v_12, __v_13, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_9, __v_10, __v_15, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_17, __v_18]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_1, __v_2, __v_5, __v_6]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_10, __v_11]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_1, __v_5, __v_8]; 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 __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_2, __v_6]; 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 __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3, __v_7, __v_8]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_12, __v_13, __v_14, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_9, __v_10, __v_16, __v_17]; 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]; let __v_19: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_18, __v_19]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_568] = [__v_9, __v_10]; record.function_queries[568].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_569: usize = 7; +const IN_569: usize = 7; const OUT_569: usize = 2; -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]; 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 __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__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(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_25: G = __r_arr[0]; let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__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(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_26: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __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(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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_569] = [__v_28, __v_29]; record.function_queries[569].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_569] = [__v_28, __v_29]; record.function_queries[569].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_570: usize = 25; -const IN_570: usize = 25; +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]; match __v_0.as_canonical_u64() { _ => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_1, __v_4]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_2, __v_5, __v_6]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_8, __v_9, __v_10, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_569] = [__v_12, __v_13]; record.function_queries[569].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_570: usize = 3; +const IN_570: usize = 3; const OUT_570: usize = 2; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_0.as_canonical_u64() { 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_14, __v_24]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_3, __v_15, __v_24]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_28, __v_29, __v_30, __v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_26, __v_27, __v_32, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_34, __v_35]; record.function_queries[570].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = []; 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 __v_26: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_25, __v_26]; record.function_queries[570].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 5u64 => { match __v_12.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_6, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_4, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_32, __v_33, __v_35, __v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_29, __v_30, __v_37, __v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_26, __v_27, __v_39, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_5, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_14, __v_24]; 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_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_571] = { let __args: [G; IN_571] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; 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 __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_44, __v_45, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_41, __v_42, __v_49, __v_50]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_51, __v_52]; record.function_queries[570].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_41, __v_42, __v_44, __v_45]; 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_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_46, __v_47]; record.function_queries[570].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = []; 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 __v_26: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_25, __v_26]; record.function_queries[570].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 7u64 => { match __v_12.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_4, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_5, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_6, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_8, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_14, __v_24]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_7, __v_19, __v_24]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_43, __v_44, __v_45, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_41, __v_42, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_38, __v_39, __v_49, __v_50]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_35, __v_36, __v_51, __v_52]; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_32, __v_33, __v_53, __v_54]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_29, __v_30, __v_55, __v_56]; 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_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_26, __v_27, __v_57, __v_58]; 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_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_59, __v_60]; record.function_queries[570].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = []; 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 __v_26: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_25, __v_26]; record.function_queries[570].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = []; 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 __v_26: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_25, __v_26]; record.function_queries[570].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_571: usize = 7; -const IN_571: usize = 7; -const OUT_571: usize = 2; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = (__v_4 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = []; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_571] = [__v_8, __v_9]; record.function_queries[571].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1, __v_6]; 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_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_298] = { let __args: [G; IN_298] = [__v_2, __v_3, __v_6]; 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_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_572] = { let __args: [G; IN_572] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; 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 __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = G::from_u64(1); let __v_37: G = (__v_6 + __v_36); let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; 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 __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_34, __v_35, __v_38, __v_39]; 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_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __ret: [G; OUT_571] = [__v_40, __v_41]; record.function_queries[571].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __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 __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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = []; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_13, __v_14]; record.function_queries[570].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = []; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_13, __v_14]; record.function_queries[570].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_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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = []; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_13, __v_14]; record.function_queries[570].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_7, __v_12, __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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_13, __v_14, __v_15, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_17, __v_18]; record.function_queries[570].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_571: usize = 12; +const IN_571: usize = 12; +const OUT_571: usize = 1; +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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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(0); let __ret: [G; OUT_571] = [__v_12]; record.function_queries[571].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_571] = [__v_12]; record.function_queries[571].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_571] = [__v_12]; record.function_queries[571].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_571] = [__v_12]; record.function_queries[571].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); let __ret: [G; OUT_571] = [__v_12]; record.function_queries[571].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); let __ret: [G; OUT_571] = [__v_12]; record.function_queries[571].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); let __ret: [G; OUT_571] = [__v_12]; record.function_queries[571].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); let __ret: [G; OUT_571] = [__v_12]; record.function_queries[571].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_572: usize = 25; const IN_572: usize = 25; const OUT_572: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_0.as_canonical_u64() { 6u64 => { match __v_12.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_5, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_6, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_7, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_14, __v_24]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_35, __v_36, __v_37, __v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_32, __v_33, __v_39, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_29, __v_30, __v_41, __v_42]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_26, __v_27, __v_43, __v_44]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __ret: [G; OUT_572] = [__v_45, __v_46]; record.function_queries[572].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__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(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_25: G = __r_arr[0]; let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__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(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_26: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_572] = [__v_28, __v_29]; record.function_queries[572].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__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(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_25: G = __r_arr[0]; let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__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(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_26: G = __r_arr[0]; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(546, (&__args[..]))?) { [G::ZERO; OUT_546] } else { let (__hash, __hit) = record.function_queries[546].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[546].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { (*(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546])) }; __ret }, _ => { aiur_fn_546::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_572] = [__v_28, __v_29]; record.function_queries[572].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_573: usize = 3; -const IN_573: usize = 3; -const OUT_573: usize = 1; -fn aiur_fn_573(inp: [G; IN_573], 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 __v_2: G = inp[2]; let __v_3: G = G::from_u64(4); let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_1]; 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 __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_301] = { let __args: [G; IN_301] = [__v_2]; 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 __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 = 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_78] = { let __args: [G; IN_78] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_22, __v_22, __v_22, __v_22]; 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 __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_23]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_573] = [__v_24]; record.function_queries[573].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_574: usize = 2; -const IN_574: usize = 2; -const OUT_574: usize = 12; -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 __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__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_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]; let __ret: [G; OUT_574] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; record.function_queries[574].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_575: usize = 2; -const IN_575: usize = 2; -const OUT_575: usize = 1; -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 __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_0, __v_1]; 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_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]; match __v_2.as_canonical_u64() { 5u64 => { let __ret: [G; OUT_575] = [__v_7]; record.function_queries[575].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_575] = [__v_14]; record.function_queries[575].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__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(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 __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__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(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 __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_25, __v_26]; 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_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __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(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 __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_572] = [__v_28, __v_29]; record.function_queries[572].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_572] = [__v_28, __v_29]; record.function_queries[572].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_573: usize = 25; +const IN_573: usize = 25; +const OUT_573: usize = 2; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_0.as_canonical_u64() { 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_1, __v_13]; 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_555] = { let __args: [G; IN_555] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_2, __v_14, __v_24]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3, __v_15, __v_24]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_28, __v_29, __v_30, __v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_26, __v_27, __v_32, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __ret: [G; OUT_573] = [__v_34, __v_35]; record.function_queries[573].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = []; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __ret: [G; OUT_573] = [__v_25, __v_26]; record.function_queries[573].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 5u64 => { match __v_12.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_6, __v_18]; 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_555] = { let __args: [G; IN_555] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_1, __v_13]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_15]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_16]; 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_34: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_32, __v_33, __v_35, __v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_29, __v_30, __v_37, __v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_26, __v_27, __v_39, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_5, __v_17]; 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_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_2, __v_14, __v_24]; 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_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_574] = { let __args: [G; IN_574] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_44, __v_45, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_41, __v_42, __v_49, __v_50]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __ret: [G; OUT_573] = [__v_51, __v_52]; record.function_queries[573].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_41, __v_42, __v_44, __v_45]; 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_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __ret: [G; OUT_573] = [__v_46, __v_47]; record.function_queries[573].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = []; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __ret: [G; OUT_573] = [__v_25, __v_26]; record.function_queries[573].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 7u64 => { match __v_12.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_1, __v_13]; 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_555] = { let __args: [G; IN_555] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_15]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_16]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_5, __v_17]; 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_34: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_6, __v_18]; 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_37: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_8, __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_40: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_2, __v_14, __v_24]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_7, __v_19, __v_24]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_43, __v_44, __v_45, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_41, __v_42, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_38, __v_39, __v_49, __v_50]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_35, __v_36, __v_51, __v_52]; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_32, __v_33, __v_53, __v_54]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_29, __v_30, __v_55, __v_56]; 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_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_26, __v_27, __v_57, __v_58]; 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_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __ret: [G; OUT_573] = [__v_59, __v_60]; record.function_queries[573].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = []; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __ret: [G; OUT_573] = [__v_25, __v_26]; record.function_queries[573].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = []; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __ret: [G; OUT_573] = [__v_25, __v_26]; record.function_queries[573].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_574: usize = 7; +const IN_574: usize = 7; +const OUT_574: usize = 2; +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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = (__v_4 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = []; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_574] = [__v_8, __v_9]; record.function_queries[574].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_1, __v_6]; 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 __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_301] = { let __args: [G; IN_301] = [__v_2, __v_3, __v_6]; 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_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_575] = { let __args: [G; IN_575] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; 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 __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = G::from_u64(1); let __v_37: G = (__v_6 + __v_36); let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_34, __v_35, __v_38, __v_39]; 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_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __ret: [G; OUT_574] = [__v_40, __v_41]; record.function_queries[574].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_575: usize = 25; +const IN_575: usize = 25; +const OUT_575: usize = 2; +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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_0.as_canonical_u64() { 6u64 => { match __v_12.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_1, __v_13]; 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_555] = { let __args: [G; IN_555] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_5, __v_17]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_6, __v_18]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_19]; 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_34: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_2, __v_14, __v_24]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_35, __v_36, __v_37, __v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_32, __v_33, __v_39, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_29, __v_30, __v_41, __v_42]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_26, __v_27, __v_43, __v_44]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __ret: [G; OUT_575] = [__v_45, __v_46]; record.function_queries[575].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__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(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 __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__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(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 __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_25, __v_26]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_575] = [__v_28, __v_29]; record.function_queries[575].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__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(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 __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__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(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 __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_25, __v_26]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_575] = [__v_28, __v_29]; record.function_queries[575].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_576: usize = 3; const IN_576: usize = 3; 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]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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 __v_5: G = __r_arr[0]; let __ret: [G; OUT_576] = [__v_5]; record.function_queries[576].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_577: usize = 5; -const IN_577: usize = 5; -const OUT_577: usize = 1; -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]; 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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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 __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_577] = [__v_9]; record.function_queries[577].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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 __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_3 + __v_10); let __v_12: G = (__v_4 + __v_9); let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_7, __v_1, __v_2, __v_11, __v_12]; 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 __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_8, __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_14: G = __r_arr[0]; let __ret: [G; OUT_577] = [__v_14]; record.function_queries[577].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_578: usize = 5; -const IN_578: usize = 5; -const OUT_578: usize = 2; -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 = 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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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 __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(0); let __ret: [G; OUT_578] = [__v_9, __v_10]; record.function_queries[578].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_1, __v_6]; 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 __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_2, __v_6, __v_10, __v_4, __v_11]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_12, __v_8]; 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_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_11, __v_13, __v_3, __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 = { let __a_val = __v_9.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_16.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_578] = [__v_15, __v_10]; record.function_queries[578].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_578] = [__v_15, __v_9]; record.function_queries[578].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_579: usize = 5; -const IN_579: usize = 5; +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]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(4); let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__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_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_304] = { let __args: [G; IN_304] = [__v_2]; 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_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 = 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_79] = { let __args: [G; IN_79] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_22, __v_22, __v_22, __v_22]; 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_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_576] = [__v_24]; record.function_queries[576].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_577: usize = 2; +const IN_577: usize = 2; +const OUT_577: usize = 12; +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 __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_2]; 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_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]; let __ret: [G; OUT_577] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; record.function_queries[577].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_578: usize = 2; +const IN_578: usize = 2; +const OUT_578: usize = 1; +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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_0, __v_1]; 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 __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]; match __v_2.as_canonical_u64() { 5u64 => { let __ret: [G; OUT_578] = [__v_7]; record.function_queries[578].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_578] = [__v_14]; record.function_queries[578].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_579: usize = 3; +const IN_579: usize = 3; const OUT_579: usize = 1; -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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = (__v_2 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { 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(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_579] = [__v_7]; record.function_queries[579].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_1, __v_4]; 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 __v_7: G = __r_arr[0]; let __v_8: G = (__v_3 + __v_4); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_0, __v_1, __v_2, __v_3, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_6, __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_579] = [__v_12]; record.function_queries[579].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_580: usize = 3; -const IN_580: usize = 3; +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 __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_579] = [__v_5]; record.function_queries[579].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_580: usize = 5; +const IN_580: usize = 5; const OUT_580: usize = 1; -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 = G::from_u64(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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_3, __v_0, __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_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_4 + __v_7); let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6, __v_1, __v_2, __v_8]; 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 __v_9: G = __r_arr[0]; let __ret: [G; OUT_580] = [__v_9]; record.function_queries[580].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_581: usize = 4; -const IN_581: usize = 4; -const OUT_581: usize = 1; -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]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_581] = [__v_0]; record.function_queries[581].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_0, __v_1, __v_2, __v_4, __v_5]; 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 __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_6, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_581] = [__v_0]; record.function_queries[581].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_581] = { let __args: [G; IN_581] = [__v_7, __v_1, __v_2, __v_10]; 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 __v_11: G = __r_arr[0]; let __ret: [G; OUT_581] = [__v_11]; record.function_queries[581].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_582: usize = 3; -const IN_582: usize = 3; +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 __loaded: [G; 3] = { let __base = 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() { 1u64 => { let __v_8: G = G::from_u64(1); 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_580] = [__v_9]; record.function_queries[580].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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 __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_3 + __v_10); let __v_12: G = (__v_4 + __v_9); let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_7, __v_1, __v_2, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_8, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(785, (&__args[..]))?) { [G::ZERO; OUT_785] } else { let (__hash, __hit) = record.function_queries[785].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[785].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { (*(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785])) }; __ret }, _ => { aiur_fn_785::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_580] = [__v_14]; record.function_queries[580].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +const INPUT_SIZE_581: usize = 5; +const IN_581: usize = 5; +const OUT_581: usize = 2; +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]; let __loaded: [G; 3] = { let __base = 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() { 1u64 => { let __v_8: G = G::from_u64(1); 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(0); let __ret: [G; OUT_581] = [__v_9, __v_10]; record.function_queries[581].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_1, __v_6]; 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 __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_6, __v_10, __v_4, __v_11]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_12, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(785, (&__args[..]))?) { [G::ZERO; OUT_785] } else { let (__hash, __hit) = record.function_queries[785].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[785].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { (*(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785])) }; __ret }, _ => { aiur_fn_785::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_11, __v_13, __v_3, __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 = { let __a_val = __v_9.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_16.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_581] = [__v_15, __v_10]; record.function_queries[581].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_581] = [__v_15, __v_9]; record.function_queries[581].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +const INPUT_SIZE_582: usize = 5; +const IN_582: usize = 5; const OUT_582: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_582] = [__v_7]; record.function_queries[582].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_4, __v_1, __v_2]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_5, __v_1, __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 __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_582] = [__v_8]; record.function_queries[582].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +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 = inp[4]; let __v_5: G = (__v_2 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { 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(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_582] = [__v_7]; record.function_queries[582].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_1, __v_4]; 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_7: G = __r_arr[0]; let __v_8: G = (__v_3 + __v_4); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_1, __v_2, __v_3, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_6, __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_582] = [__v_12]; record.function_queries[582].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_583: usize = 3; const IN_583: usize = 3; 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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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 __ret: [G; OUT_583] = [__v_5]; record.function_queries[583].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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_0, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_583] = [__v_7]; record.function_queries[583].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_2]; 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 __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_1, __v_2]; 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 __v_5: G = __r_arr[0]; let __ret: [G; OUT_583] = [__v_5]; record.function_queries[583].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_584: usize = 3; -const IN_584: usize = 3; +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 = G::from_u64(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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_3, __v_0, __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_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_4 + __v_7); let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_6, __v_1, __v_2, __v_8]; 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 __v_9: G = __r_arr[0]; let __ret: [G; OUT_583] = [__v_9]; record.function_queries[583].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_584: usize = 4; +const IN_584: usize = 4; const OUT_584: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_584] = [__v_7]; record.function_queries[584].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_1, __v_2]; 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 __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_6, __v_1, __v_2]; 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 __v_7: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_7]; record.function_queries[584].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_585: usize = 4; -const IN_585: usize = 4; +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]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_584] = [__v_0]; record.function_queries[584].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __v_1, __v_2, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_0, __v_6, __v_1]; 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 __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_584] = [__v_0]; record.function_queries[584].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_584] = { let __args: [G; IN_584] = [__v_7, __v_1, __v_2, __v_10]; 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 __v_11: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_585: usize = 3; +const IN_585: usize = 3; const OUT_585: usize = 1; -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 __loaded: [G; 3] = { let __base = 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 __v_7: G = G::from_u64(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_7, __v_0, __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_585] = [__v_10]; record.function_queries[585].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_0]; 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 = __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 __v_16: G = __r_arr[9]; let __v_17: G = __r_arr[10]; let __v_18: G = __r_arr[11]; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_5]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __v_28: G = __r_arr[9]; let __v_29: G = __r_arr[10]; let __v_30: G = __r_arr[11]; let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if ((!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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { 0u64 => { let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_585] = [__v_34]; record.function_queries[585].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_0, __v_6, __v_2, __v_3]; 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 __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_585] = [__v_35]; record.function_queries[585].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_585] = [__v_7]; record.function_queries[585].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_1, __v_2]; 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 __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_1, __v_2]; 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 __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_585] = [__v_8]; record.function_queries[585].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_586: usize = 3; const IN_586: usize = 3; const OUT_586: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_586] = [__v_7]; record.function_queries[586].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_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_587] = { let __args: [G; IN_587] = [__v_5, __v_1, __v_2, __v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(587, (&__args[..]))?) { [G::ZERO; OUT_587] } else { let (__hash, __hit) = record.function_queries[587].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[587].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { (*(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587])) }; __ret }, _ => { aiur_fn_587::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_586] = [__v_10]; record.function_queries[586].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_587: usize = 5; -const IN_587: usize = 5; +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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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 __ret: [G; OUT_586] = [__v_5]; record.function_queries[586].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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_0, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_586] = [__v_7]; record.function_queries[586].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(587, (&__args[..]))?) { [G::ZERO; OUT_587] } else { let (__hash, __hit) = record.function_queries[587].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[587].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { (*(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587])) }; __ret }, _ => { aiur_fn_587::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_4, __v_1, __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_5: G = __r_arr[0]; let __ret: [G; OUT_586] = [__v_5]; record.function_queries[586].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_587: usize = 3; +const IN_587: usize = 3; 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 __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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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 __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_8, __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_587] = [__v_11]; record.function_queries[587].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_2, __v_3]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __v_11: G = __r_arr[3]; let __v_12: G = __r_arr[4]; let __v_13: G = __r_arr[5]; let __v_14: G = __r_arr[6]; let __v_15: G = __r_arr[7]; let __v_16: G = __r_arr[8]; let __v_17: G = __r_arr[9]; let __v_18: G = __r_arr[10]; let __v_19: G = __r_arr[11]; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_2, __v_6]; 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_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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if ((!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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4, __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_34: G = __r_arr[0]; let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(587, (&__args[..]))?) { [G::ZERO; OUT_587] } else { let (__hash, __hit) = record.function_queries[587].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[587].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { (*(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587])) }; __ret }, _ => { aiur_fn_587::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_587] = [__v_35]; record.function_queries[587].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); let __v_36: 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 __v_37: G = { let __values: [G; 3] = [__v_34, __v_6, __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_587] = { let __args: [G; IN_587] = [__v_7, __v_1, __v_2, __v_6, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(587, (&__args[..]))?) { [G::ZERO; OUT_587] } else { let (__hash, __hit) = record.function_queries[587].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[587].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { (*(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587])) }; __ret }, _ => { aiur_fn_587::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 3] = [__v_34, __v_4, __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_587] = [__v_39]; record.function_queries[587].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_588: usize = 2; -const IN_588: usize = 2; +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 __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_587] = [__v_7]; record.function_queries[587].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(587, (&__args[..]))?) { [G::ZERO; OUT_587] } else { let (__hash, __hit) = record.function_queries[587].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[587].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { (*(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587])) }; __ret }, _ => { aiur_fn_587::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_4, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_587] = [__v_7]; record.function_queries[587].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_588: usize = 4; +const IN_588: usize = 4; 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 __loaded: [G; 3] = { let __base = 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_588] = [__v_8]; record.function_queries[588].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_588] = [__v_8]; record.function_queries[588].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_588] = [__v_8]; record.function_queries[588].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_588] = [__v_9]; 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_7]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_588] = [__v_9]; record.function_queries[588].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_589: usize = 1; -const IN_589: 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 __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 __v_7: G = G::from_u64(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_7, __v_0, __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_588] = [__v_10]; record.function_queries[588].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_0]; 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 __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 __v_16: G = __r_arr[9]; let __v_17: G = __r_arr[10]; let __v_18: G = __r_arr[11]; let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_5]; 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 __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __v_28: G = __r_arr[9]; let __v_29: G = __r_arr[10]; let __v_30: G = __r_arr[11]; let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if ((!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 __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { 0u64 => { let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_588] = [__v_34]; record.function_queries[588].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_6, __v_2, __v_3]; 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_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_588] = [__v_35]; record.function_queries[588].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_589: usize = 3; +const IN_589: usize = 3; 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 __loaded: [G; 3] = { let __base = 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_589] = [__v_5]; record.function_queries[589].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_3]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_589] = [__v_5]; record.function_queries[589].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_590: usize = 1; -const IN_590: 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 __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_589] = [__v_7]; record.function_queries[589].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_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_590] = { let __args: [G; IN_590] = [__v_5, __v_1, __v_2, __v_4, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_589] = [__v_10]; record.function_queries[589].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_590: usize = 5; +const IN_590: usize = 5; 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 __loaded: [G; 3] = { let __base = 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_590] = [__v_4]; record.function_queries[590].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_3]; 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]; let __ret: [G; OUT_590] = [__v_5]; record.function_queries[590].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_590] = [__v_5]; record.function_queries[590].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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 __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_8, __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_590] = [__v_11]; record.function_queries[590].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_3]; 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 __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __v_11: G = __r_arr[3]; let __v_12: G = __r_arr[4]; let __v_13: G = __r_arr[5]; let __v_14: G = __r_arr[6]; let __v_15: G = __r_arr[7]; let __v_16: G = __r_arr[8]; let __v_17: G = __r_arr[9]; let __v_18: G = __r_arr[10]; let __v_19: G = __r_arr[11]; let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_6]; 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 __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 __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if ((!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 __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_4, __v_6]; 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_34: G = __r_arr[0]; let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2, __v_6, __v_34]; 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_35: G = __r_arr[0]; let __ret: [G; OUT_590] = [__v_35]; record.function_queries[590].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); let __v_36: 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 __v_37: G = { let __values: [G; 3] = [__v_34, __v_6, __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_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2, __v_6, __v_37]; 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_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 3] = [__v_34, __v_4, __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_590] = [__v_39]; record.function_queries[590].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.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; 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(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 __ret: [G; OUT_591] = [__v_50]; record.function_queries[591].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_48, __v_50]; 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_51: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __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_591] = [__v_53]; record.function_queries[591].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_591] = [__v_51]; 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 = 2; -const IN_592: usize = 2; +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 __loaded: [G; 3] = { let __base = 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_591] = [__v_8]; record.function_queries[591].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_591] = [__v_8]; record.function_queries[591].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_591] = [__v_8]; record.function_queries[591].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_3, __v_6]; 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]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_591] = [__v_9]; 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_7]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_591] = [__v_9]; record.function_queries[591].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_592: usize = 1; +const IN_592: usize = 1; const OUT_592: usize = 1; -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 __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_592] = [__v_49]; record.function_queries[592].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_592] = [__v_50]; record.function_queries[592].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_48, __v_1]; 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_50: G = __r_arr[0]; let __ret: [G; OUT_592] = [__v_50]; record.function_queries[592].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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_592] = [__v_5]; record.function_queries[592].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_592] = [__v_5]; record.function_queries[592].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_593: usize = 1; const IN_593: usize = 1; -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 __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_592] = { let __args: [G; IN_592] = [__v_2, __v_49]; 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_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_51]; 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_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 __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_51]; 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_54: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(2); let __v_57: G = { let __a_val = __v_55.as_canonical_u64(); let __b_val = __v_56.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = 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_57.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_593] = []; record.function_queries[593].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_2, __v_0]; 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_58: G = __r_arr[0]; let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(1); let __v_61: G = { let __values: [G; 3] = [__v_60, __v_60, __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_59, __v_54, __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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = (__v_60 + __v_63); let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_62, __v_58, __v_0, __v_64]; 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 __v_65: G = __r_arr[0]; let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_65]; 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_66: G = __r_arr[0]; if (__v_66 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) }); } let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_65]; 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_67: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_67, __v_54]; 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_68: G = __r_arr[0]; if (__v_68 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) }); } let __ret: [G; OUT_593] = []; record.function_queries[593].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_593] = []; record.function_queries[593].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_594: usize = 12; -const IN_594: usize = 12; +const OUT_593: usize = 1; +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 __loaded: [G; 3] = { let __base = 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_593] = [__v_4]; record.function_queries[593].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_3]; 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 __v_5: G = __r_arr[0]; let __ret: [G; OUT_593] = [__v_5]; record.function_queries[593].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_593] = [__v_5]; record.function_queries[593].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_594: usize = 2; +const IN_594: usize = 2; const OUT_594: usize = 1; -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 __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_594] = [__v_3]; record.function_queries[594].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_594] = [__v_12]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_594] = [__v_12]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_594] = [__v_12]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_594] = [__v_4]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_594] = [__v_12]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_594] = [__v_6]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_594] = [__v_8]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_594] = [__v_9]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_595: usize = 1; -const IN_595: usize = 1; +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 __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(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 __ret: [G; OUT_594] = [__v_50]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_48, __v_50]; 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 __v_51: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __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_594] = [__v_53]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_594] = [__v_51]; record.function_queries[594].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_595: usize = 2; +const IN_595: usize = 2; const OUT_595: usize = 1; -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 __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_595] = [__v_5]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_595] = [__v_5]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__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_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_594] = { let __args: [G; IN_594] = [__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(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 __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); let __ret: [G; OUT_595] = [__v_20]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3]; 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_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_595] = [__v_7]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3]; 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_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_595] = [__v_7]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3]; 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_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_595] = [__v_7]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__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_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __v_9: G = (__v_5 * __v_8); let __ret: [G; OUT_595] = [__v_9]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_595] = [__v_5]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__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_5: G = __r_arr[0]; let __ret: [G; OUT_595] = [__v_5]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_596: usize = 2; -const IN_596: usize = 2; +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 __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_595] = [__v_49]; record.function_queries[595].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_595] = [__v_50]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_48, __v_1]; 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_50: G = __r_arr[0]; let __ret: [G; OUT_595] = [__v_50]; record.function_queries[595].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_596: usize = 1; +const IN_596: usize = 1; 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]; match __v_0.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_596] = []; record.function_queries[596].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_1]; 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_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_596] = []; record.function_queries[596].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_597: usize = 2; -const IN_597: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_597] = []; record.function_queries[597].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_3, __v_1]; 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); }, 2u64 => { let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_1]; 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); }, 3u64 => { let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_1]; 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); }, 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_597] = []; record.function_queries[597].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_598: usize = 2; -const IN_598: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_598] = []; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4, __v_1]; 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_598] = []; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_599: usize = 3; -const IN_599: usize = 3; +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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_595] = { let __args: [G; IN_595] = [__v_2, __v_49]; 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_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_2, __v_51]; 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_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 __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_2, __v_51]; 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 __v_54: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(2); let __v_57: G = { let __a_val = __v_55.as_canonical_u64(); let __b_val = __v_56.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = 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_57.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_596] = []; record.function_queries[596].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2, __v_0]; 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_58: G = __r_arr[0]; let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(1); let __v_61: G = { let __values: [G; 3] = [__v_60, __v_60, __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_59, __v_54, __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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = (__v_60 + __v_63); let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_62, __v_58, __v_0, __v_64]; 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 __v_65: G = __r_arr[0]; let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_65]; 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 __v_66: G = __r_arr[0]; if (__v_66 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) }); } let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_65]; 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_67: G = __r_arr[0]; let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_67, __v_54]; 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_68: G = __r_arr[0]; if (__v_68 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) }); } let __ret: [G; OUT_596] = []; record.function_queries[596].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_596] = []; record.function_queries[596].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_597: usize = 12; +const IN_597: usize = 12; +const OUT_597: usize = 1; +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 __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_597] = [__v_3]; record.function_queries[597].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_597] = [__v_12]; record.function_queries[597].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_597] = [__v_12]; record.function_queries[597].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_597] = [__v_12]; record.function_queries[597].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_597] = [__v_4]; record.function_queries[597].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_597] = [__v_12]; record.function_queries[597].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_597] = [__v_6]; record.function_queries[597].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_597] = [__v_8]; record.function_queries[597].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_597] = [__v_9]; record.function_queries[597].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_598: usize = 1; +const IN_598: usize = 1; +const OUT_598: usize = 1; +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 __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_598] = [__v_5]; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_598] = [__v_5]; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_2]; 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_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_597] = { let __args: [G; IN_597] = [__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(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_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); let __ret: [G; OUT_598] = [__v_20]; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_2]; 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 __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_3]; 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 __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_598] = [__v_7]; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_2]; 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 __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_3]; 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 __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_598] = [__v_7]; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_2]; 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 __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_3]; 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 __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_598] = [__v_7]; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_2]; 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 __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_3]; 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 __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4]; 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 __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __v_9: G = (__v_5 * __v_8); let __ret: [G; OUT_598] = [__v_9]; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_598] = [__v_5]; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4]; 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 __v_5: G = __r_arr[0]; let __ret: [G; OUT_598] = [__v_5]; record.function_queries[598].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_599: usize = 2; +const IN_599: usize = 2; 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 __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_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_2]; 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_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4]; 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 __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_438] = { let __args: [G; IN_438] = [__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(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_20: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_598] = { let __args: [G; IN_598] = [__v_5, __v_2]; 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_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_1, __v_2]; 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_599] = { let __args: [G; IN_599] = [__v_5, __v_1, __v_2]; 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_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_1, __v_2]; 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 __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_5, __v_8, __v_2]; 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_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_1, __v_2]; 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 __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_5, __v_8, __v_2]; 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_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_1, __v_2]; 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_599] = { let __args: [G; IN_599] = [__v_5, __v_1, __v_2]; 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 __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_8, __v_2]; 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_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_1, __v_2]; 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_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_600: usize = 0; -const IN_600: usize = 0; -const OUT_600: usize = 1; -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 = G::from_u64(69); let __v_1: G = G::from_u64(4); let __v_2: G = G::from_u64(11); let __v_3: G = G::from_u64(49); let __v_4: G = G::from_u64(38); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(81); let __v_7: G = G::from_u64(105); let __v_8: G = G::from_u64(218); let __v_9: G = G::from_u64(217); let __v_10: G = G::from_u64(25); let __v_11: G = G::from_u64(169); let __v_12: G = G::from_u64(112); let __v_13: G = G::from_u64(199); let __v_14: G = G::from_u64(44); let __v_15: G = G::from_u64(238); let __v_16: G = G::from_u64(88); let __v_17: G = G::from_u64(117); let __v_18: G = G::from_u64(101); let __v_19: G = G::from_u64(138); let __v_20: G = G::from_u64(237); let __v_21: G = G::from_u64(179); let __v_22: G = G::from_u64(189); let __v_23: G = G::from_u64(31); let __v_24: G = G::from_u64(137); let __v_25: G = G::from_u64(252); let __v_26: G = G::from_u64(223); let __v_27: G = G::from_u64(140); let __v_28: G = G::from_u64(136); let __v_29: G = G::from_u64(250); 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_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_20, __v_29]; 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_600] = [__v_30]; record.function_queries[600].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_601: usize = 0; -const IN_601: usize = 0; -const OUT_601: usize = 1; -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 = G::from_u64(195); let __v_1: G = G::from_u64(125); let __v_2: G = G::from_u64(98); let __v_3: G = G::from_u64(144); let __v_4: G = G::from_u64(224); let __v_5: G = G::from_u64(15); let __v_6: G = G::from_u64(184); let __v_7: G = G::from_u64(101); let __v_8: G = G::from_u64(251); let __v_9: G = G::from_u64(93); let __v_10: G = G::from_u64(183); let __v_11: G = G::from_u64(188); let __v_12: G = G::from_u64(225); let __v_13: G = G::from_u64(143); let __v_14: G = G::from_u64(214); let __v_15: G = G::from_u64(158); let __v_16: G = G::from_u64(109); let __v_17: G = G::from_u64(22); let __v_18: G = G::from_u64(116); let __v_19: G = G::from_u64(173); let __v_20: G = G::from_u64(87); let __v_21: G = G::from_u64(55); let __v_22: G = G::from_u64(36); let __v_23: G = G::from_u64(84); let __v_24: G = G::from_u64(102); let __v_25: G = G::from_u64(234); let __v_26: G = G::from_u64(159); let __v_27: G = G::from_u64(117); let __v_28: G = G::from_u64(120); let __v_29: G = G::from_u64(162); let __v_30: G = G::from_u64(7); let __v_31: 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_6, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; 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_601] = [__v_31]; record.function_queries[601].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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]; match __v_0.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_1]; 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 __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_599] = []; record.function_queries[599].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_600: usize = 2; +const IN_600: usize = 2; +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 __loaded: [G; 3] = { let __base = 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_600] = []; record.function_queries[600].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; 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); }, 2u64 => { let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; 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); }, 3u64 => { let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; 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); }, 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_600] = []; record.function_queries[600].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_601: usize = 2; +const IN_601: usize = 2; +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 __loaded: [G; 3] = { let __base = 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_601] = []; record.function_queries[601].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_4, __v_1]; 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 __ret: [G; OUT_601] = []; record.function_queries[601].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_602: usize = 3; const IN_602: usize = 3; -const OUT_602: usize = 1; -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 = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_602] = [__v_4]; record.function_queries[602].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() { 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_6, __v_1, __v_9]; 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 __v_10: G = __r_arr[0]; let __ret: [G; OUT_602] = [__v_10]; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_602] = [__v_8]; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +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 __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_602] = []; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_2]; 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_602] = []; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4]; 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_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_441] = { let __args: [G; IN_441] = [__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(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_20: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_601] = { let __args: [G; IN_601] = [__v_5, __v_2]; 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 __ret: [G; OUT_602] = []; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_1, __v_2]; 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_602] = []; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_4, __v_1, __v_2]; 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 __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_8, __v_2]; 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_602] = []; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_4, __v_1, __v_2]; 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 __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_8, __v_2]; 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_602] = []; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_1, __v_2]; 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 __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_6, __v_8, __v_2]; 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_602] = []; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_602] = []; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_6, __v_1, __v_2]; 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_602] = []; record.function_queries[602].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_603: usize = 0; const IN_603: usize = 0; -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 __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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 __v_0: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; 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_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 __v_14: G = G::from_u64(1); if (__v_3 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("Eq inductive: wrong universe param count".to_string()) }); } let __v_15: G = G::from_u64(2); if (__v_5 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("Eq inductive: wrong parameter count".to_string()) }); } if (__v_7 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); } let __ret: [G; OUT_603] = []; record.function_queries[603].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_604: usize = 4; -const IN_604: usize = 4; -const OUT_604: usize = 0; -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 __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = []; 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 __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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("Quot.Typ declared at a non-canonical address".to_string()) }); } let __v_7: G = G::from_u64(2); break '__mc_0 [__v_6, __v_7]; }, 1u64 => { let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = []; 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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("Quot.mk declared at a non-canonical address".to_string()) }); } let __v_7: G = G::from_u64(3); break '__mc_0 [__v_6, __v_7]; }, 2u64 => { let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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("Quot.lift declared at a non-canonical address".to_string()) }); } let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = []; 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 __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(6); break '__mc_0 [__v_7, __v_8]; }, 3u64 => { let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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("Quot.ind declared at a non-canonical address".to_string()) }); } let __v_7: G = G::from_u64(5); break '__mc_0 [__v_6, __v_7]; }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }; let __v_4: G = __mc_out___mc_0[0]; let __v_5: G = __mc_out___mc_0[1]; if (__v_2 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Quot constant: wrong universe param count for its kind".to_string()) }); } let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_3, __v_5, __v_6]; 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 __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("Quot constant: type has too few foralls for its kind".to_string()) }); } let __ret: [G; OUT_604] = []; record.function_queries[604].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_605: usize = 2; -const IN_605: usize = 2; +const OUT_603: usize = 1; +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 = G::from_u64(69); let __v_1: G = G::from_u64(4); let __v_2: G = G::from_u64(11); let __v_3: G = G::from_u64(49); let __v_4: G = G::from_u64(38); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(81); let __v_7: G = G::from_u64(105); let __v_8: G = G::from_u64(218); let __v_9: G = G::from_u64(217); let __v_10: G = G::from_u64(25); let __v_11: G = G::from_u64(169); let __v_12: G = G::from_u64(112); let __v_13: G = G::from_u64(199); let __v_14: G = G::from_u64(44); let __v_15: G = G::from_u64(238); let __v_16: G = G::from_u64(88); let __v_17: G = G::from_u64(117); let __v_18: G = G::from_u64(101); let __v_19: G = G::from_u64(138); let __v_20: G = G::from_u64(237); let __v_21: G = G::from_u64(179); let __v_22: G = G::from_u64(189); let __v_23: G = G::from_u64(31); let __v_24: G = G::from_u64(137); let __v_25: G = G::from_u64(252); let __v_26: G = G::from_u64(223); let __v_27: G = G::from_u64(140); let __v_28: G = G::from_u64(136); let __v_29: G = G::from_u64(250); 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_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_20, __v_29]; 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_603] = [__v_30]; record.function_queries[603].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_604: usize = 0; +const IN_604: usize = 0; +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 = G::from_u64(195); let __v_1: G = G::from_u64(125); let __v_2: G = G::from_u64(98); let __v_3: G = G::from_u64(144); let __v_4: G = G::from_u64(224); let __v_5: G = G::from_u64(15); let __v_6: G = G::from_u64(184); let __v_7: G = G::from_u64(101); let __v_8: G = G::from_u64(251); let __v_9: G = G::from_u64(93); let __v_10: G = G::from_u64(183); let __v_11: G = G::from_u64(188); let __v_12: G = G::from_u64(225); let __v_13: G = G::from_u64(143); let __v_14: G = G::from_u64(214); let __v_15: G = G::from_u64(158); let __v_16: G = G::from_u64(109); let __v_17: G = G::from_u64(22); let __v_18: G = G::from_u64(116); let __v_19: G = G::from_u64(173); let __v_20: G = G::from_u64(87); let __v_21: G = G::from_u64(55); let __v_22: G = G::from_u64(36); let __v_23: G = G::from_u64(84); let __v_24: G = G::from_u64(102); let __v_25: G = G::from_u64(234); let __v_26: G = G::from_u64(159); let __v_27: G = G::from_u64(117); let __v_28: G = G::from_u64(120); let __v_29: G = G::from_u64(162); let __v_30: G = G::from_u64(7); let __v_31: 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_6, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; 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_604] = [__v_31]; record.function_queries[604].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_605: usize = 3; +const IN_605: usize = 3; 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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_605] = [__v_0]; 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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_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_605] = { let __args: [G; IN_605] = [__v_4, __v_7]; 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_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); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_606: usize = 3; -const IN_606: usize = 3; +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 = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_605] = [__v_4]; 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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_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 __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_6, __v_1, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_605] = [__v_10]; record.function_queries[605].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_605] = [__v_8]; record.function_queries[605].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_606: usize = 0; +const IN_606: usize = 0; const OUT_606: usize = 0; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_606] = []; record.function_queries[606].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_606] = { let __args: [G; IN_606] = [__v_5, __v_10, __v_11]; 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 __ret: [G; OUT_606] = []; record.function_queries[606].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_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 __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = []; 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_0: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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 __v_14: G = G::from_u64(1); if (__v_3 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("Eq inductive: wrong universe param count".to_string()) }); } let __v_15: G = G::from_u64(2); if (__v_5 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("Eq inductive: wrong parameter count".to_string()) }); } if (__v_7 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); } let __ret: [G; OUT_606] = []; record.function_queries[606].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_607: usize = 4; const IN_607: usize = 4; const OUT_607: usize = 0; -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 __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_607] = []; record.function_queries[607].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_607] = { let __args: [G; IN_607] = [__v_7, __v_1, __v_2, __v_16]; 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 __ret: [G; OUT_607] = []; record.function_queries[607].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_608: usize = 3; -const IN_608: usize = 3; -const OUT_608: usize = 0; -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 __v_2: G = inp[2]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; 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_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_608] = []; record.function_queries[608].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_609: usize = 7; -const IN_609: usize = 7; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = []; 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 __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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("Quot.Typ declared at a non-canonical address".to_string()) }); } let __v_7: G = G::from_u64(2); break '__mc_0 [__v_6, __v_7]; }, 1u64 => { let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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("Quot.mk declared at a non-canonical address".to_string()) }); } let __v_7: G = G::from_u64(3); break '__mc_0 [__v_6, __v_7]; }, 2u64 => { let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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("Quot.lift declared at a non-canonical address".to_string()) }); } let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = []; 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_7: G = G::from_u64(2); let __v_8: G = G::from_u64(6); break '__mc_0 [__v_7, __v_8]; }, 3u64 => { let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = []; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __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_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("Quot.ind declared at a non-canonical address".to_string()) }); } let __v_7: G = G::from_u64(5); break '__mc_0 [__v_6, __v_7]; }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }; let __v_4: G = __mc_out___mc_0[0]; let __v_5: G = __mc_out___mc_0[1]; if (__v_2 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Quot constant: wrong universe param count for its kind".to_string()) }); } let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_3, __v_5, __v_6]; 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_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("Quot constant: type has too few foralls for its kind".to_string()) }); } let __ret: [G; OUT_607] = []; record.function_queries[607].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_608] = [__v_0]; record.function_queries[608].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_608] = { let __args: [G; IN_608] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_608] = [__v_8]; 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 = 3; +const IN_609: usize = 3; const OUT_609: usize = 0; -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 = (__v_1 + __v_3); let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8]; 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_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_608] = { let __args: [G; IN_608] = [__v_12, __v_5, __v_6]; 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_15: G = G::from_u64(0); let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_13, __v_4, __v_15]; 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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_607] = { let __args: [G; IN_607] = [__v_10, __v_1, __v_3, __v_15]; 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 __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_10, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_620] = { let __args: [G; IN_620] = [__v_18, __v_21]; 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_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_609] = []; record.function_queries[609].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }) } +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]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_609] = []; record.function_queries[609].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_609] = { let __args: [G; IN_609] = [__v_5, __v_10, __v_11]; 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 __ret: [G; OUT_609] = []; record.function_queries[609].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_610: usize = 4; const IN_610: usize = 4; const OUT_610: usize = 0; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_610] = []; record.function_queries[610].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() { 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_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_446] = { let __args: [G; IN_446] = [__v_5, __v_9, __v_3]; 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_12: G = __r_arr[0]; 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("ctor parameter type disagrees with the inductive's".to_string()) }); } let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __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 __v_16: G = (__v_2 - __v_13); let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_6, __v_10, __v_16, __v_15]; 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 __ret: [G; OUT_610] = []; record.function_queries[610].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } +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 __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_610] = []; record.function_queries[610].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_610] = { let __args: [G; IN_610] = [__v_7, __v_1, __v_2, __v_16]; 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 __ret: [G; OUT_610] = []; record.function_queries[610].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_611: usize = 3; const IN_611: usize = 3; const OUT_611: usize = 0; -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 __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_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_4]; 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 __ret: [G; OUT_611] = []; record.function_queries[611].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_612: usize = 3; -const IN_612: usize = 3; -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 __v_2: G = inp[2]; let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __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_3: G = __r_arr[0]; 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_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_612] = [__v_5]; record.function_queries[612].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.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_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() { 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); 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_612] = { let __args: [G; IN_612] = [__v_6, __v_9, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_612] = [__v_12]; record.function_queries[612].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_613: usize = 3; -const IN_613: usize = 3; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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_611] = []; record.function_queries[611].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_612: usize = 7; +const IN_612: usize = 7; +const OUT_612: usize = 0; +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 __v_2: G = inp[2]; let __v_3: G = 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_608] = { let __args: [G; IN_608] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_8]; 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_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_611] = { let __args: [G; IN_611] = [__v_12, __v_5, __v_6]; 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_15: G = G::from_u64(0); let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_13, __v_4, __v_15]; 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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_610] = { let __args: [G; IN_610] = [__v_10, __v_1, __v_3, __v_15]; 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 __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_10, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_623] = { let __args: [G; IN_623] = [__v_18, __v_21]; 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_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_612] = []; record.function_queries[612].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }) } +const INPUT_SIZE_613: usize = 4; +const IN_613: usize = 4; const OUT_613: usize = 0; -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 __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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_7, __v_1]; 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_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("ctor field lives in a universe above the inductive's".to_string()) }); } let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __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_613] = { let __args: [G; IN_613] = [__v_5, __v_1, __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 __ret: [G; OUT_613] = []; record.function_queries[613].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_613] = []; record.function_queries[613].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_614: usize = 4; -const IN_614: usize = 4; +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]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_613] = []; record.function_queries[613].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() { 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_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_449] = { let __args: [G; IN_449] = [__v_5, __v_9, __v_3]; 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_12: G = __r_arr[0]; 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("ctor parameter type disagrees with the inductive's".to_string()) }); } let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __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 __v_16: G = (__v_2 - __v_13); let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_6, __v_10, __v_16, __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 __ret: [G; OUT_613] = []; record.function_queries[613].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_614: usize = 3; +const IN_614: usize = 3; const OUT_614: usize = 0; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_0, __v_2, __v_3]; 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 __ret: [G; OUT_614] = []; record.function_queries[614].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() { 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __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_614] = { let __args: [G; IN_614] = [__v_6, __v_9, __v_2, __v_11]; 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 __ret: [G; OUT_614] = []; record.function_queries[614].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } +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 = 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_613] = { let __args: [G; IN_613] = [__v_0, __v_1, __v_2, __v_4]; 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 __ret: [G; OUT_614] = []; record.function_queries[614].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_615: usize = 3; const IN_615: usize = 3; -const OUT_615: usize = 0; -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 __loaded: [G; 3] = { let __base = 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_615] = []; record.function_queries[615].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_614] = { let __args: [G; IN_614] = [__v_0, __v_1, __v_2, __v_7]; 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 __ret: [G; OUT_615] = []; record.function_queries[615].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_616: usize = 2; -const IN_616: usize = 2; -const OUT_616: usize = 1; -fn aiur_fn_616(inp: [G; IN_616], 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 __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __ret: [G; OUT_616] = [__v_2]; record.function_queries[616].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_617: usize = 2; -const IN_617: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_617] = [__v_5]; record.function_queries[617].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_617] = [__v_6]; record.function_queries[617].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_617] = [__v_6]; record.function_queries[617].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -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_295] = { let __args: [G; IN_295] = [__v_0]; 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_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_617] = { let __args: [G; IN_617] = [__v_1, __v_10]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_618] = [__v_15]; record.function_queries[618].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_618] = [__v_15]; record.function_queries[618].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; 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_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_615] = [__v_5]; record.function_queries[615].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.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_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() { 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); 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_615] = { let __args: [G; IN_615] = [__v_6, __v_9, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_615] = [__v_12]; record.function_queries[615].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_616: usize = 3; +const IN_616: usize = 3; +const OUT_616: usize = 0; +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 __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() { 5u64 => { let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_7, __v_1]; 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_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("ctor field lives in a universe above the inductive's".to_string()) }); } let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __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_616] = { let __args: [G; IN_616] = [__v_5, __v_1, __v_11]; 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 __ret: [G; OUT_616] = []; record.function_queries[616].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_616] = []; record.function_queries[616].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_617: usize = 4; +const IN_617: usize = 4; +const OUT_617: usize = 0; +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 = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_2, __v_3]; 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 __ret: [G; OUT_617] = []; record.function_queries[617].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() { 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __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_617] = { let __args: [G; IN_617] = [__v_6, __v_9, __v_2, __v_11]; 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 __ret: [G; OUT_617] = []; record.function_queries[617].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_618: usize = 3; +const IN_618: usize = 3; +const OUT_618: usize = 0; +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 __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() { 0u64 => { let __ret: [G; OUT_618] = []; record.function_queries[618].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_617] = { let __args: [G; IN_617] = [__v_0, __v_1, __v_2, __v_7]; 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 __ret: [G; OUT_618] = []; record.function_queries[618].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_619: usize = 2; const IN_619: usize = 2; 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 __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_619] = [__v_6]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_619] = [__v_6]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(618, (&__args[..]))?) { [G::ZERO; OUT_618] } else { let (__hash, __hit) = record.function_queries[618].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[618].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { (*(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618])) }; __ret }, _ => { aiur_fn_618::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_619] = [__v_6]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_619] = [__v_7]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_619] = [__v_7]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_619] = [__v_7]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_619] = [__v_7]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_619] = [__v_7]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_619] = [__v_7]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_619] = [__v_7]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_619] = [__v_8]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_5, __v_1]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_619] = [__v_8]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, 7u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_619] = [__v_6]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_619] = [__v_6]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __ret: [G; OUT_619] = [__v_2]; record.function_queries[619].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_620: usize = 2; const IN_620: usize = 2; 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 __loaded: [G; 3] = { let __base = 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_620] = [__v_5]; record.function_queries[620].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_620] = [__v_6]; 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_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_620] = [__v_6]; record.function_queries[620].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_621: usize = 3; -const IN_621: usize = 3; -const OUT_621: usize = 2; -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 = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_621] = [__v_0, __v_2]; 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() { 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_621] = { let __args: [G; IN_621] = [__v_5, __v_10, __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]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_621] = [__v_11, __v_12]; record.function_queries[621].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_621] = [__v_0, __v_2]; record.function_queries[621].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_622: usize = 4; -const IN_622: usize = 4; -const OUT_622: usize = 0; -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 __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_622] = []; record.function_queries[622].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_622] = { let __args: [G; IN_622] = [__v_7, __v_1, __v_2, __v_15]; 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 __ret: [G; OUT_622] = []; record.function_queries[622].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_623: usize = 5; -const IN_623: usize = 5; -const OUT_623: usize = 0; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; 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_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_606] = { let __args: [G; IN_606] = [__v_1, __v_7, __v_18]; 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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_622] = { let __args: [G; IN_622] = [__v_2, __v_9, __v_4, __v_18]; 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 __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_21, __v_3]; 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_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_623] = []; record.function_queries[623].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } -const INPUT_SIZE_624: usize = 4; -const IN_624: usize = 4; -const OUT_624: usize = 0; -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 __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_624] = []; record.function_queries[624].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __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 __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() { 5u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_7, __v_1]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) }); } let __v_12: G = { let __values: [G; 3] = [__v_11, __v_7, __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_624] = { let __args: [G; IN_624] = [__v_8, __v_1, __v_12, __v_3]; 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 __ret: [G; OUT_624] = []; record.function_queries[624].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_13, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(618, (&__args[..]))?) { [G::ZERO; OUT_618] } else { let (__hash, __hit) = record.function_queries[618].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[618].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { (*(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618])) }; __ret }, _ => { aiur_fn_618::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_13, __v_14, __v_11, __v_1, __v_17]; 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 __ret: [G; OUT_624] = []; record.function_queries[624].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_624] = []; record.function_queries[624].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_13]; 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_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 __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_30, __v_1]; 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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) }); } let __v_33: G = { let __values: [G; 3] = [__v_32, __v_25, __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_797] = { let __args: [G; IN_797] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(785, (&__args[..]))?) { [G::ZERO; OUT_785] } else { let (__hash, __hit) = record.function_queries[785].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[785].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { (*(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785])) }; __ret }, _ => { aiur_fn_785::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_25, __v_26, __v_23, __v_33, __v_32, __v_21, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(625, (&__args[..]))?) { [G::ZERO; OUT_625] } else { let (__hash, __hit) = record.function_queries[625].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[625].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[625].bump_multiplicity(__i); } let __ret: [G; OUT_625] = unsafe { (*(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625])) }; __ret }, _ => { aiur_fn_625::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_624] = []; record.function_queries[624].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, } }, } }) } -const INPUT_SIZE_625: usize = 7; -const IN_625: usize = 7; +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 __loaded: [G; 3] = { let __base = 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_620] = [__v_5]; record.function_queries[620].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_620] = [__v_6]; 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_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_620] = [__v_6]; record.function_queries[620].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.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 __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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_620] = { let __args: [G; IN_620] = [__v_1, __v_10]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_15]; record.function_queries[621].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_15]; record.function_queries[621].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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; 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_622] = [__v_6]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_622] = [__v_6]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_622] = [__v_6]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_622] = [__v_7]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_622] = [__v_7]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_622] = [__v_7]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_622] = [__v_7]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_622] = [__v_7]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_622] = [__v_7]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_622] = [__v_7]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; match __v_7.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 __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_5, __v_1]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_622] = [__v_8]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, 7u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_622] = [__v_6]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_622] = [__v_6]; record.function_queries[622].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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 __v_5: G = G::from_u64(0); let __ret: [G; OUT_623] = [__v_5]; record.function_queries[623].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_623] = [__v_6]; record.function_queries[623].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_623] = [__v_6]; record.function_queries[623].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_624: usize = 3; +const IN_624: usize = 3; +const OUT_624: usize = 2; +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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_624] = [__v_0, __v_2]; record.function_queries[624].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_624] = { let __args: [G; IN_624] = [__v_5, __v_10, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_624] = [__v_11, __v_12]; record.function_queries[624].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_624] = [__v_0, __v_2]; record.function_queries[624].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_625: usize = 4; +const IN_625: usize = 4; const OUT_625: usize = 0; -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 __v_2: G = inp[2]; let __v_3: G = 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_2 - __v_4); match __v_7.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_625] = []; record.function_queries[625].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1, __v_4]; 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_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() { 6u64 => { 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_621] = { let __args: [G; IN_621] = [__v_11, __v_5, __v_22]; 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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = G::from_u64(0); let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_23, __v_6, __v_25]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_26, __v_3, __v_22, __v_25]; 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_27: G = (__v_4 + __v_21); let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_1, __v_2, __v_3, __v_27, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(625, (&__args[..]))?) { [G::ZERO; OUT_625] } else { let (__hash, __hit) = record.function_queries[625].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[625].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[625].bump_multiplicity(__i); } let __ret: [G; OUT_625] = unsafe { (*(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625])) }; __ret }, _ => { aiur_fn_625::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_625] = []; record.function_queries[625].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_626: usize = 4; -const IN_626: usize = 4; +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 __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_625] = []; record.function_queries[625].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_625] = { let __args: [G; IN_625] = [__v_7, __v_1, __v_2, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(625, (&__args[..]))?) { [G::ZERO; OUT_625] } else { let (__hash, __hit) = record.function_queries[625].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[625].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[625].bump_multiplicity(__i); } let __ret: [G; OUT_625] = unsafe { (*(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625])) }; __ret }, _ => { aiur_fn_625::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_625] = []; record.function_queries[625].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_626: usize = 5; +const IN_626: usize = 5; const OUT_626: usize = 0; -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 __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() { 5u64 => { let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __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_626] = { let __args: [G; IN_626] = [__v_6, __v_1, __v_9, __v_3]; 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 __ret: [G; OUT_626] = []; record.function_queries[626].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_626] = []; record.function_queries[626].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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_609] = { let __args: [G; IN_609] = [__v_1, __v_7, __v_18]; 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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_625] = { let __args: [G; IN_625] = [__v_2, __v_9, __v_4, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(625, (&__args[..]))?) { [G::ZERO; OUT_625] } else { let (__hash, __hit) = record.function_queries[625].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[625].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[625].bump_multiplicity(__i); } let __ret: [G; OUT_625] = unsafe { (*(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625])) }; __ret }, _ => { aiur_fn_625::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_21, __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_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_626] = []; record.function_queries[626].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } const INPUT_SIZE_627: usize = 4; const IN_627: usize = 4; const OUT_627: usize = 0; -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 __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 = { 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_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 __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0, __v_1, __v_3]; 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]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_7, __v_9, __v_5]; 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 __ret: [G; OUT_627] = []; record.function_queries[627].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_628: usize = 8; -const IN_628: usize = 8; +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 __v_3: G = inp[3]; let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_0, __v_1]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_627] = []; record.function_queries[627].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]; 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_5: 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_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() { 5u64 => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_7, __v_1]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) }); } let __v_12: G = { let __values: [G; 3] = [__v_11, __v_7, __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_627] = { let __args: [G; IN_627] = [__v_8, __v_1, __v_12, __v_3]; 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 __ret: [G; OUT_627] = []; record.function_queries[627].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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_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 __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_13, __v_1]; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_13, __v_14, __v_11, __v_1, __v_17]; 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 __ret: [G; OUT_627] = []; record.function_queries[627].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_627] = []; record.function_queries[627].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_13]; 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_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 __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_30, __v_1]; 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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) }); } let __v_33: G = { let __values: [G; 3] = [__v_32, __v_25, __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_800] = { let __args: [G; IN_800] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(788, (&__args[..]))?) { [G::ZERO; OUT_788] } else { let (__hash, __hit) = record.function_queries[788].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[788].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { (*(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788])) }; __ret }, _ => { aiur_fn_788::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_25, __v_26, __v_23, __v_33, __v_32, __v_21, __v_35]; 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 __ret: [G; OUT_627] = []; record.function_queries[627].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, } }, } }) } +const INPUT_SIZE_628: usize = 7; +const IN_628: usize = 7; const OUT_628: usize = 0; -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 __v_4: G = 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_1 + __v_2); 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_612] = { let __args: [G; IN_612] = [__v_0, __v_8, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_7, __v_12]; 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 __ret: [G; OUT_628] = []; record.function_queries[628].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_629: usize = 10; -const IN_629: usize = 10; +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 __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = (__v_2 - __v_4); match __v_7.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_628] = []; record.function_queries[628].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_1, __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_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() { 6u64 => { 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_624] = { let __args: [G; IN_624] = [__v_11, __v_5, __v_22]; 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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = G::from_u64(0); let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_23, __v_6, __v_25]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_26, __v_3, __v_22, __v_25]; 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_27: G = (__v_4 + __v_21); let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_0, __v_1, __v_2, __v_3, __v_27, __v_5, __v_6]; 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 __ret: [G; OUT_628] = []; record.function_queries[628].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_629: usize = 4; +const IN_629: usize = 4; const OUT_629: usize = 0; -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 __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = (__v_3 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_629] = []; record.function_queries[629].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_6, __v_9]; 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 __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() { 6u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_15, __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_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); if (__v_24 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("ctor belongs to a different block than its inductive".to_string()) }); } if (__v_16 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("ctor points at a different member of the block".to_string()) }); } if (__v_17 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("ctor's stored index differs from its position".to_string()) }); } if (__v_18 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("ctor parameter count differs from the inductive's".to_string()) }); } let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0, __v_14, __v_1]; 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 __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_14, __v_18, __v_7]; 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 __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() { 0u64 => { 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_14, __v_18, __v_5, __v_27]; 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)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; 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 __ret: [G; OUT_629] = []; record.function_queries[629].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_630: usize = 12; -const IN_630: usize = 12; +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 __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() { 5u64 => { let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __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_629] = { let __args: [G; IN_629] = [__v_6, __v_1, __v_9, __v_3]; 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 __ret: [G; OUT_629] = []; record.function_queries[629].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_629] = []; record.function_queries[629].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_630: usize = 4; +const IN_630: usize = 4; const OUT_630: usize = 0; -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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; 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 __ret: [G; OUT_630] = []; record.function_queries[630].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_630] = []; record.function_queries[630].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_631: usize = 13; -const IN_631: usize = 13; +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 __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 = { 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_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 __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_1, __v_3]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_8, __v_7, __v_9, __v_5]; 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 __ret: [G; OUT_630] = []; record.function_queries[630].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_631: usize = 8; +const IN_631: usize = 8; const OUT_631: usize = 0; -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 __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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() { 5u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_631] = []; record.function_queries[631].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __v_22: G = __r_arr[8]; let __v_23: G = __r_arr[9]; let __v_24: G = __r_arr[10]; let __v_25: G = __r_arr[11]; let __v_26: G = __r_arr[12]; let __v_27: G = __r_arr[13]; let __v_28: G = __r_arr[14]; let __v_29: G = __r_arr[15]; let __v_30: G = __r_arr[16]; let __v_31: G = __r_arr[17]; let __v_32: G = __r_arr[18]; let __v_33: G = __r_arr[19]; let __v_34: G = __r_arr[20]; let __v_35: G = __r_arr[21]; let __v_36: G = __r_arr[22]; let __v_37: G = __r_arr[23]; let __v_38: G = __r_arr[24]; let __v_39: G = __r_arr[25]; let __v_40: G = __r_arr[26]; let __v_41: G = __r_arr[27]; let __v_42: G = __r_arr[28]; let __v_43: G = __r_arr[29]; let __v_44: G = __r_arr[30]; let __v_45: G = __r_arr[31]; let __v_46: G = __r_arr[32]; let __v_47: G = __r_arr[33]; let __v_48: G = __r_arr[34]; let __v_49: G = __r_arr[35]; let __v_50: G = __r_arr[36]; let __v_51: G = __r_arr[37]; let __v_52: G = __r_arr[38]; let __v_53: G = __r_arr[39]; let __v_54: G = __r_arr[40]; let __v_55: G = __r_arr[41]; let __v_56: G = __r_arr[42]; let __v_57: G = __r_arr[43]; let __v_58: G = __r_arr[44]; let __v_59: G = __r_arr[45]; let __v_60: G = __r_arr[46]; let __v_61: G = __r_arr[47]; match __v_14.as_canonical_u64() { _ => { match __v_14.as_canonical_u64() { 8u64 => { let __v_62: G = G::from_u64(0); let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; 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 __ret: [G; OUT_631] = []; record.function_queries[631].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_631] = []; record.function_queries[631].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __ret: [G; OUT_631] = []; record.function_queries[631].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_632: usize = 7; -const IN_632: usize = 7; +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 __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = (__v_1 + __v_2); 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_615] = { let __args: [G; IN_615] = [__v_0, __v_8, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_7, __v_12]; 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 __ret: [G; OUT_631] = []; record.function_queries[631].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_632: usize = 10; +const IN_632: usize = 10; const OUT_632: usize = 0; -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 __v_2: G = inp[2]; let __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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_632] = []; record.function_queries[632].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 1u64 => { let __v_54: G = (__v_5 - __v_4); let __v_55: G = G::from_bool((__v_54 == G::ZERO)); match __v_55.as_canonical_u64() { 1u64 => { let __v_56: G = G::from_u64(1); let __v_57: G = (__v_5 + __v_56); let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; 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 __ret: [G; OUT_632] = []; record.function_queries[632].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_6, __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_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]; match __v_57.as_canonical_u64() { 5u64 => { if (__v_60 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) }); } let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_1, __v_59, __v_2]; 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_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = { let __values: [G; 3] = [__v_70, __v_70, __v_70]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_612] = { let __args: [G; IN_612] = [__v_1, __v_69, __v_71]; 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_72: G = __r_arr[0]; let __v_73: G = (__v_60 + __v_61); let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_59, __v_73, __v_71]; 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_74: G = __r_arr[0]; let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_72, __v_74]; 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_75: G = __r_arr[0]; if (__v_75 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: Some("mutual block peers land in different universes".to_string()) }); } let __v_76: G = (__v_5 + __v_70); let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_76, __v_6]; 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 __ret: [G; OUT_632] = []; record.function_queries[632].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __v_70: G = (__v_5 + __v_69); let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; 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 __ret: [G; OUT_632] = []; record.function_queries[632].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_5 + __v_54); let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; 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 __ret: [G; OUT_632] = []; record.function_queries[632].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_633: usize = 16; -const IN_633: usize = 16; -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]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_305] = { let __args: [G; IN_305] = [__v_0]; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_633] = [__v_17]; record.function_queries[633].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_633] = [__v_17]; record.function_queries[633].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_633] = [__v_17]; record.function_queries[633].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_633] = [__v_17]; record.function_queries[633].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_3.as_canonical_u64() { 6u64 => { match __v_10.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_633] = [__v_17]; record.function_queries[633].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_5, __v_9, __v_10, __v_18]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_633] = [__v_19]; record.function_queries[633].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_633] = [__v_17]; record.function_queries[633].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_633] = [__v_17]; record.function_queries[633].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_634: usize = 4; -const IN_634: usize = 4; -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]; match __v_1.as_canonical_u64() { 0u64 => { 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_2, __v_4, __v_3, __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_7: G = __r_arr[0]; let __ret: [G; OUT_634] = [__v_7]; 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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __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 __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_6, __v_11, __v_2, __v_9]; 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 __ret: [G; OUT_634] = [__v_12]; record.function_queries[634].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_634] = [__v_8]; record.function_queries[634].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_635: usize = 5; -const IN_635: usize = 5; -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]; 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 __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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_635] = [__v_8]; 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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_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_517] = { let __args: [G; IN_517] = [__v_7, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); 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 __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_10, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = (__v_11 - __v_14); let __v_16: G = (__v_1 - __v_11); let __v_17: G = (__v_16 - __v_2); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_15.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_4]; }, _ => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_17, __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 }, } }; break '__mc_0 [__v_19]; }, } }; let __v_18: G = __mc_out___mc_0[0]; let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_7, __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 = G::from_u64(1); let __v_22: G = (__v_2 + __v_21); let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_1, __v_22, __v_20, __v_18]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_635] = [__v_23]; record.function_queries[635].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_635] = [__v_10]; record.function_queries[635].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_636: usize = 2; -const IN_636: usize = 2; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = 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_9); match __v_10.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_632] = []; record.function_queries[632].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_6, __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_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() { 6u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_15, __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_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); if (__v_24 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("ctor belongs to a different block than its inductive".to_string()) }); } if (__v_16 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("ctor points at a different member of the block".to_string()) }); } if (__v_17 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("ctor's stored index differs from its position".to_string()) }); } if (__v_18 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("ctor parameter count differs from the inductive's".to_string()) }); } let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_0, __v_14, __v_1]; 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 __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(618, (&__args[..]))?) { [G::ZERO; OUT_618] } else { let (__hash, __hit) = record.function_queries[618].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[618].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { (*(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618])) }; __ret }, _ => { aiur_fn_618::(__args, __hash, record, io_buffer)? }, } } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() { 0u64 => { 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_14, __v_18, __v_5, __v_27]; 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)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; 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 __ret: [G; OUT_632] = []; record.function_queries[632].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_633: usize = 12; +const IN_633: usize = 12; +const OUT_633: usize = 0; +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]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; 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 __ret: [G; OUT_633] = []; record.function_queries[633].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_633] = []; record.function_queries[633].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_634: usize = 13; +const IN_634: usize = 13; +const OUT_634: usize = 0; +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]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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() { 5u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_634] = []; record.function_queries[634].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __v_22: G = __r_arr[8]; let __v_23: G = __r_arr[9]; let __v_24: G = __r_arr[10]; let __v_25: G = __r_arr[11]; let __v_26: G = __r_arr[12]; let __v_27: G = __r_arr[13]; let __v_28: G = __r_arr[14]; let __v_29: G = __r_arr[15]; let __v_30: G = __r_arr[16]; let __v_31: G = __r_arr[17]; let __v_32: G = __r_arr[18]; let __v_33: G = __r_arr[19]; let __v_34: G = __r_arr[20]; let __v_35: G = __r_arr[21]; let __v_36: G = __r_arr[22]; let __v_37: G = __r_arr[23]; let __v_38: G = __r_arr[24]; let __v_39: G = __r_arr[25]; let __v_40: G = __r_arr[26]; let __v_41: G = __r_arr[27]; let __v_42: G = __r_arr[28]; let __v_43: G = __r_arr[29]; let __v_44: G = __r_arr[30]; let __v_45: G = __r_arr[31]; let __v_46: G = __r_arr[32]; let __v_47: G = __r_arr[33]; let __v_48: G = __r_arr[34]; let __v_49: G = __r_arr[35]; let __v_50: G = __r_arr[36]; let __v_51: G = __r_arr[37]; let __v_52: G = __r_arr[38]; let __v_53: G = __r_arr[39]; let __v_54: G = __r_arr[40]; let __v_55: G = __r_arr[41]; let __v_56: G = __r_arr[42]; let __v_57: G = __r_arr[43]; let __v_58: G = __r_arr[44]; let __v_59: G = __r_arr[45]; let __v_60: G = __r_arr[46]; let __v_61: G = __r_arr[47]; match __v_14.as_canonical_u64() { _ => { match __v_14.as_canonical_u64() { 8u64 => { let __v_62: G = G::from_u64(0); let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; 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 __ret: [G; OUT_634] = []; record.function_queries[634].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_634] = []; record.function_queries[634].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __ret: [G; OUT_634] = []; record.function_queries[634].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_635: usize = 7; +const IN_635: usize = 7; +const OUT_635: usize = 0; +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]; let __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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_635] = []; record.function_queries[635].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 1u64 => { let __v_54: G = (__v_5 - __v_4); let __v_55: G = G::from_bool((__v_54 == G::ZERO)); match __v_55.as_canonical_u64() { 1u64 => { let __v_56: G = G::from_u64(1); let __v_57: G = (__v_5 + __v_56); let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __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 __ret: [G; OUT_635] = []; record.function_queries[635].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_6, __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_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]; match __v_57.as_canonical_u64() { 5u64 => { if (__v_60 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) }); } let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_59, __v_2]; 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_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = { let __values: [G; 3] = [__v_70, __v_70, __v_70]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_615] = { let __args: [G; IN_615] = [__v_1, __v_69, __v_71]; 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_72: G = __r_arr[0]; let __v_73: G = (__v_60 + __v_61); let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_59, __v_73, __v_71]; 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_74: G = __r_arr[0]; let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_72, __v_74]; 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_75: G = __r_arr[0]; if (__v_75 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: Some("mutual block peers land in different universes".to_string()) }); } let __v_76: G = (__v_5 + __v_70); let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_76, __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 __ret: [G; OUT_635] = []; record.function_queries[635].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __v_70: G = (__v_5 + __v_69); let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __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 __ret: [G; OUT_635] = []; record.function_queries[635].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_5 + __v_54); let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __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 __ret: [G; OUT_635] = []; record.function_queries[635].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +const INPUT_SIZE_636: usize = 16; +const IN_636: usize = 16; 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 __loaded: [G; 3] = { let __base = 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_636] = [__v_5]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_1, __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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_636] = [__v_6]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_4, __v_1]; 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_636] = [__v_6]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_637: usize = 2; -const IN_637: usize = 2; +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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_308] = { let __args: [G; IN_308] = [__v_0]; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_636] = [__v_17]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_636] = [__v_17]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_636] = [__v_17]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_636] = [__v_17]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_3.as_canonical_u64() { 6u64 => { match __v_10.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_636] = [__v_17]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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 __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_5, __v_9, __v_10, __v_18]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_636] = [__v_19]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_636] = [__v_17]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_636] = [__v_17]; record.function_queries[636].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_637: usize = 4; +const IN_637: usize = 4; 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 __loaded: [G; 3] = { let __base = 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_637] = [__v_5]; record.function_queries[637].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_637] = [__v_10]; record.function_queries[637].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_1]; 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); }, } }, _ => { let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_1]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_637] = [__v_9]; record.function_queries[637].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_638: usize = 13; -const IN_638: usize = 13; +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 __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_2, __v_4, __v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(638, (&__args[..]))?) { [G::ZERO; OUT_638] } else { let (__hash, __hit) = record.function_queries[638].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[638].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { (*(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638])) }; __ret }, _ => { aiur_fn_638::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_637] = [__v_7]; record.function_queries[637].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() { 5u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __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 __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_6, __v_11, __v_2, __v_9]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_637] = [__v_12]; record.function_queries[637].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_637] = [__v_8]; record.function_queries[637].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +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]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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() { 5u64 => { let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_7, __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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_638] = [__v_14]; record.function_queries[638].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = (__v_3 + __v_4); 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 __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_2, __v_14, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); 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_332] = { let __args: [G; IN_332] = [__v_17, __v_19]; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_638] = [__v_21]; record.function_queries[638].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_5.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_7, __v_8, __v_21]; 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_22: 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_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: 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_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]; let __v_29: G = __loaded[6]; let __v_30: G = __loaded[7]; let __v_31: G = __loaded[8]; let __v_32: G = __loaded[9]; let __v_33: G = __loaded[10]; let __v_34: G = __loaded[11]; match __v_23.as_canonical_u64() { 6u64 => { let __v_35: G = G::from_bool((__v_30 == G::ZERO)); let __ret: [G; OUT_638] = [__v_35]; record.function_queries[638].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_35: G = G::from_u64(0); let __ret: [G; OUT_638] = [__v_35]; record.function_queries[638].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_638] = [__v_21]; record.function_queries[638].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_638] = [__v_13]; record.function_queries[638].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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]; let __v_5: G = (__v_1 - __v_2); match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_638] = [__v_8]; record.function_queries[638].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_520] = { let __args: [G; IN_520] = [__v_7, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); 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 __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_10, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = (__v_11 - __v_14); let __v_16: G = (__v_1 - __v_11); let __v_17: G = (__v_16 - __v_2); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_15.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_4]; }, _ => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_17, __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 }, } }; break '__mc_0 [__v_19]; }, } }; let __v_18: G = __mc_out___mc_0[0]; let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_7, __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 = G::from_u64(1); let __v_22: G = (__v_2 + __v_21); let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_8, __v_1, __v_22, __v_20, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(638, (&__args[..]))?) { [G::ZERO; OUT_638] } else { let (__hash, __hit) = record.function_queries[638].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[638].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { (*(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638])) }; __ret }, _ => { aiur_fn_638::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_638] = [__v_23]; record.function_queries[638].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_638] = [__v_10]; record.function_queries[638].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_639: usize = 2; const IN_639: usize = 2; 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 __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_639] = [__v_3]; record.function_queries[639].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_641] = { let __args: [G; IN_641] = [__v_4, __v_51]; 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_52: G = __r_arr[0]; let __ret: [G; OUT_639] = [__v_52]; record.function_queries[639].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); let __ret: [G; OUT_639] = [__v_51]; record.function_queries[639].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_640: usize = 1; -const IN_640: 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 __loaded: [G; 3] = { let __base = 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_639] = [__v_5]; record.function_queries[639].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_1, __v_3]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_639] = [__v_6]; record.function_queries[639].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_639] = [__v_6]; record.function_queries[639].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_640] = [__v_49]; record.function_queries[640].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_640] = [__v_49]; record.function_queries[640].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_641: usize = 2; -const IN_641: usize = 2; +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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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_640] = [__v_5]; record.function_queries[640].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_640] = [__v_10]; record.function_queries[640].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_4, __v_1]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_640] = [__v_10]; record.function_queries[640].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_4, __v_1]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_640] = [__v_9]; 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 = 13; +const IN_641: usize = 13; const OUT_641: usize = 1; -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 __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_641] = [__v_49]; record.function_queries[641].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_641] = [__v_49]; record.function_queries[641].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_641] = { let __args: [G; IN_641] = [__v_48, __v_50]; 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_51: G = __r_arr[0]; let __ret: [G; OUT_641] = [__v_51]; record.function_queries[641].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_48, __v_1]; 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_49: G = __r_arr[0]; let __ret: [G; OUT_641] = [__v_49]; record.function_queries[641].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_642: usize = 5; -const IN_642: usize = 5; +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]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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() { 5u64 => { let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_7, __v_12]; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_641] = [__v_14]; record.function_queries[641].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = (__v_3 + __v_4); 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 __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_14, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); 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_335] = { let __args: [G; IN_335] = [__v_17, __v_19]; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_641] = [__v_21]; record.function_queries[641].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_5.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_7, __v_8, __v_21]; 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_22: 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_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: 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_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]; let __v_29: G = __loaded[6]; let __v_30: G = __loaded[7]; let __v_31: G = __loaded[8]; let __v_32: G = __loaded[9]; let __v_33: G = __loaded[10]; let __v_34: G = __loaded[11]; match __v_23.as_canonical_u64() { 6u64 => { let __v_35: G = G::from_bool((__v_30 == G::ZERO)); let __ret: [G; OUT_641] = [__v_35]; record.function_queries[641].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_35: G = G::from_u64(0); let __ret: [G; OUT_641] = [__v_35]; record.function_queries[641].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_641] = [__v_21]; record.function_queries[641].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_641] = [__v_13]; record.function_queries[641].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_642: usize = 2; +const IN_642: usize = 2; 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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = (__v_3 + __v_4); let __v_6: G = (__v_2 + __v_5); let __v_7: G = (__v_1 + __v_6); let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_0, __v_7]; 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_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_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __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_642] = [__v_16]; record.function_queries[642].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_643: usize = 12; -const IN_643: usize = 12; +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 __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_642] = [__v_3]; record.function_queries[642].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_644] = { let __args: [G; IN_644] = [__v_4, __v_51]; 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_52: G = __r_arr[0]; let __ret: [G; OUT_642] = [__v_52]; record.function_queries[642].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); let __ret: [G; OUT_642] = [__v_51]; record.function_queries[642].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_643: usize = 1; +const IN_643: usize = 1; 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]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_605] = { let __args: [G; IN_605] = [__v_2, __v_14]; 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_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_122] = { let __args: [G; IN_122] = [__v_17]; 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_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_643] = [__v_24]; record.function_queries[643].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_643] = [__v_27]; record.function_queries[643].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_643] = [__v_21]; record.function_queries[643].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_643] = [__v_13]; record.function_queries[643].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_644: usize = 6; -const IN_644: usize = 6; +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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_643] = [__v_49]; record.function_queries[643].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_643] = [__v_49]; record.function_queries[643].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_644: usize = 2; +const IN_644: usize = 2; 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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_0, __v_8]; 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_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_122] = { let __args: [G; IN_122] = [__v_11]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_15, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__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_645] = { let __args: [G; IN_645] = [__v_16, __v_18]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_644] = [__v_19]; record.function_queries[644].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } -const INPUT_SIZE_645: usize = 2; -const IN_645: usize = 2; +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 __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_644] = [__v_49]; record.function_queries[644].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_644] = [__v_49]; record.function_queries[644].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_644] = { let __args: [G; IN_644] = [__v_48, __v_50]; 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_51: G = __r_arr[0]; let __ret: [G; OUT_644] = [__v_51]; record.function_queries[644].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_48, __v_1]; 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_49: G = __r_arr[0]; let __ret: [G; OUT_644] = [__v_49]; record.function_queries[644].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_645: usize = 5; +const IN_645: usize = 5; 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 __loaded: [G; 3] = { let __base = 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_645] = [__v_6]; record.function_queries[645].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_5, __v_1]; 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_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_370] = { let __args: [G; IN_370] = [__v_3, __v_1, __v_5]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_1]; 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_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_645] = [__v_9]; record.function_queries[645].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_646: usize = 3; -const IN_646: usize = 3; +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 = (__v_3 + __v_4); let __v_6: G = (__v_2 + __v_5); let __v_7: G = (__v_1 + __v_6); let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_7]; 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_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_125] = { let __args: [G; IN_125] = [__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_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_645] = [__v_16]; record.function_queries[645].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_646: usize = 12; +const IN_646: usize = 12; 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 = (__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_646] = [__v_5]; record.function_queries[646].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_646] = { let __args: [G; IN_646] = [__v_0, __v_1, __v_9]; 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_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_646] = [__v_11]; record.function_queries[646].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_647: usize = 2; -const IN_647: usize = 2; +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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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_608] = { let __args: [G; IN_608] = [__v_2, __v_14]; 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_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_125] = { let __args: [G; IN_125] = [__v_17]; 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_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_646] = [__v_24]; record.function_queries[646].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_646] = [__v_27]; record.function_queries[646].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_646] = [__v_21]; record.function_queries[646].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_646] = [__v_13]; record.function_queries[646].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_647: usize = 6; +const IN_647: usize = 6; 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 __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_648] = { let __args: [G; IN_648] = [__v_3, __v_3, __v_0, __v_1, __v_50]; 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_51: G = __r_arr[0]; let __ret: [G; OUT_647] = [__v_51]; record.function_queries[647].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; 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_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_646] = { let __args: [G; IN_646] = [__v_1, __v_52, __v_63]; 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_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_647] = [__v_68]; record.function_queries[647].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_647] = [__v_64]; record.function_queries[647].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_648: usize = 5; -const IN_648: usize = 5; +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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_8]; 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 __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_125] = { let __args: [G; IN_125] = [__v_11]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_15, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__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_648] = { let __args: [G; IN_648] = [__v_16, __v_18]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_647] = [__v_19]; record.function_queries[647].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } +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 __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_648] = [__v_53]; record.function_queries[648].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_2, __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_52: G = __r_arr[0]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2, __v_4]; 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_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_646] = { let __args: [G; IN_646] = [__v_3, __v_66, __v_67]; 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_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_648] = { let __args: [G; IN_648] = [__v_0, __v_51, __v_2, __v_3, __v_71]; 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_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_648] = [__v_73]; record.function_queries[648].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_648] = { let __args: [G; IN_648] = [__v_0, __v_51, __v_2, __v_3, __v_53]; 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_54: G = __r_arr[0]; let __ret: [G; OUT_648] = [__v_54]; record.function_queries[648].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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_648] = [__v_6]; record.function_queries[648].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __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]; 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_373] = { let __args: [G; IN_373] = [__v_3, __v_1, __v_5]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_4, __v_1]; 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_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_648] = [__v_9]; 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 = 3; const IN_649: usize = 3; 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 __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_649] = [__v_9]; record.function_queries[649].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_652] = { let __args: [G; IN_652] = [__v_6, __v_2]; 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 __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_649] = [__v_11]; record.function_queries[649].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_8, __v_1, __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_11: G = __r_arr[0]; let __ret: [G; OUT_649] = [__v_11]; record.function_queries[649].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_8, __v_1, __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_10: G = __r_arr[0]; let __ret: [G; OUT_649] = [__v_10]; record.function_queries[649].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_8, __v_1, __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_9: G = __r_arr[0]; let __ret: [G; OUT_649] = [__v_9]; record.function_queries[649].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +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 = (__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_649] = [__v_5]; record.function_queries[649].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_649] = { let __args: [G; IN_649] = [__v_0, __v_1, __v_9]; 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_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_649] = [__v_11]; record.function_queries[649].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_650: usize = 2; const IN_650: usize = 2; 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 = (__v_0 - __v_1); match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_650] = [__v_3]; record.function_queries[650].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_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].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_335] = { let __args: [G; IN_335] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].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_651] = { let __args: [G; IN_651] = [__v_5, __v_9]; 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 __v_12: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].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_650] = { let __args: [G; IN_650] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_5, __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_12: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].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_650] = { let __args: [G; IN_650] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_5, __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_12: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].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_650] = { let __args: [G; IN_650] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_5, __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_12: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].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_650] = { let __args: [G; IN_650] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_5, __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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_6, __v_10]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_13]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_13]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].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_348] = { let __args: [G; IN_348] = [__v_4, __v_5, __v_8, __v_9]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].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_650] = { let __args: [G; IN_650] = [__v_6, __v_10]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_13]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_13]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_12]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_650] = [__v_11]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_651: usize = 2; -const IN_651: usize = 2; +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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_651] = { let __args: [G; IN_651] = [__v_3, __v_3, __v_0, __v_1, __v_50]; 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 __v_51: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_51]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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_649] = { let __args: [G; IN_649] = [__v_1, __v_52, __v_63]; 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_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_650] = [__v_68]; record.function_queries[650].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_650] = [__v_64]; record.function_queries[650].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_651: usize = 5; +const IN_651: usize = 5; const OUT_651: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_651] = [__v_8]; record.function_queries[651].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_651] = [__v_8]; record.function_queries[651].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_651] = [__v_8]; record.function_queries[651].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_7]; 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 __v_9: G = __r_arr[0]; let __ret: [G; OUT_651] = [__v_9]; record.function_queries[651].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_651] = [__v_9]; record.function_queries[651].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_652: usize = 2; -const IN_652: usize = 2; +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 __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_651] = [__v_53]; record.function_queries[651].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_2, __v_4]; 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_52: G = __r_arr[0]; let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_2, __v_4]; 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_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_649] = { let __args: [G; IN_649] = [__v_3, __v_66, __v_67]; 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_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_651] = { let __args: [G; IN_651] = [__v_0, __v_51, __v_2, __v_3, __v_71]; 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 __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_651] = [__v_73]; record.function_queries[651].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_651] = { let __args: [G; IN_651] = [__v_0, __v_51, __v_2, __v_3, __v_53]; 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 __v_54: G = __r_arr[0]; let __ret: [G; OUT_651] = [__v_54]; record.function_queries[651].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +const INPUT_SIZE_652: usize = 3; +const IN_652: usize = 3; const OUT_652: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_652] = [__v_8]; record.function_queries[652].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_652] = [__v_8]; record.function_queries[652].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_652] = [__v_8]; record.function_queries[652].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_4, __v_7]; 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 __v_9: G = __r_arr[0]; let __ret: [G; OUT_652] = [__v_9]; record.function_queries[652].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_652] = [__v_9]; record.function_queries[652].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_653: usize = 13; -const IN_653: usize = 13; +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 __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_652] = [__v_9]; record.function_queries[652].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_655] = { let __args: [G; IN_655] = [__v_6, __v_2]; 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 __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_652] = [__v_11]; record.function_queries[652].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_8, __v_1, __v_2]; 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 __v_11: G = __r_arr[0]; let __ret: [G; OUT_652] = [__v_11]; record.function_queries[652].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_8, __v_1, __v_2]; 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 __v_10: G = __r_arr[0]; let __ret: [G; OUT_652] = [__v_10]; record.function_queries[652].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_8, __v_1, __v_2]; 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 __v_9: G = __r_arr[0]; let __ret: [G; OUT_652] = [__v_9]; record.function_queries[652].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_653: usize = 2; +const IN_653: usize = 2; 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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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_644] = { let __args: [G; IN_644] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_13]; record.function_queries[653].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_653] = [__v_14]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 = (__v_0 - __v_1); match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_653] = [__v_3]; record.function_queries[653].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_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].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_338] = { let __args: [G; IN_338] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].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_654] = { let __args: [G; IN_654] = [__v_5, __v_9]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].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_653] = { let __args: [G; IN_653] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_5, __v_9]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].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_653] = { let __args: [G; IN_653] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_5, __v_9]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].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_653] = { let __args: [G; IN_653] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_5, __v_9]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].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_653] = { let __args: [G; IN_653] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_5, __v_9]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_6, __v_10]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_13]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_13]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].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_351] = { let __args: [G; IN_351] = [__v_4, __v_5, __v_8, __v_9]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].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_653] = { let __args: [G; IN_653] = [__v_6, __v_10]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_13]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_13]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_12]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_11]; record.function_queries[653].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_654: usize = 2; const IN_654: usize = 2; 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 __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_655] = { let __args: [G; IN_655] = [__v_3, __v_3, __v_0, __v_50, __v_1]; 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 __v_51: G = __r_arr[0]; let __ret: [G; OUT_654] = [__v_51]; record.function_queries[654].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_654] = [__v_1]; record.function_queries[654].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_655: usize = 5; -const IN_655: usize = 5; +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 __loaded: [G; 3] = { let __base = 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_654] = [__v_8]; record.function_queries[654].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_654] = [__v_8]; record.function_queries[654].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_654] = [__v_8]; record.function_queries[654].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3, __v_6]; 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]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_654] = [__v_9]; record.function_queries[654].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_654] = [__v_9]; record.function_queries[654].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_655: usize = 2; +const IN_655: usize = 2; const OUT_655: usize = 1; -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 __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_655] = [__v_4]; record.function_queries[655].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_2, __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_52: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_52]; 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_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_642] = { let __args: [G; IN_642] = [__v_56, __v_57, __v_59, __v_60, __v_58]; 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_66: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_66]; 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_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_655] = [__v_75]; record.function_queries[655].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_655] = [__v_4]; record.function_queries[655].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_655] = [__v_4]; record.function_queries[655].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_655] = { let __args: [G; IN_655] = [__v_0, __v_51, __v_2, __v_53, __v_4]; 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 __v_54: G = __r_arr[0]; let __ret: [G; OUT_655] = [__v_54]; record.function_queries[655].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_656: usize = 3; -const IN_656: usize = 3; +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 __loaded: [G; 3] = { let __base = 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_655] = [__v_8]; record.function_queries[655].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_655] = [__v_8]; record.function_queries[655].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_655] = [__v_8]; record.function_queries[655].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_4, __v_7]; 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 __v_9: G = __r_arr[0]; let __ret: [G; OUT_655] = [__v_9]; record.function_queries[655].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_655] = [__v_9]; record.function_queries[655].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_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 __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_655] = { let __args: [G; IN_655] = [__v_4, __v_4, __v_0, __v_51, __v_1]; 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 __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_290] = { let __args: [G; IN_290] = [__v_51]; 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_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_648] = { let __args: [G; IN_648] = [__v_53, __v_53, __v_51, __v_2, __v_100]; 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_101: G = __r_arr[0]; break '__mc_1 [__v_101]; }, _ => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_51]; 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_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_646] = { let __args: [G; IN_646] = [__v_2, __v_102, __v_113]; 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_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_640] = { let __args: [G; IN_640] = [__v_0]; 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_101: G = __r_arr[0]; match __v_101.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_656] = [__v_100]; record.function_queries[656].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_51, __v_2, __v_100]; 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_102: G = __r_arr[0]; let __ret: [G; OUT_656] = [__v_102]; record.function_queries[656].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_657: usize = 4; -const IN_657: usize = 4; +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]; match __v_0.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_656] = [__v_13]; record.function_queries[656].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_656] = [__v_14]; record.function_queries[656].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_657: usize = 2; +const IN_657: usize = 2; 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 __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_658] = { let __args: [G; IN_658] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; 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_53: G = __r_arr[0]; let __ret: [G; OUT_657] = [__v_53]; record.function_queries[657].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_657] = [__v_3]; record.function_queries[657].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_658: usize = 7; -const IN_658: usize = 7; +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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_658] = { let __args: [G; IN_658] = [__v_3, __v_3, __v_0, __v_50, __v_1]; 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_51: G = __r_arr[0]; let __ret: [G; OUT_657] = [__v_51]; record.function_queries[657].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_657] = [__v_1]; record.function_queries[657].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_658: usize = 5; +const IN_658: usize = 5; 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 __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_658] = [__v_5]; record.function_queries[658].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_2, __v_6]; 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_54: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_54]; 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_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_642] = { let __args: [G; IN_642] = [__v_58, __v_59, __v_61, __v_62, __v_60]; 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_68: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_68]; 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_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_658] = { let __args: [G; IN_658] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; 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_75: G = __r_arr[0]; let __ret: [G; OUT_658] = [__v_75]; record.function_queries[658].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__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(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_73: G = __r_arr[0]; let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__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(643, (&__args[..]))?) { [G::ZERO; OUT_643] } else { let (__hash, __hit) = record.function_queries[643].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[643].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { (*(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643])) }; __ret }, _ => { aiur_fn_643::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_5, __v_69, __v_73]; 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_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_658] = { let __args: [G; IN_658] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; 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_78: G = __r_arr[0]; let __ret: [G; OUT_658] = [__v_78]; record.function_queries[658].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(796, (&__args[..]))?) { [G::ZERO; OUT_796] } else { let (__hash, __hit) = record.function_queries[796].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[796].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[796].bump_multiplicity(__i); } let __ret: [G; OUT_796] = unsafe { (*(record.function_queries[796].output_at(__i).as_ptr() as *const [G; OUT_796])) }; __ret }, _ => { aiur_fn_796::(__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_658] = { let __args: [G; IN_658] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_78]; 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_79: G = __r_arr[0]; let __ret: [G; OUT_658] = [__v_79]; record.function_queries[658].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_658] = { let __args: [G; IN_658] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; 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_56: G = __r_arr[0]; let __ret: [G; OUT_658] = [__v_56]; record.function_queries[658].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +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 __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_658] = [__v_4]; record.function_queries[658].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_2, __v_3]; 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_52: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_52]; 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_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_645] = { let __args: [G; IN_645] = [__v_56, __v_57, __v_59, __v_60, __v_58]; 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_66: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_66]; 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_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_658] = [__v_75]; record.function_queries[658].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_658] = [__v_4]; record.function_queries[658].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_658] = [__v_4]; record.function_queries[658].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_658] = { let __args: [G; IN_658] = [__v_0, __v_51, __v_2, __v_53, __v_4]; 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_54: G = __r_arr[0]; let __ret: [G; OUT_658] = [__v_54]; record.function_queries[658].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } const INPUT_SIZE_659: usize = 3; const IN_659: usize = 3; -const OUT_659: usize = 2; -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 __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_659] = [__v_9, __v_9]; record.function_queries[659].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_659] = [__v_10, __v_2]; record.function_queries[659].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_659] = { let __args: [G; IN_659] = [__v_8, __v_1, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_659] = [__v_12, __v_13]; record.function_queries[659].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_660: usize = 5; -const IN_660: usize = 5; -const OUT_660: usize = 2; -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 __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_660] = [__v_11, __v_11]; record.function_queries[660].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_652] = { let __args: [G; IN_652] = [__v_8, __v_3]; 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 __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_660] = [__v_17, __v_4]; record.function_queries[660].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_660] = { let __args: [G; IN_660] = [__v_10, __v_1, __v_2, __v_3, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_660] = [__v_19, __v_20]; record.function_queries[660].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_661: usize = 2; -const IN_661: usize = 2; -const OUT_661: usize = 4; -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 __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_661] = [__v_9, __v_8, __v_11, __v_11]; record.function_queries[661].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_661] = [__v_3, __v_4, __v_5, __v_6]; record.function_queries[661].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_661] = { let __args: [G; IN_661] = [__v_7, __v_9]; 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_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_661] = [__v_10, __v_11, __v_12, __v_13]; record.function_queries[661].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_662: usize = 4; -const IN_662: usize = 4; -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 __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_662] = [__v_8]; record.function_queries[662].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_789] = { let __args: [G; IN_789] = [__v_3, __v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_662] = [__v_6]; record.function_queries[662].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_662] = [__v_10]; record.function_queries[662].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_663: usize = 6; -const IN_663: usize = 6; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_663] = [__v_0]; record.function_queries[663].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_662] = { let __args: [G; IN_662] = [__v_5, __v_2, __v_3, __v_4]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_663] = { let __args: [G; IN_663] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_663] = [__v_16]; record.function_queries[663].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }) } +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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_658] = { let __args: [G; IN_658] = [__v_4, __v_4, __v_0, __v_51, __v_1]; 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_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_293] = { let __args: [G; IN_293] = [__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_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_651] = { let __args: [G; IN_651] = [__v_53, __v_53, __v_51, __v_2, __v_100]; 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 __v_101: G = __r_arr[0]; break '__mc_1 [__v_101]; }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_51]; 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_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_649] = { let __args: [G; IN_649] = [__v_2, __v_102, __v_113]; 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_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_643] = { let __args: [G; IN_643] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(643, (&__args[..]))?) { [G::ZERO; OUT_643] } else { let (__hash, __hit) = record.function_queries[643].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[643].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { (*(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643])) }; __ret }, _ => { aiur_fn_643::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; match __v_101.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_659] = [__v_100]; record.function_queries[659].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_51, __v_2, __v_100]; 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_102: G = __r_arr[0]; let __ret: [G; OUT_659] = [__v_102]; record.function_queries[659].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_660: usize = 4; +const IN_660: usize = 4; +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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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]; 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_661] = { let __args: [G; IN_661] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; 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_53: G = __r_arr[0]; let __ret: [G; OUT_660] = [__v_53]; record.function_queries[660].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_660] = [__v_3]; record.function_queries[660].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_661: usize = 7; +const IN_661: usize = 7; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __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_661] = [__v_5]; record.function_queries[661].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_2, __v_6]; 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_54: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_54]; 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_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_645] = { let __args: [G; IN_645] = [__v_58, __v_59, __v_61, __v_62, __v_60]; 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_68: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_68]; 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_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_661] = { let __args: [G; IN_661] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; 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_75: G = __r_arr[0]; let __ret: [G; OUT_661] = [__v_75]; record.function_queries[661].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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(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_73: G = __r_arr[0]; let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__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(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_74: G = __r_arr[0]; let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_5, __v_69, __v_73]; 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 __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_661] = { let __args: [G; IN_661] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; 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_78: G = __r_arr[0]; let __ret: [G; OUT_661] = [__v_78]; record.function_queries[661].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(799, (&__args[..]))?) { [G::ZERO; OUT_799] } else { let (__hash, __hit) = record.function_queries[799].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[799].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[799].bump_multiplicity(__i); } let __ret: [G; OUT_799] = unsafe { (*(record.function_queries[799].output_at(__i).as_ptr() as *const [G; OUT_799])) }; __ret }, _ => { aiur_fn_799::(__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_661] = { let __args: [G; IN_661] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_78]; 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_79: G = __r_arr[0]; let __ret: [G; OUT_661] = [__v_79]; record.function_queries[661].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_661] = { let __args: [G; IN_661] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; 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_56: G = __r_arr[0]; let __ret: [G; OUT_661] = [__v_56]; record.function_queries[661].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +const INPUT_SIZE_662: usize = 3; +const IN_662: usize = 3; +const OUT_662: usize = 2; +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 __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_662] = [__v_9, __v_9]; record.function_queries[662].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_662] = [__v_10, __v_2]; record.function_queries[662].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_662] = { let __args: [G; IN_662] = [__v_8, __v_1, __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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_662] = [__v_12, __v_13]; record.function_queries[662].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_663: usize = 5; +const IN_663: usize = 5; +const OUT_663: usize = 2; +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 __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_663] = [__v_11, __v_11]; record.function_queries[663].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_655] = { let __args: [G; IN_655] = [__v_8, __v_3]; 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 __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_663] = [__v_17, __v_4]; record.function_queries[663].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_663] = { let __args: [G; IN_663] = [__v_10, __v_1, __v_2, __v_3, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_663] = [__v_19, __v_20]; record.function_queries[663].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } const INPUT_SIZE_664: usize = 2; const IN_664: usize = 2; -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]; 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_664] = [__v_3]; record.function_queries[664].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(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_4, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_664] = [__v_10]; record.function_queries[664].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_425] = { let __args: [G; IN_425] = [__v_0, __v_7]; 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_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 __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_11, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_13, __v_10, __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_664] = [__v_17]; record.function_queries[664].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_664] = [__v_14]; record.function_queries[664].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const OUT_664: usize = 4; +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 __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_664] = [__v_9, __v_8, __v_11, __v_11]; record.function_queries[664].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_664] = [__v_3, __v_4, __v_5, __v_6]; record.function_queries[664].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_664] = { let __args: [G; IN_664] = [__v_7, __v_9]; 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_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_664] = [__v_10, __v_11, __v_12, __v_13]; record.function_queries[664].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_665: usize = 4; const IN_665: usize = 4; 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 = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_665] = [__v_0]; record.function_queries[665].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_665] = { let __args: [G; IN_665] = [__v_12, __v_1, __v_2, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_665] = [__v_14]; record.function_queries[665].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_666: usize = 3; -const IN_666: usize = 3; +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]; 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_665] = [__v_8]; record.function_queries[665].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_792] = { let __args: [G; IN_792] = [__v_3, __v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_665] = [__v_6]; record.function_queries[665].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_665] = [__v_10]; record.function_queries[665].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_666: usize = 6; +const IN_666: usize = 6; 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 __loaded: [G; 3] = { let __base = 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_666] = [__v_0]; record.function_queries[666].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_666] = { let __args: [G; IN_666] = [__v_9, __v_5, __v_2]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_666] = [__v_10]; record.function_queries[666].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_667: usize = 5; -const IN_667: usize = 5; +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]; let __v_5: G = inp[5]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_666] = [__v_0]; record.function_queries[666].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_665] = { let __args: [G; IN_665] = [__v_5, __v_2, __v_3, __v_4]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_8, __v_10, __v_11]; 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_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_666] = { let __args: [G; IN_666] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_666] = [__v_16]; record.function_queries[666].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }) } +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 __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_665] = { let __args: [G; IN_665] = [__v_0, __v_1, __v_2, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_667] = [__v_6]; record.function_queries[667].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_4, __v_2]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_667] = [__v_5]; record.function_queries[667].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_668: usize = 3; -const IN_668: usize = 3; +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]; 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_667] = [__v_3]; record.function_queries[667].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(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_4, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_667] = [__v_10]; record.function_queries[667].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_428] = { let __args: [G; IN_428] = [__v_0, __v_7]; 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_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 __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_11, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_13, __v_10, __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_667] = [__v_17]; record.function_queries[667].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_667] = [__v_14]; record.function_queries[667].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_668: usize = 4; +const IN_668: usize = 4; 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 = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_668] = [__v_0]; record.function_queries[668].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_668] = { let __args: [G; IN_668] = [__v_10, __v_1, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_668] = [__v_12]; record.function_queries[668].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_669: usize = 2; -const IN_669: usize = 2; +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 = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_668] = [__v_0]; record.function_queries[668].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_668] = { let __args: [G; IN_668] = [__v_12, __v_1, __v_2, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_668] = [__v_14]; record.function_queries[668].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_669: usize = 3; +const IN_669: usize = 3; 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 __loaded: [G; 3] = { let __base = 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_669] = [__v_0]; record.function_queries[669].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_4]; 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_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_669] = [__v_8]; record.function_queries[669].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_670: usize = 2; -const IN_670: usize = 2; -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 = 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_670] = [__v_3, __v_0]; record.function_queries[670].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_670] = { let __args: [G; IN_670] = [__v_4, __v_7]; 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_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_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_670] = [__v_11, __v_9]; record.function_queries[670].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_425] = { let __args: [G; IN_425] = [__v_0, __v_7]; 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_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 __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_11, __v_14]; 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_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; 3] = [__v_17, __v_10, __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_670] = [__v_18, __v_16]; record.function_queries[670].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_670] = [__v_14, __v_0]; record.function_queries[670].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +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 __loaded: [G; 3] = { let __base = 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_669] = [__v_0]; record.function_queries[669].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_2, __v_6]; 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_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_669] = { let __args: [G; IN_669] = [__v_9, __v_5, __v_2]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_669] = [__v_10]; record.function_queries[669].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_670: usize = 5; +const IN_670: usize = 5; +const OUT_670: usize = 1; +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 = 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_668] = { let __args: [G; IN_668] = [__v_0, __v_1, __v_2, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_670] = [__v_6]; record.function_queries[670].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_4, __v_2]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_670] = [__v_5]; record.function_queries[670].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_671: usize = 3; const IN_671: usize = 3; const OUT_671: usize = 1; -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 __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_671] = [__v_7]; record.function_queries[671].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_671] = { let __args: [G; IN_671] = [__v_5, __v_1, __v_9]; 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_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_671] = [__v_11]; record.function_queries[671].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_672: usize = 6; -const IN_672: usize = 6; +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 __v_2: G = inp[2]; let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_671] = [__v_0]; record.function_queries[671].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_671] = { let __args: [G; IN_671] = [__v_10, __v_1, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_671] = [__v_12]; record.function_queries[671].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_672: usize = 2; +const IN_672: usize = 2; 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]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_5, __v_3]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_672] = [__v_6]; record.function_queries[672].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_0, __v_1, __v_2, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_672] = [__v_7]; record.function_queries[672].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -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 __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_673] = [__v_0]; record.function_queries[673].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_673] = { let __args: [G; IN_673] = [__v_8, __v_1, __v_10]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_673] = [__v_11]; record.function_queries[673].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_674: usize = 9; -const IN_674: usize = 9; +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 __loaded: [G; 3] = { let __base = 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_672] = [__v_0]; record.function_queries[672].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0, __v_4]; 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_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_672] = [__v_8]; record.function_queries[672].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_673: usize = 2; +const IN_673: usize = 2; +const OUT_673: usize = 2; +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]; 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_673] = [__v_3, __v_0]; record.function_queries[673].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_673] = { let __args: [G; IN_673] = [__v_4, __v_7]; 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 = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __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_673] = [__v_11, __v_9]; record.function_queries[673].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_428] = { let __args: [G; IN_428] = [__v_0, __v_7]; 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_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 __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_11, __v_14]; 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_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; 3] = [__v_17, __v_10, __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_673] = [__v_18, __v_16]; record.function_queries[673].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_673] = [__v_14, __v_0]; record.function_queries[673].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +const INPUT_SIZE_674: usize = 3; +const IN_674: usize = 3; 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 = inp[4]; let __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_344] = { let __args: [G; IN_344] = [__v_1, __v_4]; 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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_11, __v_3]; 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_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_14, __v_6, __v_3, __v_15]; 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_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, _ => { let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_14, __v_8, __v_3]; 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_15: G = __r_arr[0]; break '__mc_0 [__v_15]; }, } }; let __v_15: G = __mc_out___mc_0[0]; let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_15, __v_3, __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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 4] = [__v_18, __v_5, __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 __v_20: G = G::from_u64(5); let __v_21: G = { let __values: [G; 4] = [__v_20, __v_17, __v_19, __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_669] = { let __args: [G; IN_669] = [__v_21, __v_12]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_674] = [__v_22]; record.function_queries[674].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_675: usize = 3; -const IN_675: usize = 3; +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 __loaded: [G; 3] = { let __base = 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_674] = [__v_7]; record.function_queries[674].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; 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_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_674] = { let __args: [G; IN_674] = [__v_5, __v_1, __v_9]; 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_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_674] = [__v_11]; record.function_queries[674].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +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 = G::from_u64(0); let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_0, __v_1, __v_2, __v_3]; 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 __v_4: G = __r_arr[0]; let __ret: [G; OUT_675] = [__v_4]; 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; +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() { 1u64 => { let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_5, __v_3]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_675] = [__v_6]; record.function_queries[675].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_0, __v_1, __v_2, __v_6]; 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_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 = 3; +const IN_676: usize = 3; const OUT_676: usize = 1; -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 __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_676] = [__v_0]; record.function_queries[676].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_676] = { let __args: [G; IN_676] = [__v_9, __v_1, __v_2, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_676] = [__v_12]; record.function_queries[676].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_677: usize = 2; -const IN_677: 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 = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_676] = [__v_0]; record.function_queries[676].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_676] = { let __args: [G; IN_676] = [__v_8, __v_1, __v_10]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_676] = [__v_11]; record.function_queries[676].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_677: usize = 9; +const IN_677: usize = 9; const OUT_677: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_677] = [__v_0]; record.function_queries[677].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0, __v_4]; 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_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_677] = [__v_8]; record.function_queries[677].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_678: usize = 9; -const IN_678: usize = 9; +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 = inp[4]; let __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_347] = { let __args: [G; IN_347] = [__v_1, __v_4]; 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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_11, __v_3]; 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_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_14, __v_6, __v_3, __v_15]; 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_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, _ => { let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_14, __v_8, __v_3]; 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_15: G = __r_arr[0]; break '__mc_0 [__v_15]; }, } }; let __v_15: G = __mc_out___mc_0[0]; let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_15, __v_3, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 4] = [__v_18, __v_5, __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 __v_20: G = G::from_u64(5); let __v_21: G = { let __values: [G; 4] = [__v_20, __v_17, __v_19, __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_672] = { let __args: [G; IN_672] = [__v_21, __v_12]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_677] = [__v_22]; record.function_queries[677].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_678: usize = 3; +const IN_678: usize = 3; const OUT_678: usize = 1; -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 __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_6, __v_9]; 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_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_295] = { let __args: [G; IN_295] = [__v_10]; 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_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() { 5u64 => { let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_17, __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(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_27: G = __r_arr[0]; let __ret: [G; OUT_678] = [__v_27]; record.function_queries[678].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_0, __v_1, __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(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_27: G = __r_arr[0]; let __ret: [G; OUT_678] = [__v_27]; record.function_queries[678].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_679: usize = 11; -const IN_679: usize = 11; +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 = G::from_u64(0); let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_1, __v_2, __v_3]; 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 __v_4: G = __r_arr[0]; let __ret: [G; OUT_678] = [__v_4]; record.function_queries[678].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_679: usize = 4; +const IN_679: usize = 4; 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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __r_arr: [G; OUT_802] = { let __args: [G; IN_802] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(802, (&__args[..]))?) { [G::ZERO; OUT_802] } else { let (__hash, __hit) = record.function_queries[802].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[802].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[802].bump_multiplicity(__i); } let __ret: [G; OUT_802] = unsafe { (*(record.function_queries[802].output_at(__i).as_ptr() as *const [G; OUT_802])) }; __ret }, _ => { aiur_fn_802::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_7, __v_1, __v_12]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_14, __v_4]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_8, __v_6, __v_4]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_8, __v_9, __v_4, __v_11, __v_4]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_8, __v_10]; 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_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 __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_20]; 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_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]; match __v_25.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_27, __v_23]; 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_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; 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_39: G = __r_arr[0]; let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_39, __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_40: G = __r_arr[0]; let __v_41: G = (__v_11 + __v_19); let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_40, __v_41, __v_38]; 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_42: G = __r_arr[0]; let __v_43: G = G::from_u64(2); let __v_44: G = { let __values: [G; 4] = [__v_43, __v_20, __v_23, __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 __v_45: G = (__v_4 + __v_11); let __v_46: G = (__v_45 + __v_19); let __v_47: G = (__v_46 + __v_5); let __v_48: G = G::from_u64(1); let __v_49: G = (__v_47 - __v_48); let __v_50: G = (__v_41 + __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_21.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_44, __v_22, __v_50]; 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_51: G = __r_arr[0]; break '__mc_0 [__v_51]; }, _ => { let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_44, __v_4, __v_49, __v_51]; 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_52: G = __r_arr[0]; break '__mc_0 [__v_52]; }, } }; let __v_51: G = __mc_out___mc_0[0]; let __v_52: G = G::from_u64(0); let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_51, __v_5, __v_52]; 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_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); let __v_55: G = (__v_47 + __v_54); let __v_56: G = (__v_55 - __v_54); let __v_57: G = (__v_4 + __v_10); let __v_58: G = (__v_56 - __v_57); let __v_59: G = { let __values: [G; 4] = [__v_52, __v_58, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_673] = { let __args: [G; IN_673] = [__v_59, __v_5, __v_52]; 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_60: G = __r_arr[0]; let __v_61: G = G::from_u64(3); let __v_62: G = { let __values: [G; 4] = [__v_52, __v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_61, __v_60, __v_62, __v_52]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(5); let __v_65: G = { let __values: [G; 4] = [__v_64, __v_53, __v_63, __v_52]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_669] = { let __args: [G; IN_669] = [__v_65, __v_42]; 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_66: G = __r_arr[0]; let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_66, __v_18]; 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_67: G = __r_arr[0]; let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_67, __v_17]; 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_68: G = __r_arr[0]; let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_68, __v_15]; 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_69: G = __r_arr[0]; let __ret: [G; OUT_679] = [__v_69]; record.function_queries[679].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } -const INPUT_SIZE_680: usize = 26; -const IN_680: usize = 26; -const OUT_680: usize = 0; -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 __v_8: G = inp[8]; let __v_9: G = inp[9]; 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]; match __v_0.as_canonical_u64() { 7u64 => { match __v_13.as_canonical_u64() { 5u64 => { let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(0); let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_20, __v_21, __v_26]; 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_27: 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_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: 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_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 = G::from_u64(1); break '__mc_0 [__v_40, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: 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 __v_29: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __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 }, } }; break '__mc_0 [__v_26, __v_26, __v_26, __v_29, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; }, } }; let __v_26: G = __mc_out___mc_0[0]; let __v_27: G = __mc_out___mc_0[1]; let __v_28: G = __mc_out___mc_0[2]; let __v_29: G = __mc_out___mc_0[3]; let __v_30: G = __mc_out___mc_0[4]; let __v_31: G = __mc_out___mc_0[5]; let __v_32: G = __mc_out___mc_0[6]; let __v_33: G = __mc_out___mc_0[7]; let __v_34: G = __mc_out___mc_0[8]; let __v_35: G = __mc_out___mc_0[9]; let __v_36: G = __mc_out___mc_0[10]; let __v_37: G = __mc_out___mc_0[11]; let __v_38: G = __mc_out___mc_0[12]; let __v_39: G = (__v_16 + __v_17); let __v_40: G = G::from_u64(1); let __v_41: G = { let __values: [G; 3] = [__v_40, __v_40, __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 __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_15, __v_39, __v_41]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_20, __v_25]; 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_43: G = __r_arr[0]; let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_42, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; 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_44: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(4); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 3] = [__v_45, __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_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 3] = [__v_45, __v_45, __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 }, } }; break '__mc_1 [__v_46]; }, } }; let __v_45: G = __mc_out___mc_1[0]; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_46]; 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 __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_10, __v_20, __v_44]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_48, __v_10, __v_12]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_48]; 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 __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_10]; 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_51: G = __r_arr[0]; let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_20]; 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_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_20]; 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_54: G = __r_arr[0]; let __v_55: G = (__v_53 - __v_54); let __v_56: G = (__v_52 * __v_55); let __v_57: G = (__v_51 * __v_56); let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_57.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; 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_58: G = __r_arr[0]; break '__mc_2 [__v_58]; }, _ => { let __v_58: G = G::from_u64(1); let __v_59: G = { let __values: [G; 3] = [__v_58, __v_58, __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 }, } }; break '__mc_2 [__v_59]; }, } }; let __v_58: G = __mc_out___mc_2[0]; let __v_59: G = G::from_u64(0); let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_48, __v_25, __v_57, __v_58, __v_59]; 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_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; match __v_60.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_48, __v_61, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; 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 __ret: [G; OUT_680] = []; record.function_queries[680].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_62: G = G::from_u64(0); let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_48, __v_25, __v_62]; 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_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; match __v_63.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_48, __v_64, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; 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 __ret: [G; OUT_680] = []; record.function_queries[680].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64())); }, } }, } }, _ => { let __ret: [G; OUT_680] = []; record.function_queries[680].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_681: usize = 18; -const IN_681: usize = 18; -const OUT_681: usize = 0; -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 __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_1]; 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_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 __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; 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_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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_12, __v_22, __v_24]; 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_25: G = __r_arr[0]; if (__v_25 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) }); } let __r_arr: [G; OUT_802] = { let __args: [G; IN_802] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(802, (&__args[..]))?) { [G::ZERO; OUT_802] } else { let (__hash, __hit) = record.function_queries[802].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[802].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[802].bump_multiplicity(__i); } let __ret: [G; OUT_802] = unsafe { (*(record.function_queries[802].output_at(__i).as_ptr() as *const [G; OUT_802])) }; __ret }, _ => { aiur_fn_802::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0, __v_10, __v_5, __v_26, __v_5]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; if (__v_6 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("recursor motive count disagrees with the canonical reconstruction".to_string()) }); } if (__v_7 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("recursor minor count disagrees with the canonical reconstruction".to_string()) }); } let __v_29: G = G::from_u64(0); let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_0, __v_1, __v_29]; 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 __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_2, __v_30, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_29]; 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)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_11, __v_31, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_29]; 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 __ret: [G; OUT_681] = []; record.function_queries[681].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_682: usize = 3; -const IN_682: usize = 3; +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 __v_3: G = inp[3]; let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_679] = [__v_0]; record.function_queries[679].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_679] = { let __args: [G; IN_679] = [__v_9, __v_1, __v_2, __v_11]; 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); }, } }) } +const INPUT_SIZE_680: usize = 2; +const IN_680: usize = 2; +const OUT_680: usize = 1; +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 __loaded: [G; 3] = { let __base = 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_680] = [__v_0]; record.function_queries[680].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_0, __v_4]; 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_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_680] = [__v_8]; record.function_queries[680].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_681: usize = 9; +const IN_681: usize = 9; +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 __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_6, __v_9]; 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_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_298] = { let __args: [G; IN_298] = [__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_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() { 5u64 => { let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_17, __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(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 __v_27: G = __r_arr[0]; let __ret: [G; OUT_681] = [__v_27]; record.function_queries[681].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_0, __v_1, __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(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 __v_27: G = __r_arr[0]; let __ret: [G; OUT_681] = [__v_27]; record.function_queries[681].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_682: usize = 11; +const IN_682: usize = 11; const OUT_682: usize = 1; -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 = (__v_2 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_682] = [__v_4]; record.function_queries[682].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_682] = [__v_10]; record.function_queries[682].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_5]; 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_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_682] = { let __args: [G; IN_682] = [__v_9, __v_1, __v_25]; 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 __v_26: G = __r_arr[0]; let __v_27: G = (__v_23 + __v_26); let __ret: [G; OUT_682] = [__v_27]; record.function_queries[682].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_683: usize = 15; -const IN_683: usize = 15; -const OUT_683: usize = 1; -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 = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 = (__v_0 - __v_14); match __v_15.as_canonical_u64() { 0u64 => { 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_683] = [__v_17]; record.function_queries[683].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_2, __v_3, __v_14]; 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_16: 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_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: 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_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; let __v_25: G = __loaded[8]; let __v_26: G = __loaded[9]; let __v_27: G = __loaded[10]; let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { let __v_29: G = (__v_1 + __v_14); let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_14 + __v_32); let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; 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)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_683] = [__v_35]; record.function_queries[683].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_683] = [__v_30]; record.function_queries[683].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_684: usize = 9; -const IN_684: usize = 9; +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 __r_arr: [G; OUT_805] = { let __args: [G; IN_805] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(805, (&__args[..]))?) { [G::ZERO; OUT_805] } else { let (__hash, __hit) = record.function_queries[805].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[805].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[805].bump_multiplicity(__i); } let __ret: [G; OUT_805] = unsafe { (*(record.function_queries[805].output_at(__i).as_ptr() as *const [G; OUT_805])) }; __ret }, _ => { aiur_fn_805::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_7, __v_1, __v_12]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_14, __v_4]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_8, __v_6, __v_4]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_8, __v_9, __v_4, __v_11, __v_4]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_8, __v_10]; 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_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 __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_20]; 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_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]; match __v_25.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_27, __v_23]; 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_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; 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_39: G = __r_arr[0]; let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_39, __v_5]; 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_40: G = __r_arr[0]; let __v_41: G = (__v_11 + __v_19); let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_40, __v_41, __v_38]; 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(2); let __v_44: G = { let __values: [G; 4] = [__v_43, __v_20, __v_23, __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 __v_45: G = (__v_4 + __v_11); let __v_46: G = (__v_45 + __v_19); let __v_47: G = (__v_46 + __v_5); let __v_48: G = G::from_u64(1); let __v_49: G = (__v_47 - __v_48); let __v_50: G = (__v_41 + __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_21.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_44, __v_22, __v_50]; 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_51: G = __r_arr[0]; break '__mc_0 [__v_51]; }, _ => { let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_44, __v_4, __v_49, __v_51]; 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_52: G = __r_arr[0]; break '__mc_0 [__v_52]; }, } }; let __v_51: G = __mc_out___mc_0[0]; let __v_52: G = G::from_u64(0); let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_51, __v_5, __v_52]; 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_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); let __v_55: G = (__v_47 + __v_54); let __v_56: G = (__v_55 - __v_54); let __v_57: G = (__v_4 + __v_10); let __v_58: G = (__v_56 - __v_57); let __v_59: G = { let __values: [G; 4] = [__v_52, __v_58, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_676] = { let __args: [G; IN_676] = [__v_59, __v_5, __v_52]; 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_60: G = __r_arr[0]; let __v_61: G = G::from_u64(3); let __v_62: G = { let __values: [G; 4] = [__v_52, __v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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_61, __v_60, __v_62, __v_52]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 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(5); let __v_65: G = { let __values: [G; 4] = [__v_64, __v_53, __v_63, __v_52]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __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_65, __v_42]; 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_66: G = __r_arr[0]; let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_66, __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_67: G = __r_arr[0]; let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_67, __v_17]; 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_68: G = __r_arr[0]; let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_68, __v_15]; 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_69: G = __r_arr[0]; let __ret: [G; OUT_682] = [__v_69]; record.function_queries[682].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } +const INPUT_SIZE_683: usize = 26; +const IN_683: usize = 26; +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 = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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]; match __v_0.as_canonical_u64() { 7u64 => { match __v_13.as_canonical_u64() { 5u64 => { let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(0); let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_20, __v_21, __v_26]; 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_27: 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_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: 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_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 = G::from_u64(1); break '__mc_0 [__v_40, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: 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 __v_29: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __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 }, } }; break '__mc_0 [__v_26, __v_26, __v_26, __v_29, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; }, } }; let __v_26: G = __mc_out___mc_0[0]; let __v_27: G = __mc_out___mc_0[1]; let __v_28: G = __mc_out___mc_0[2]; let __v_29: G = __mc_out___mc_0[3]; let __v_30: G = __mc_out___mc_0[4]; let __v_31: G = __mc_out___mc_0[5]; let __v_32: G = __mc_out___mc_0[6]; let __v_33: G = __mc_out___mc_0[7]; let __v_34: G = __mc_out___mc_0[8]; let __v_35: G = __mc_out___mc_0[9]; let __v_36: G = __mc_out___mc_0[10]; let __v_37: G = __mc_out___mc_0[11]; let __v_38: G = __mc_out___mc_0[12]; let __v_39: G = (__v_16 + __v_17); let __v_40: G = G::from_u64(1); let __v_41: G = { let __values: [G; 3] = [__v_40, __v_40, __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 __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_15, __v_39, __v_41]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_20, __v_25]; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_42, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; 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_44: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(4); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 3] = [__v_45, __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_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 3] = [__v_45, __v_45, __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 }, } }; break '__mc_1 [__v_46]; }, } }; let __v_45: G = __mc_out___mc_1[0]; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_1, __v_46]; 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 __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10, __v_20, __v_44]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_48, __v_10, __v_12]; 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 __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_48]; 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_643] = { let __args: [G; IN_643] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(643, (&__args[..]))?) { [G::ZERO; OUT_643] } else { let (__hash, __hit) = record.function_queries[643].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[643].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { (*(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643])) }; __ret }, _ => { aiur_fn_643::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(643, (&__args[..]))?) { [G::ZERO; OUT_643] } else { let (__hash, __hit) = record.function_queries[643].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[643].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { (*(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643])) }; __ret }, _ => { aiur_fn_643::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_20]; 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_54: G = __r_arr[0]; let __v_55: G = (__v_53 - __v_54); let __v_56: G = (__v_52 * __v_55); let __v_57: G = (__v_51 * __v_56); let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_57.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __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_58: G = __r_arr[0]; break '__mc_2 [__v_58]; }, _ => { let __v_58: G = G::from_u64(1); let __v_59: G = { let __values: [G; 3] = [__v_58, __v_58, __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 }, } }; break '__mc_2 [__v_59]; }, } }; let __v_58: G = __mc_out___mc_2[0]; let __v_59: G = G::from_u64(0); let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_48, __v_25, __v_57, __v_58, __v_59]; 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_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; match __v_60.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_48, __v_61, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; 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 __ret: [G; OUT_683] = []; record.function_queries[683].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_62: G = G::from_u64(0); let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_48, __v_25, __v_62]; 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_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; match __v_63.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_48, __v_64, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; 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 __ret: [G; OUT_683] = []; record.function_queries[683].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64())); }, } }, } }, _ => { let __ret: [G; OUT_683] = []; record.function_queries[683].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_684: usize = 18; +const IN_684: usize = 18; const OUT_684: usize = 0; -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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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; 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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_684] = []; record.function_queries[684].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_10.as_canonical_u64() { _ => { if (__v_10 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("recursor rule is out of ctor order".to_string()) }); } let __v_14: G = { let __a_val = __v_10.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 }; 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("recursor rule names a ctor index out of range".to_string()) }); } let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_6, __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_16: 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_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: 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_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; let __v_25: G = __loaded[8]; let __v_26: G = __loaded[9]; let __v_27: G = __loaded[10]; let __v_28: G = __loaded[11]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_17.as_canonical_u64() { 6u64 => { if (__v_11 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("recursor rule field count differs from the ctor's".to_string()) }); } break '__mc_0 []; }, _ => { return Err(ExecError::MatchNoCase(__v_17.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_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; match __v_29.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_684] = []; record.function_queries[684].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_32: G = (__v_2 + __v_3); let __v_33: G = (__v_32 + __v_4); let __v_34: G = (__v_33 + __v_11); let __v_35: G = G::from_u64(0); 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_715] = { let __args: [G; IN_715] = [__v_12, __v_34, __v_35, __v_37]; 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 __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; if (__v_39 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("recursor rule rhs has too few binders to peel".to_string()) }); } let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_38, __v_30, __v_37]; 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_41: G = __r_arr[0]; if (__v_41 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("recursor rule rhs differs from canonical reconstruction".to_string()) }); } let __v_42: G = (__v_8 + __v_36); let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_42]; 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 __ret: [G; OUT_684] = []; record.function_queries[684].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_685: usize = 12; -const IN_685: usize = 12; +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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_0, __v_1]; 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_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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; 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_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 __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_12, __v_22, __v_24]; 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_25: G = __r_arr[0]; if (__v_25 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) }); } let __r_arr: [G; OUT_805] = { let __args: [G; IN_805] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(805, (&__args[..]))?) { [G::ZERO; OUT_805] } else { let (__hash, __hit) = record.function_queries[805].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[805].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[805].bump_multiplicity(__i); } let __ret: [G; OUT_805] = unsafe { (*(record.function_queries[805].output_at(__i).as_ptr() as *const [G; OUT_805])) }; __ret }, _ => { aiur_fn_805::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_0, __v_10, __v_5, __v_26, __v_5]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; if (__v_6 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("recursor motive count disagrees with the canonical reconstruction".to_string()) }); } if (__v_7 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("recursor minor count disagrees with the canonical reconstruction".to_string()) }); } let __v_29: G = G::from_u64(0); let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_0, __v_1, __v_29]; 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 __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_2, __v_30, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_29]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_11, __v_31, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_29]; 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 __ret: [G; OUT_684] = []; 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 = 1; -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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __loaded: [G; 3] = { let __base = 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_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_685] = [__v_0]; record.function_queries[685].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_2, __v_11, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 32] = [__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]; 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_779] = { let __args: [G; IN_779] = [__v_4, __v_16, __v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_5, __v_16, __v_15]; 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_19: G = __r_arr[0]; let __v_20: G = (__v_6 + __v_7); let __v_21: G = (__v_20 + __v_8); let __v_22: G = (__v_21 + __v_9); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_3, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_9 - __v_13); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_23, __v_24, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = (__v_7 + __v_8); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_25, __v_26, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_27]; 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 __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = (__v_22 + __v_30); let __v_32: G = G::from_u64(2); let __v_33: G = { let __values: [G; 4] = [__v_32, __v_18, __v_10, __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 __v_34: G = G::from_u64(1); let __v_35: G = (__v_31 - __v_34); let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_33, __v_6, __v_35, __v_15]; 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_36: G = __r_arr[0]; let __v_37: G = (__v_35 - __v_6); let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_36, __v_7, __v_37, __v_15]; 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_38: G = __r_arr[0]; let __v_39: G = (__v_37 - __v_7); let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_38, __v_8, __v_39, __v_15]; 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_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 3] = [__v_34, __v_34, __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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_29, __v_41]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_42]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_44, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_40, __v_45]; 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_46: G = __r_arr[0]; let __v_47: G = (__v_9 - __v_34); let __v_48: G = (__v_47 - __v_13); let __v_49: G = (__v_48 + __v_30); let __v_50: G = { let __values: [G; 4] = [__v_15, __v_49, __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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_50, __v_30, __v_15]; 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_51: G = __r_arr[0]; let __v_52: G = G::from_u64(3); let __v_53: G = { let __values: [G; 4] = [__v_52, __v_46, __v_51, __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 __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_53, __v_28]; 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_54: G = __r_arr[0]; let __v_55: G = { let __values: [G; 4] = [__v_52, __v_0, __v_54, __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 __v_56: G = (__v_11 + __v_34); let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_55, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_56]; 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 __v_57: G = __r_arr[0]; let __ret: [G; OUT_685] = [__v_57]; record.function_queries[685].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }) } -const INPUT_SIZE_686: usize = 13; -const IN_686: usize = 13; +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 __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_685] = [__v_4]; record.function_queries[685].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_685] = [__v_10]; record.function_queries[685].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__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_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_685] = { let __args: [G; IN_685] = [__v_9, __v_1, __v_25]; 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 __v_26: G = __r_arr[0]; let __v_27: G = (__v_23 + __v_26); let __ret: [G; OUT_685] = [__v_27]; record.function_queries[685].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_686: usize = 15; +const IN_686: usize = 15; const OUT_686: usize = 1; -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]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0, __v_6]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_13, __v_5]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); let __v_19: G = (__v_18 + __v_16); let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_13, __v_5, __v_5, __v_15, __v_11, __v_12, __v_15]; 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 __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_709] = { let __args: [G; IN_709] = [__v_20, __v_8, __v_22, __v_22, __v_22, __v_15, __v_15]; 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 __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 = (__v_19 - __v_21); let __v_28: G = (__v_17 + __v_1); let __v_29: G = (__v_27 - __v_28); let __v_30: G = { let __values: [G; 4] = [__v_15, __v_29, __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 __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_30, __v_16, __v_16, __v_15]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_31, __v_24, __v_25, __v_23, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_15]; 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 __v_32: G = __r_arr[0]; let __ret: [G; OUT_686] = [__v_32]; record.function_queries[686].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_687: usize = 3; -const IN_687: usize = 3; -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 __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_687] = [__v_10]; record.function_queries[687].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_1, __v_4, __v_6, __v_5, __v_2]; 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 __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_8, __v_1, __v_2]; 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_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_687] = [__v_12]; record.function_queries[687].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_688: usize = 5; -const IN_688: usize = 5; +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]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 = (__v_0 - __v_14); match __v_15.as_canonical_u64() { 0u64 => { 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_686] = [__v_17]; record.function_queries[686].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_2, __v_3, __v_14]; 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 __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_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: 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_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; let __v_25: G = __loaded[8]; let __v_26: G = __loaded[9]; let __v_27: G = __loaded[10]; let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { let __v_29: G = (__v_1 + __v_14); let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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 __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_14 + __v_32); let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_686] = [__v_35]; record.function_queries[686].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_686] = [__v_30]; record.function_queries[686].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_687: usize = 9; +const IN_687: usize = 9; +const OUT_687: usize = 0; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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; 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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_687] = []; record.function_queries[687].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_10.as_canonical_u64() { _ => { if (__v_10 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("recursor rule is out of ctor order".to_string()) }); } let __v_14: G = { let __a_val = __v_10.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 }; 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("recursor rule names a ctor index out of range".to_string()) }); } let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_6, __v_10]; 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 __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_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: 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_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; let __v_25: G = __loaded[8]; let __v_26: G = __loaded[9]; let __v_27: G = __loaded[10]; let __v_28: G = __loaded[11]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_17.as_canonical_u64() { 6u64 => { if (__v_11 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("recursor rule field count differs from the ctor's".to_string()) }); } break '__mc_0 []; }, _ => { return Err(ExecError::MatchNoCase(__v_17.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_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; match __v_29.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_687] = []; record.function_queries[687].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_32: G = (__v_2 + __v_3); let __v_33: G = (__v_32 + __v_4); let __v_34: G = (__v_33 + __v_11); let __v_35: G = G::from_u64(0); 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_718] = { let __args: [G; IN_718] = [__v_12, __v_34, __v_35, __v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; if (__v_39 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("recursor rule rhs has too few binders to peel".to_string()) }); } let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_38, __v_30, __v_37]; 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_41: G = __r_arr[0]; if (__v_41 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("recursor rule rhs differs from canonical reconstruction".to_string()) }); } let __v_42: G = (__v_8 + __v_36); let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_42]; 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 __ret: [G; OUT_687] = []; record.function_queries[687].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +const INPUT_SIZE_688: usize = 12; +const IN_688: usize = 12; const OUT_688: usize = 1; -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 __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_290] = { let __args: [G; IN_290] = [__v_0]; 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 __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_689] = { let __args: [G; IN_689] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; 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 __v_54: G = __r_arr[0]; let __ret: [G; OUT_688] = [__v_54]; record.function_queries[688].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_688] = [__v_4]; record.function_queries[688].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_689: usize = 8; -const IN_689: usize = 8; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __loaded: [G; 3] = { let __base = 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_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_688] = [__v_0]; record.function_queries[688].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_11, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 32] = [__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]; 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_782] = { let __args: [G; IN_782] = [__v_4, __v_16, __v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_5, __v_16, __v_15]; 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_19: G = __r_arr[0]; let __v_20: G = (__v_6 + __v_7); let __v_21: G = (__v_20 + __v_8); let __v_22: G = (__v_21 + __v_9); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_3, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_9 - __v_13); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_23, __v_24, __v_15]; 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_25: G = __r_arr[0]; let __v_26: G = (__v_7 + __v_8); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_25, __v_26, __v_9]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = (__v_22 + __v_30); let __v_32: G = G::from_u64(2); let __v_33: G = { let __values: [G; 4] = [__v_32, __v_18, __v_10, __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 __v_34: G = G::from_u64(1); let __v_35: G = (__v_31 - __v_34); let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_33, __v_6, __v_35, __v_15]; 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_36: G = __r_arr[0]; let __v_37: G = (__v_35 - __v_6); let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_36, __v_7, __v_37, __v_15]; 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_38: G = __r_arr[0]; let __v_39: G = (__v_37 - __v_7); let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_38, __v_8, __v_39, __v_15]; 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_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 3] = [__v_34, __v_34, __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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_29, __v_41]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_42]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_44, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_40, __v_45]; 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_46: G = __r_arr[0]; let __v_47: G = (__v_9 - __v_34); let __v_48: G = (__v_47 - __v_13); let __v_49: G = (__v_48 + __v_30); let __v_50: G = { let __values: [G; 4] = [__v_15, __v_49, __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 __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_50, __v_30, __v_15]; 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_51: G = __r_arr[0]; let __v_52: G = G::from_u64(3); let __v_53: G = { let __values: [G; 4] = [__v_52, __v_46, __v_51, __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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_53, __v_28]; 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_54: G = __r_arr[0]; let __v_55: G = { let __values: [G; 4] = [__v_52, __v_0, __v_54, __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 __v_56: G = (__v_11 + __v_34); let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_55, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_56]; 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 __v_57: G = __r_arr[0]; let __ret: [G; OUT_688] = [__v_57]; record.function_queries[688].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }) } +const INPUT_SIZE_689: usize = 13; +const IN_689: usize = 13; const OUT_689: usize = 1; -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 __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_689] = [__v_6]; record.function_queries[689].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_2, __v_7]; 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_55: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_55]; 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_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_642] = { let __args: [G; IN_642] = [__v_59, __v_60, __v_62, __v_63, __v_61]; 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_69: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_69]; 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_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_644] = { let __args: [G; IN_644] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; 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_85: G = __r_arr[0]; let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_85, __v_4]; 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 __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_689] = [__v_55]; record.function_queries[689].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_689] = { let __args: [G; IN_689] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; 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 __v_72: G = __r_arr[0]; let __ret: [G; OUT_689] = [__v_72]; record.function_queries[689].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_689] = { let __args: [G; IN_689] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; 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 __v_57: G = __r_arr[0]; let __ret: [G; OUT_689] = [__v_57]; record.function_queries[689].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_690: usize = 1; -const IN_690: usize = 1; +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 __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_6]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_13, __v_5]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_14, __v_15]; 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 __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); let __v_19: G = (__v_18 + __v_16); let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_13, __v_5, __v_5, __v_15, __v_11, __v_12, __v_15]; 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 __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 __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_20, __v_8, __v_22, __v_22, __v_22, __v_15, __v_15]; 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 __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 = (__v_19 - __v_21); let __v_28: G = (__v_17 + __v_1); let __v_29: G = (__v_27 - __v_28); let __v_30: G = { let __values: [G; 4] = [__v_15, __v_29, __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 __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_30, __v_16, __v_16, __v_15]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_31, __v_24, __v_25, __v_23, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_15]; 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 __v_32: G = __r_arr[0]; let __ret: [G; OUT_689] = [__v_32]; record.function_queries[689].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_690: usize = 3; +const IN_690: usize = 3; const OUT_690: usize = 1; -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 __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_690] = [__v_8]; record.function_queries[690].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__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 __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_690] = { let __args: [G; IN_690] = [__v_6]; 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 __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_690] = [__v_23]; record.function_queries[690].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_691: usize = 3; -const IN_691: usize = 3; +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 __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_690] = [__v_10]; record.function_queries[690].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_1, __v_4, __v_6, __v_5, __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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_8, __v_1, __v_2]; 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 __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_690] = [__v_12]; record.function_queries[690].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_691: usize = 5; +const IN_691: usize = 5; 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 __v_1: G = inp[1]; let __v_2: G = inp[2]; 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_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_301] = { let __args: [G; IN_301] = [__v_1]; 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 __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_78] = { let __args: [G; IN_78] = [__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(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 __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_23]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_691] = [__v_24]; record.function_queries[691].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_692: usize = 15; -const IN_692: usize = 15; +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 __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]; 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]; 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_692] = { let __args: [G; IN_692] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; 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_54: G = __r_arr[0]; let __ret: [G; OUT_691] = [__v_54]; record.function_queries[691].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_691] = [__v_4]; record.function_queries[691].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_692: usize = 8; +const IN_692: usize = 8; 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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 = (__v_12 - __v_14); match __v_15.as_canonical_u64() { 0u64 => { 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_692] = [__v_17]; record.function_queries[692].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_10, __v_11, __v_14]; 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_16: 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_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: 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_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; let __v_25: G = __loaded[8]; let __v_26: G = __loaded[9]; let __v_27: G = __loaded[10]; let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_11, __v_14, __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_29: G = __r_arr[0]; let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; 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 __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_13 + __v_32); let __v_34: G = (__v_14 + __v_32); let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_34]; 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_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 3] = [__v_31, __v_30, __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_692] = [__v_36]; record.function_queries[692].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_693: usize = 5; -const IN_693: usize = 5; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_692] = [__v_6]; record.function_queries[692].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_2, __v_7]; 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_55: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_55]; 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_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_645] = { let __args: [G; IN_645] = [__v_59, __v_60, __v_62, __v_63, __v_61]; 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_69: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_69]; 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_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_647] = { let __args: [G; IN_647] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; 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_85: G = __r_arr[0]; let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_85, __v_4]; 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 __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_692] = [__v_55]; record.function_queries[692].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_692] = { let __args: [G; IN_692] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; 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_72: G = __r_arr[0]; let __ret: [G; OUT_692] = [__v_72]; record.function_queries[692].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_692] = { let __args: [G; IN_692] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; 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_57: G = __r_arr[0]; let __ret: [G; OUT_692] = [__v_57]; record.function_queries[692].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.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 __v_1: G = 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_694] = { let __args: [G; IN_694] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_693] = [__v_6]; record.function_queries[693].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_694: usize = 8; -const IN_694: usize = 8; +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; 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_693] = [__v_8]; record.function_queries[693].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_2]; 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_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_693] = { let __args: [G; IN_693] = [__v_6]; 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_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_693] = [__v_23]; 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 = 3; +const IN_694: usize = 3; 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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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; 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_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 __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_694] = [__v_15]; record.function_queries[694].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_9]; 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_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() { 5u64 => { let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_6 + __v_29); let __v_31: G = G::from_u64(1); let __v_32: G = (__v_7 + __v_31); let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; 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_33: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_28, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_694] = [__v_34]; record.function_queries[694].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_7 + __v_27); let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_694] = [__v_29]; record.function_queries[694].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_695: usize = 5; -const IN_695: usize = 5; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0]; 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_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_304] = { let __args: [G; IN_304] = [__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_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_79] = { let __args: [G; IN_79] = [__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(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_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_694] = [__v_24]; record.function_queries[694].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_695: usize = 15; +const IN_695: usize = 15; 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 __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_695] = [__v_9]; record.function_queries[695].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_789] = { let __args: [G; IN_789] = [__v_4, __v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_366] = { let __args: [G; IN_366] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_695] = [__v_9]; record.function_queries[695].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_695] = [__v_11]; record.function_queries[695].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_696: usize = 2; -const IN_696: usize = 2; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 = (__v_12 - __v_14); match __v_15.as_canonical_u64() { 0u64 => { 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_695] = [__v_17]; record.function_queries[695].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_10, __v_11, __v_14]; 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 __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_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: 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_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; let __v_25: G = __loaded[8]; let __v_26: G = __loaded[9]; let __v_27: G = __loaded[10]; let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_11, __v_14, __v_10]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; 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_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_13 + __v_32); let __v_34: G = (__v_14 + __v_32); let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_34]; 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_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 3] = [__v_31, __v_30, __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_695] = [__v_36]; record.function_queries[695].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_696: usize = 5; +const IN_696: usize = 5; 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 __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_696] = { let __args: [G; IN_696] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_696] = [__v_8]; record.function_queries[696].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_696] = [__v_1]; record.function_queries[696].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_697: usize = 7; -const IN_697: usize = 7; +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 = G::from_u64(0); let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5]; 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_696] = [__v_6]; record.function_queries[696].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_697: usize = 8; +const IN_697: usize = 8; 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_697] = [__v_0]; record.function_queries[697].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_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_695] = { let __args: [G; IN_695] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__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_1 - __v_14); let __v_16: G = (__v_6 + __v_14); let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_16]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_697] = [__v_17]; record.function_queries[697].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_12]; 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_13: 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_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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_16, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(375, (&__args[..]))?) { [G::ZERO; OUT_375] } else { let (__hash, __hit) = record.function_queries[375].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[375].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { (*(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375])) }; __ret }, _ => { aiur_fn_375::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = (__v_1 - __v_21); let __v_23: G = (__v_6 + __v_21); let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_20, __v_22, __v_2, __v_3, __v_4, __v_5, __v_23]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_697] = [__v_24]; record.function_queries[697].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, } }, } }) } -const INPUT_SIZE_698: usize = 13; -const IN_698: usize = 13; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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; 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_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 __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_697] = [__v_15]; record.function_queries[697].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_9]; 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_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() { 5u64 => { let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_6 + __v_29); let __v_31: G = G::from_u64(1); let __v_32: G = (__v_7 + __v_31); let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; 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_33: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_28, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_697] = [__v_34]; record.function_queries[697].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_7 + __v_27); let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_697] = [__v_29]; record.function_queries[697].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +const INPUT_SIZE_698: usize = 5; +const IN_698: usize = 5; const OUT_698: usize = 1; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_1, __v_5]; 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_13: G = __r_arr[0]; let __v_14: G = (__v_9 + __v_10); let __v_15: G = (__v_8 + __v_14); let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_13, __v_2, __v_15, __v_14, __v_3, __v_4, __v_16]; 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_17: G = __r_arr[0]; 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_709] = { let __args: [G; IN_709] = [__v_17, __v_6, __v_19, __v_19, __v_19, __v_16, __v_14]; 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 __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 __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = (__v_24 + __v_25); let __v_27: G = (__v_15 + __v_26); let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_23]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_29, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_30, __v_25, __v_16]; 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_31: G = __r_arr[0]; let __v_32: G = (__v_27 - __v_18); let __v_33: G = (__v_11 + __v_12); let __v_34: G = (__v_32 - __v_33); let __v_35: G = { let __values: [G; 4] = [__v_16, __v_34, __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_263] = { let __args: [G; IN_263] = [__v_35, __v_31]; 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_36: G = __r_arr[0]; let __v_37: G = G::from_u64(2); let __v_38: G = { let __values: [G; 4] = [__v_37, __v_0, __v_5, __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_704] = { let __args: [G; IN_704] = [__v_38, __v_2, __v_8, __v_27, __v_3, __v_4]; 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_39: G = __r_arr[0]; let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_39, __v_24, __v_26, __v_16]; 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_40: G = __r_arr[0]; let __v_41: G = G::from_u64(3); let __v_42: G = { let __values: [G; 4] = [__v_41, __v_36, __v_40, __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_701] = { let __args: [G; IN_701] = [__v_21, __v_22, __v_20, __v_7, __v_11, __v_24, __v_15, __v_16]; 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_43: G = __r_arr[0]; let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_42, __v_43]; 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_44: G = __r_arr[0]; let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_44, __v_20]; 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_45: G = __r_arr[0]; let __ret: [G; OUT_698] = [__v_45]; record.function_queries[698].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_699: usize = 1; -const IN_699: usize = 1; -const OUT_699: usize = 2; -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 = 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_700] = { let __args: [G; IN_700] = [__v_0, __v_2]; 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 __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(785, (&__args[..]))?) { [G::ZERO; OUT_785] } else { let (__hash, __hit) = record.function_queries[785].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[785].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { (*(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785])) }; __ret }, _ => { aiur_fn_785::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_699] = [__v_5, __v_4]; record.function_queries[699].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_700: usize = 2; -const IN_700: usize = 2; -const OUT_700: usize = 2; -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 __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_700] = { let __args: [G; IN_700] = [__v_4, __v_7]; 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 __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_700] = [__v_8, __v_9]; record.function_queries[700].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_700] = [__v_1, __v_0]; record.function_queries[700].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_701: usize = 8; -const IN_701: usize = 8; +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 __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_698] = [__v_9]; record.function_queries[698].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_792] = { let __args: [G; IN_792] = [__v_4, __v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_369] = { let __args: [G; IN_369] = [__v_7, __v_2, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_698] = [__v_9]; record.function_queries[698].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_698] = [__v_11]; record.function_queries[698].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_699: usize = 2; +const IN_699: usize = 2; +const OUT_699: usize = 1; +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 __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_699] = { let __args: [G; IN_699] = [__v_4, __v_7]; 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 __v_8: G = __r_arr[0]; let __ret: [G; OUT_699] = [__v_8]; record.function_queries[699].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_699] = [__v_1]; record.function_queries[699].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_700: usize = 7; +const IN_700: usize = 7; +const OUT_700: usize = 1; +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 __v_5: G = inp[5]; let __v_6: G = inp[6]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_700] = [__v_0]; record.function_queries[700].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_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_698] = { let __args: [G; IN_698] = [__v_6, __v_2, __v_3, __v_4, __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)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_9, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); let __v_16: G = (__v_6 + __v_14); let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_16]; 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 __v_17: G = __r_arr[0]; let __ret: [G; OUT_700] = [__v_17]; record.function_queries[700].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_12]; 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_13: 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_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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_6, __v_2, __v_3, __v_4, __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)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_16, __v_18, __v_19]; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = (__v_1 - __v_21); let __v_23: G = (__v_6 + __v_21); let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_20, __v_22, __v_2, __v_3, __v_4, __v_5, __v_23]; 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 __v_24: G = __r_arr[0]; let __ret: [G; OUT_700] = [__v_24]; record.function_queries[700].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, } }, } }) } +const INPUT_SIZE_701: usize = 13; +const IN_701: usize = 13; const OUT_701: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __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_701] = [__v_12]; record.function_queries[701].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_1, __v_7, __v_11]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_3, __v_12, __v_11]; 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_13: G = __r_arr[0]; let __v_14: G = (__v_5 + __v_7); let __v_15: G = (__v_6 + __v_14); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_5 - __v_9); let __v_18: G = (__v_17 + __v_7); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_16, __v_18, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_19]; 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 __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_15 + __v_22); let __v_24: G = G::from_u64(1); let __v_25: G = (__v_23 - __v_24); let __v_26: G = (__v_4 + __v_12); let __v_27: G = (__v_25 - __v_26); let __v_28: G = (__v_6 + __v_9); let __v_29: G = (__v_25 - __v_28); let __v_30: 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_425] = { let __args: [G; IN_425] = [__v_21, __v_30]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_33, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_11, __v_27, __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_263] = { let __args: [G; IN_263] = [__v_35, __v_34]; 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_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_11, __v_29, __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_668] = { let __args: [G; IN_668] = [__v_37, __v_22, __v_11]; 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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(3); let __v_40: G = { let __values: [G; 4] = [__v_39, __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 __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_40, __v_20]; 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_41: G = __r_arr[0]; let __v_42: G = (__v_7 + __v_24); let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_42]; 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_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 3] = [__v_11, __v_41, __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 __ret: [G; OUT_701] = [__v_44]; record.function_queries[701].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_702: usize = 3; -const IN_702: usize = 3; -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 = 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_702] = [__v_7]; record.function_queries[702].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_5, __v_1, __v_2]; 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_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_702] = [__v_9]; record.function_queries[702].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_703: usize = 4; -const IN_703: usize = 4; -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 = 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_703] = [__v_0]; record.function_queries[703].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_703] = { let __args: [G; IN_703] = [__v_11, __v_1, __v_2, __v_12]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_703] = [__v_13]; record.function_queries[703].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_704: usize = 6; -const IN_704: usize = 6; +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 __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_5]; 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_13: G = __r_arr[0]; let __v_14: G = (__v_9 + __v_10); let __v_15: G = (__v_8 + __v_14); let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_13, __v_2, __v_15, __v_14, __v_3, __v_4, __v_16]; 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 __v_17: G = __r_arr[0]; 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_712] = { let __args: [G; IN_712] = [__v_17, __v_6, __v_19, __v_19, __v_19, __v_16, __v_14]; 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 __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 __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = (__v_24 + __v_25); let __v_27: G = (__v_15 + __v_26); let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_23]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_29, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_30, __v_25, __v_16]; 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_31: G = __r_arr[0]; let __v_32: G = (__v_27 - __v_18); let __v_33: G = (__v_11 + __v_12); let __v_34: G = (__v_32 - __v_33); let __v_35: G = { let __values: [G; 4] = [__v_16, __v_34, __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_266] = { let __args: [G; IN_266] = [__v_35, __v_31]; 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_36: G = __r_arr[0]; let __v_37: G = G::from_u64(2); let __v_38: G = { let __values: [G; 4] = [__v_37, __v_0, __v_5, __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_707] = { let __args: [G; IN_707] = [__v_38, __v_2, __v_8, __v_27, __v_3, __v_4]; 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_39: G = __r_arr[0]; let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_39, __v_24, __v_26, __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_40: G = __r_arr[0]; let __v_41: G = G::from_u64(3); let __v_42: G = { let __values: [G; 4] = [__v_41, __v_36, __v_40, __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_704] = { let __args: [G; IN_704] = [__v_21, __v_22, __v_20, __v_7, __v_11, __v_24, __v_15, __v_16]; 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_43: G = __r_arr[0]; let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_42, __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 __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_44, __v_20]; 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 __ret: [G; OUT_701] = [__v_45]; 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 = 2; +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_703] = { let __args: [G; IN_703] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(788, (&__args[..]))?) { [G::ZERO; OUT_788] } else { let (__hash, __hit) = record.function_queries[788].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[788].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { (*(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788])) }; __ret }, _ => { aiur_fn_788::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_702] = [__v_5, __v_4]; 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 = 2; +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 __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_703] = { let __args: [G; IN_703] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_703] = [__v_8, __v_9]; record.function_queries[703].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_703] = [__v_1, __v_0]; record.function_queries[703].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_704: usize = 8; +const IN_704: usize = 8; const OUT_704: usize = 1; -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 __v_1: G = inp[1]; 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_676] = { let __args: [G; IN_676] = [__v_0, __v_2, __v_7, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_704] = [__v_9]; record.function_queries[704].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = (__v_3 - __v_2); let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __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_7: G = __r_arr[0]; let __ret: [G; OUT_704] = [__v_7]; record.function_queries[704].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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 __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_704] = [__v_12]; record.function_queries[704].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_7, __v_11]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_12, __v_11]; 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_13: G = __r_arr[0]; let __v_14: G = (__v_5 + __v_7); let __v_15: G = (__v_6 + __v_14); let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_5 - __v_9); let __v_18: G = (__v_17 + __v_7); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_16, __v_18, __v_11]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_19]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_15 + __v_22); let __v_24: G = G::from_u64(1); let __v_25: G = (__v_23 - __v_24); let __v_26: G = (__v_4 + __v_12); let __v_27: G = (__v_25 - __v_26); let __v_28: G = (__v_6 + __v_9); let __v_29: G = (__v_25 - __v_28); let __v_30: 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_428] = { let __args: [G; IN_428] = [__v_21, __v_30]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_33, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_11, __v_27, __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_266] = { let __args: [G; IN_266] = [__v_35, __v_34]; 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_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_11, __v_29, __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_671] = { let __args: [G; IN_671] = [__v_37, __v_22, __v_11]; 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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(3); let __v_40: G = { let __values: [G; 4] = [__v_39, __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 __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_40, __v_20]; 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_41: G = __r_arr[0]; let __v_42: G = (__v_7 + __v_24); let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_42]; 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_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 3] = [__v_11, __v_41, __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 __ret: [G; OUT_704] = [__v_44]; record.function_queries[704].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } const INPUT_SIZE_705: usize = 3; const IN_705: usize = 3; -const OUT_705: usize = 2; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_705] = [__v_3, __v_4]; record.function_queries[705].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_706: usize = 3; -const IN_706: usize = 3; -const OUT_706: usize = 2; -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 = 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_425] = { let __args: [G; IN_425] = [__v_0, __v_4]; 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 __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() { 5u64 => { let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_8, __v_1, __v_2]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_706] = [__v_10, __v_11]; record.function_queries[706].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_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(0); let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_1, __v_13, __v_11, __v_2, __v_16]; 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 = __r_arr[1]; let __ret: [G; OUT_706] = [__v_17, __v_18]; record.function_queries[706].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_706] = [__v_16, __v_16]; record.function_queries[706].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_707: usize = 5; -const IN_707: usize = 5; -const OUT_707: usize = 2; -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 __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_707] = [__v_11, __v_11]; record.function_queries[707].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_708] = { let __args: [G; IN_708] = [__v_8, __v_2, __v_3]; 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 __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_707] = [__v_14, __v_4]; record.function_queries[707].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_707] = { let __args: [G; IN_707] = [__v_10, __v_1, __v_2, __v_3, __v_15]; 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 = __r_arr[1]; let __ret: [G; OUT_707] = [__v_16, __v_17]; record.function_queries[707].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +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 __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_705] = [__v_7]; record.function_queries[705].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_5, __v_1, __v_2]; 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_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_705] = [__v_9]; record.function_queries[705].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_706: usize = 4; +const IN_706: usize = 4; +const OUT_706: usize = 1; +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 = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_706] = [__v_0]; record.function_queries[706].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_706] = { let __args: [G; IN_706] = [__v_11, __v_1, __v_2, __v_12]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_706] = [__v_13]; record.function_queries[706].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_707: usize = 6; +const IN_707: usize = 6; +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]; 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_679] = { let __args: [G; IN_679] = [__v_0, __v_2, __v_7, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_707] = [__v_9]; record.function_queries[707].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = (__v_3 - __v_2); let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_5, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_707] = [__v_7]; record.function_queries[707].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_708: usize = 3; const IN_708: usize = 3; -const OUT_708: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_708] = [__v_6]; record.function_queries[708].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_708] = [__v_9]; record.function_queries[708].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_10, __v_7]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_5, __v_8, __v_2]; 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 __v_12: G = __r_arr[0]; let __ret: [G; OUT_708] = [__v_12]; record.function_queries[708].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_708] = [__v_12]; record.function_queries[708].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_709: usize = 7; -const IN_709: usize = 7; -const OUT_709: usize = 4; -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 __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_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 __v_11: G = (__v_6 + __v_5); let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_8, __v_1, __v_11]; 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_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; 3] = [__v_14, __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 }, } }; match __v_12.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __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 __v_18: G = { let __values: [G; 3] = [__v_16, __v_13, __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 = G::from_u64(1); let __v_20: G = (__v_5 + __v_19); let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_9, __v_1, __v_15, __v_17, __v_18, __v_20, __v_6]; 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 __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __ret: [G; OUT_709] = [__v_21, __v_22, __v_23, __v_24]; record.function_queries[709].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 + __v_16); let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; 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 __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 __ret: [G; OUT_709] = [__v_18, __v_19, __v_20, __v_21]; record.function_queries[709].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(785, (&__args[..]))?) { [G::ZERO; OUT_785] } else { let (__hash, __hit) = record.function_queries[785].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[785].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { (*(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785])) }; __ret }, _ => { aiur_fn_785::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(785, (&__args[..]))?) { [G::ZERO; OUT_785] } else { let (__hash, __hit) = record.function_queries[785].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[785].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { (*(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785])) }; __ret }, _ => { aiur_fn_785::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(785, (&__args[..]))?) { [G::ZERO; OUT_785] } else { let (__hash, __hit) = record.function_queries[785].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[785].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { (*(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785])) }; __ret }, _ => { aiur_fn_785::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_709] = [__v_11, __v_12, __v_13, __v_0]; record.function_queries[709].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_710: usize = 4; -const IN_710: usize = 4; -const OUT_710: usize = 1; -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 __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(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_710] = [__v_11]; record.function_queries[710].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_5]; 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_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() { 5u64 => { let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; 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_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(366, (&__args[..]))?) { [G::ZERO; OUT_366] } else { let (__hash, __hit) = record.function_queries[366].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[366].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { (*(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366])) }; __ret }, _ => { aiur_fn_366::(__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_3 + __v_26); let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_9, __v_1, __v_2, __v_27]; 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 __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 3] = [__v_24, __v_25, __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_710] = [__v_29]; record.function_queries[710].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_9, __v_1, __v_2, __v_3]; 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 __v_23: G = __r_arr[0]; let __ret: [G; OUT_710] = [__v_23]; record.function_queries[710].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_711: usize = 13; -const IN_711: usize = 13; -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 __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_3, __v_5, __v_6, __v_4]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_13]; 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_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() { 5u64 => { let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_10]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__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_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_22]; 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_30: G = __r_arr[0]; let __v_31: G = (__v_29 - __v_30); let __v_32: G = (__v_28 * __v_31); let __v_33: G = (__v_27 * __v_32); let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(799, (&__args[..]))?) { [G::ZERO; OUT_799] } else { let (__hash, __hit) = record.function_queries[799].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[799].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[799].bump_multiplicity(__i); } let __ret: [G; OUT_799] = unsafe { (*(record.function_queries[799].output_at(__i).as_ptr() as *const [G; OUT_799])) }; __ret }, _ => { aiur_fn_799::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; if (__v_34 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) }); } let __v_35: G = (__v_3 + __v_5); let __v_36: G = (__v_6 + __v_4); let __v_37: G = (__v_35 + __v_36); let __v_38: G = (__v_37 + __v_29); let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_38]; 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_39: G = __r_arr[0]; let __v_40: G = (__v_5 + __v_6); let __v_41: G = (__v_3 + __v_40); let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_7, __v_41, __v_1]; 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 __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() { 1u64 => { break '__mc_0 []; }, _ => { if (__v_3 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("recursor parameter count differs from its inductive's".to_string()) }); } if (__v_4 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) }); } let __v_42: G = (__v_18 + __v_19); let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; 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)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(638, (&__args[..]))?) { [G::ZERO; OUT_638] } else { let (__hash, __hit) = record.function_queries[638].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[638].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { (*(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638])) }; __ret }, _ => { aiur_fn_638::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; if (__v_8 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) }); } let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__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(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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; 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 __ret: [G; OUT_711] = []; record.function_queries[711].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_712: usize = 6; -const IN_712: usize = 6; -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 __v_2: G = 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); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_0, __v_8]; 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_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_122] = { let __args: [G; IN_122] = [__v_11]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_712] = []; record.function_queries[712].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } -const INPUT_SIZE_713: usize = 2; -const IN_713: usize = 2; +const OUT_708: usize = 2; +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 __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0, __v_1, __v_2]; 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 __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_708] = [__v_3, __v_4]; record.function_queries[708].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_709: usize = 3; +const IN_709: usize = 3; +const OUT_709: usize = 2; +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 = 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_428] = { let __args: [G; IN_428] = [__v_0, __v_4]; 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_5: 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_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() { 5u64 => { let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_8, __v_1, __v_2]; 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 __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_709] = [__v_10, __v_11]; record.function_queries[709].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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_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(0); let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_1, __v_13, __v_11, __v_2, __v_16]; 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 __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_709] = [__v_17, __v_18]; record.function_queries[709].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_709] = [__v_16, __v_16]; record.function_queries[709].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_710: usize = 5; +const IN_710: usize = 5; +const OUT_710: usize = 2; +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 __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_710] = [__v_11, __v_11]; record.function_queries[710].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_711] = { let __args: [G; IN_711] = [__v_8, __v_2, __v_3]; 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 __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_710] = [__v_14, __v_4]; record.function_queries[710].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_710] = { let __args: [G; IN_710] = [__v_10, __v_1, __v_2, __v_3, __v_15]; 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 __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_710] = [__v_16, __v_17]; record.function_queries[710].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +const INPUT_SIZE_711: usize = 3; +const IN_711: usize = 3; +const OUT_711: usize = 1; +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 __loaded: [G; 3] = { let __base = 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_711] = [__v_6]; record.function_queries[711].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_711] = [__v_9]; record.function_queries[711].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_2, __v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10, __v_7]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_5, __v_8, __v_2]; 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 __v_12: G = __r_arr[0]; let __ret: [G; OUT_711] = [__v_12]; record.function_queries[711].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_711] = [__v_12]; record.function_queries[711].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_712: usize = 7; +const IN_712: usize = 7; +const OUT_712: usize = 4; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 4] = { let __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_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 __v_11: G = (__v_6 + __v_5); let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_8, __v_1, __v_11]; 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 __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; 3] = [__v_14, __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 }, } }; match __v_12.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __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 __v_18: G = { let __values: [G; 3] = [__v_16, __v_13, __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 = G::from_u64(1); let __v_20: G = (__v_5 + __v_19); let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9, __v_1, __v_15, __v_17, __v_18, __v_20, __v_6]; 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 __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __ret: [G; OUT_712] = [__v_21, __v_22, __v_23, __v_24]; record.function_queries[712].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 + __v_16); let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; 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 __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 __ret: [G; OUT_712] = [__v_18, __v_19, __v_20, __v_21]; record.function_queries[712].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(788, (&__args[..]))?) { [G::ZERO; OUT_788] } else { let (__hash, __hit) = record.function_queries[788].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[788].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { (*(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788])) }; __ret }, _ => { aiur_fn_788::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(788, (&__args[..]))?) { [G::ZERO; OUT_788] } else { let (__hash, __hit) = record.function_queries[788].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[788].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { (*(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788])) }; __ret }, _ => { aiur_fn_788::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(788, (&__args[..]))?) { [G::ZERO; OUT_788] } else { let (__hash, __hit) = record.function_queries[788].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[788].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { (*(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788])) }; __ret }, _ => { aiur_fn_788::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_712] = [__v_11, __v_12, __v_13, __v_0]; record.function_queries[712].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_713: usize = 4; +const IN_713: usize = 4; const OUT_713: usize = 1; -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 __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_713] = [__v_4]; record.function_queries[713].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_713] = { let __args: [G; IN_713] = [__v_0, __v_7]; 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 __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_713] = [__v_9]; record.function_queries[713].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_714: usize = 3; -const IN_714: usize = 3; +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 __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(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(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_713] = [__v_11]; record.function_queries[713].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__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_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() { 5u64 => { let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; 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_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_23, __v_3, __v_24]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = (__v_3 + __v_26); let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_9, __v_1, __v_2, __v_27]; 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 __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 3] = [__v_24, __v_25, __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_713] = [__v_29]; record.function_queries[713].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_9, __v_1, __v_2, __v_3]; 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 __v_23: G = __r_arr[0]; let __ret: [G; OUT_713] = [__v_23]; record.function_queries[713].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_714: usize = 13; +const IN_714: usize = 13; 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 __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_714] = []; record.function_queries[714].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_599] = { let __args: [G; IN_599] = [__v_6, __v_8, __v_2]; 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_714] = { let __args: [G; IN_714] = [__v_7, __v_1, __v_2]; 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 __ret: [G; OUT_714] = []; record.function_queries[714].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_715: usize = 4; -const IN_715: usize = 4; -const OUT_715: usize = 3; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_715] = [__v_0, __v_2, __v_3]; record.function_queries[715].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_715] = { let __args: [G; IN_715] = [__v_6, __v_9, __v_10, __v_12]; 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 __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __ret: [G; OUT_715] = [__v_13, __v_14, __v_15]; record.function_queries[715].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_715] = [__v_0, __v_2, __v_3]; record.function_queries[715].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_716: usize = 13; -const IN_716: usize = 13; -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 __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; 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 __v_13: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_2]; 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_716] = []; record.function_queries[716].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_14, __v_1]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_2]; 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 __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_3]; 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 __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_3, __v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(518, (&__args[..]))?) { [G::ZERO; OUT_518] } else { let (__hash, __hit) = record.function_queries[518].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[518].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { (*(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518])) }; __ret }, _ => { aiur_fn_518::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_716] = []; record.function_queries[716].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_14, __v_1]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__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 __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_17, __v_18]; 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_19: G = __r_arr[0]; if (__v_19 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("theorem's type is not a Prop".to_string()) }); } let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_2]; 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 __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_3]; 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 __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_3, __v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(518, (&__args[..]))?) { [G::ZERO; OUT_518] } else { let (__hash, __hit) = record.function_queries[518].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[518].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { (*(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518])) }; __ret }, _ => { aiur_fn_518::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_716] = []; record.function_queries[716].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_14, __v_1]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_2]; 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 __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_3]; 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 __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_3, __v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(518, (&__args[..]))?) { [G::ZERO; OUT_518] } else { let (__hash, __hit) = record.function_queries[518].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[518].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { (*(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518])) }; __ret }, _ => { aiur_fn_518::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_716] = []; record.function_queries[716].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_2]; 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 __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_12, __v_3, __v_1, __v_2]; 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 __ret: [G; OUT_716] = []; record.function_queries[716].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_2]; 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 __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_7]; 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_628] = { let __args: [G; IN_628] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; 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 __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_0, __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(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 __ret: [G; OUT_716] = []; record.function_queries[716].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_2]; 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 __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_4]; 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_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 => { if (__v_6 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) }); } let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_21, __v_2, __v_22]; 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 __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_6, __v_23, __v_7, __v_20, __v_3, __v_4]; 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_31: G = (__v_22 + __v_23); 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 __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_21, __v_31, __v_33]; 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_34: G = __r_arr[0]; let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_6, __v_34]; 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)? }, } } }; match __v_25.as_canonical_u64() { 0u64 => { let __v_35: G = G::from_u64(1); let __v_36: 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_627] = { let __args: [G; IN_627] = [__v_2, __v_6, __v_3, __v_36]; 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 __ret: [G; OUT_716] = []; record.function_queries[716].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_716] = []; record.function_queries[716].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }, 7u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(517, (&__args[..]))?) { [G::ZERO; OUT_517] } else { let (__hash, __hit) = record.function_queries[517].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[517].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { (*(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517])) }; __ret }, _ => { aiur_fn_517::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_13, __v_2]; 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 __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_10]; 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_711] = { let __args: [G; IN_711] = [__v_0, __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(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_716] = []; record.function_queries[716].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_717: usize = 1; -const IN_717: usize = 1; +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]; match __v_0.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_2, __v_3, __v_5, __v_6, __v_4]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_13]; 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_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() { 5u64 => { let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(643, (&__args[..]))?) { [G::ZERO; OUT_643] } else { let (__hash, __hit) = record.function_queries[643].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[643].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { (*(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643])) }; __ret }, _ => { aiur_fn_643::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(643, (&__args[..]))?) { [G::ZERO; OUT_643] } else { let (__hash, __hit) = record.function_queries[643].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[643].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { (*(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643])) }; __ret }, _ => { aiur_fn_643::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_22]; 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_30: G = __r_arr[0]; let __v_31: G = (__v_29 - __v_30); let __v_32: G = (__v_28 * __v_31); let __v_33: G = (__v_27 * __v_32); let __r_arr: [G; OUT_802] = { let __args: [G; IN_802] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(802, (&__args[..]))?) { [G::ZERO; OUT_802] } else { let (__hash, __hit) = record.function_queries[802].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[802].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[802].bump_multiplicity(__i); } let __ret: [G; OUT_802] = unsafe { (*(record.function_queries[802].output_at(__i).as_ptr() as *const [G; OUT_802])) }; __ret }, _ => { aiur_fn_802::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; if (__v_34 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) }); } let __v_35: G = (__v_3 + __v_5); let __v_36: G = (__v_6 + __v_4); let __v_37: G = (__v_35 + __v_36); let __v_38: G = (__v_37 + __v_29); let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_38]; 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_39: G = __r_arr[0]; let __v_40: G = (__v_5 + __v_6); let __v_41: G = (__v_3 + __v_40); let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_7, __v_41, __v_1]; 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 __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() { 1u64 => { break '__mc_0 []; }, _ => { if (__v_3 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("recursor parameter count differs from its inductive's".to_string()) }); } if (__v_4 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) }); } let __v_42: G = (__v_18 + __v_19); let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; 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)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; 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_42: G = __r_arr[0]; if (__v_8 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) }); } let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__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(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 __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; 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)? }, } } }; let __ret: [G; OUT_714] = []; record.function_queries[714].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +const INPUT_SIZE_715: usize = 6; +const IN_715: usize = 6; +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 __v_2: G = 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); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_8]; 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 __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_125] = { let __args: [G; IN_125] = [__v_11]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_715] = []; record.function_queries[715].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } +const INPUT_SIZE_716: usize = 2; +const IN_716: usize = 2; +const OUT_716: usize = 1; +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 = (__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_716] = [__v_4]; record.function_queries[716].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_716] = { let __args: [G; IN_716] = [__v_0, __v_7]; 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 __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_716] = [__v_9]; record.function_queries[716].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_717: usize = 3; +const IN_717: usize = 3; const OUT_717: usize = 0; -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_295] = { let __args: [G; IN_295] = [__v_0]; 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_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_716] = { let __args: [G; IN_716] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; 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_717] = []; record.function_queries[717].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_718: usize = 1; -const IN_718: usize = 1; -const OUT_718: usize = 1; -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 __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_19] = { let __args: [G; IN_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(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__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_718] = [__v_23]; record.function_queries[718].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_19] = { let __args: [G; IN_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(19, (&__args[..]))?) { [G::ZERO; OUT_19] } else { let (__hash, __hit) = record.function_queries[19].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[19].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[19].bump_multiplicity(__i); } let __ret: [G; OUT_19] = unsafe { (*(record.function_queries[19].output_at(__i).as_ptr() as *const [G; OUT_19])) }; __ret }, _ => { aiur_fn_19::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_18]; 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_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_718] = [__v_22]; record.function_queries[718].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_718] = [__v_21]; record.function_queries[718].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_718] = [__v_21]; record.function_queries[718].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_7]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_718] = [__v_21]; record.function_queries[718].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_7]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9]; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_19, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_718] = [__v_23]; record.function_queries[718].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_718] = [__v_20]; record.function_queries[718].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_719: usize = 1; -const IN_719: usize = 1; -const OUT_719: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_719] = [__v_5]; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_719] = [__v_6]; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __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_717] = []; record.function_queries[717].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_602] = { let __args: [G; IN_602] = [__v_6, __v_8, __v_2]; 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 __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_7, __v_1, __v_2]; 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 __ret: [G; OUT_717] = []; record.function_queries[717].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_718: usize = 4; +const IN_718: usize = 4; +const OUT_718: usize = 3; +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 __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_718] = [__v_0, __v_2, __v_3]; record.function_queries[718].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_718] = { let __args: [G; IN_718] = [__v_6, __v_9, __v_10, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __ret: [G; OUT_718] = [__v_13, __v_14, __v_15]; record.function_queries[718].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_718] = [__v_0, __v_2, __v_3]; record.function_queries[718].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_719: usize = 13; +const IN_719: usize = 13; +const OUT_719: usize = 0; +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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__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(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_13: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_2]; 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_719] = []; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_14, __v_1]; 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 __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_3, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_2]; 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_599] = { let __args: [G; IN_599] = [__v_13, __v_3]; 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_521] = { let __args: [G; IN_521] = [__v_3, __v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(521, (&__args[..]))?) { [G::ZERO; OUT_521] } else { let (__hash, __hit) = record.function_queries[521].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[521].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { (*(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521])) }; __ret }, _ => { aiur_fn_521::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_719] = []; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_14, __v_1]; 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 __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_3, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__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 __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_17, __v_18]; 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_19: G = __r_arr[0]; if (__v_19 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("theorem's type is not a Prop".to_string()) }); } let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_2]; 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_599] = { let __args: [G; IN_599] = [__v_13, __v_3]; 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_521] = { let __args: [G; IN_521] = [__v_3, __v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(521, (&__args[..]))?) { [G::ZERO; OUT_521] } else { let (__hash, __hit) = record.function_queries[521].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[521].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { (*(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521])) }; __ret }, _ => { aiur_fn_521::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_719] = []; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_14, __v_1]; 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 __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_3, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_2]; 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_599] = { let __args: [G; IN_599] = [__v_13, __v_3]; 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_521] = { let __args: [G; IN_521] = [__v_3, __v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(521, (&__args[..]))?) { [G::ZERO; OUT_521] } else { let (__hash, __hit) = record.function_queries[521].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[521].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { (*(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521])) }; __ret }, _ => { aiur_fn_521::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_719] = []; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_2]; 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_607] = { let __args: [G; IN_607] = [__v_12, __v_3, __v_1, __v_2]; 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 __ret: [G; OUT_719] = []; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_2]; 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_596] = { let __args: [G; IN_596] = [__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 __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __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(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 __ret: [G; OUT_719] = []; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_2]; 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_300] = { let __args: [G; IN_300] = [__v_3, __v_4]; 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_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 => { if (__v_6 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) }); } let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_21, __v_2, __v_22]; 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 __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_2, __v_6, __v_23, __v_7, __v_20, __v_3, __v_4]; 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_31: G = (__v_22 + __v_23); 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 __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_21, __v_31, __v_33]; 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_34: G = __r_arr[0]; let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_6, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(618, (&__args[..]))?) { [G::ZERO; OUT_618] } else { let (__hash, __hit) = record.function_queries[618].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[618].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { (*(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618])) }; __ret }, _ => { aiur_fn_618::(__args, __hash, record, io_buffer)? }, } } }; match __v_25.as_canonical_u64() { 0u64 => { let __v_35: G = G::from_u64(1); let __v_36: 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_630] = { let __args: [G; IN_630] = [__v_2, __v_6, __v_3, __v_36]; 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 __ret: [G; OUT_719] = []; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_719] = []; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }, 7u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_14, __v_1]; 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 __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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(520, (&__args[..]))?) { [G::ZERO; OUT_520] } else { let (__hash, __hit) = record.function_queries[520].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[520].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { (*(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520])) }; __ret }, _ => { aiur_fn_520::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_2]; 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_596] = { let __args: [G; IN_596] = [__v_10]; 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 __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0, __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(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 __ret: [G; OUT_719] = []; record.function_queries[719].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_720: usize = 1; const IN_720: usize = 1; -const OUT_720: usize = 1; -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 __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_720] = [__v_13]; record.function_queries[720].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_11]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_720] = [__v_14]; record.function_queries[720].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const OUT_720: usize = 0; +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 __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; 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_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_719] = { let __args: [G; IN_719] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; 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 __ret: [G; OUT_720] = []; record.function_queries[720].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_721: usize = 1; const IN_721: usize = 1; const OUT_721: usize = 1; -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 __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_721] = [__v_38]; record.function_queries[721].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_35]; 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_37: G = __r_arr[0]; let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_36]; 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_38: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_37, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_721] = [__v_39]; record.function_queries[721].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __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_721] = [__v_23]; record.function_queries[721].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_721] = { let __args: [G; IN_721] = [__v_18]; 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_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_721] = [__v_22]; record.function_queries[721].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_3]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_721] = [__v_21]; record.function_queries[721].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_5]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_6]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_721] = [__v_21]; record.function_queries[721].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_7]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_8]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_721] = [__v_21]; record.function_queries[721].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_7]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_8]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__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_21: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_19, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_721] = [__v_23]; record.function_queries[721].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_721] = [__v_20]; record.function_queries[721].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_722: usize = 1; const IN_722: usize = 1; const OUT_722: usize = 1; -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 __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_722] = [__v_49]; record.function_queries[722].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_718] = { let __args: [G; IN_718] = [__v_13]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_47]; 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_51: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_722] = [__v_52]; record.function_queries[722].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_28]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_29]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_47]; 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_51: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_722] = [__v_52]; record.function_queries[722].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_45]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__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_49: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_47]; 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_51: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_722] = [__v_52]; record.function_queries[722].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_723: usize = 48; -const IN_723: usize = 48; +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 __loaded: [G; 3] = { let __base = 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_722] = [__v_5]; record.function_queries[722].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_722] = [__v_6]; record.function_queries[722].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_723: usize = 1; +const IN_723: usize = 1; const OUT_723: usize = 1; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_719] = { let __args: [G; IN_719] = [__v_45]; 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_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12]; 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_50: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_49, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_48, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_723] = [__v_52]; record.function_queries[723].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_43]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_44]; 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_50: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_49, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_48, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_723] = [__v_52]; record.function_queries[723].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_723] = [__v_50]; record.function_queries[723].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_723] = [__v_50]; record.function_queries[723].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 8u64 => { let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_723] = [__v_50]; record.function_queries[723].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_723] = [__v_48]; record.function_queries[723].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_724: usize = 2; -const IN_724: usize = 2; +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 __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_723] = [__v_13]; record.function_queries[723].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__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_13: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_723] = [__v_14]; record.function_queries[723].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_724: usize = 1; +const IN_724: usize = 1; const OUT_724: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_724] = [__v_5]; record.function_queries[724].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_724] = [__v_6]; record.function_queries[724].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_724] = [__v_6]; record.function_queries[724].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __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_724] = [__v_38]; record.function_queries[724].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_35]; 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_37: G = __r_arr[0]; let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_36]; 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_38: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_37, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_724] = [__v_39]; record.function_queries[724].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_725: usize = 1; const IN_725: usize = 1; -const OUT_725: usize = 0; -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 __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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() { _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0, __v_2, __v_2, __v_49]; 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)? }, } } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_10]; 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)? }, } } }; break '__mc_0 []; }, } }, 6u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_10]; 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)? }, } } }; break '__mc_0 []; }, } }, 4u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_18]; 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)? }, } } }; break '__mc_0 []; }, } }, 5u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_10]; 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)? }, } } }; break '__mc_0 []; }, } }, _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_47, __v_49, __v_50]; 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 __ret: [G; OUT_725] = []; record.function_queries[725].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_726: usize = 3; -const IN_726: usize = 3; -const OUT_726: usize = 0; -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 __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 __ret: [G; OUT_726] = []; record.function_queries[726].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1, __v_2]; 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_6: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_4]; 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)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_1, __v_8]; 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 __ret: [G; OUT_726] = []; record.function_queries[726].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_727: usize = 4; -const IN_727: usize = 4; -const OUT_727: usize = 0; -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 __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 __ret: [G; OUT_727] = []; record.function_queries[727].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; 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_51: G = G::from_u64(1); let __v_52: G = (__v_3 + __v_51); let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0, __v_1, __v_50, __v_52]; 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 __ret: [G; OUT_727] = []; record.function_queries[727].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_728: usize = 48; -const IN_728: usize = 48; +const OUT_725: usize = 1; +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 __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_725] = [__v_49]; record.function_queries[725].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_721] = { let __args: [G; IN_721] = [__v_13]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_47]; 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_51: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_725] = [__v_52]; record.function_queries[725].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_28]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_29]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_47]; 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_51: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_725] = [__v_52]; record.function_queries[725].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_45]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_46]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_47]; 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_51: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_725] = [__v_52]; record.function_queries[725].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_726: usize = 48; +const IN_726: usize = 48; +const OUT_726: usize = 1; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_722] = { let __args: [G; IN_722] = [__v_45]; 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_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__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_49: G = __r_arr[0]; let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12]; 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_50: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_49, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_48, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_726] = [__v_52]; record.function_queries[726].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_43]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_44]; 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_50: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_49, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_48, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_726] = [__v_52]; record.function_queries[726].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_726] = [__v_50]; record.function_queries[726].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 3u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_726] = [__v_50]; record.function_queries[726].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 8u64 => { let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_1]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_726] = [__v_50]; record.function_queries[726].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_726] = [__v_48]; record.function_queries[726].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_727: usize = 2; +const IN_727: usize = 2; +const OUT_727: usize = 1; +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 __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_727] = [__v_5]; record.function_queries[727].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_727] = [__v_6]; record.function_queries[727].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_727] = [__v_6]; record.function_queries[727].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_728: usize = 1; +const IN_728: usize = 1; const OUT_728: usize = 0; -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 __v_9: G = inp[9]; 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 __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __v_0, __v_47]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_48]; 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_49: 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_49.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_50: G = __loaded[0]; let __v_51: G = __loaded[1]; let __v_52: G = __loaded[2]; let __v_53: G = __loaded[3]; let __v_54: G = __loaded[4]; let __v_55: G = __loaded[5]; let __v_56: G = __loaded[6]; let __v_57: G = __loaded[7]; let __v_58: G = __loaded[8]; let __v_59: G = __loaded[9]; let __v_60: G = __loaded[10]; let __v_61: G = __loaded[11]; let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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_48]; 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_728] = []; record.function_queries[728].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_729: usize = 1; -const IN_729: usize = 1; -const OUT_729: usize = 1; -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 = 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_52] = { let __args: [G; IN_52] = [__v_0, __v_2]; 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 = 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_24] = { let __args: [G; IN_24] = [__v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_729] = [__v_6]; record.function_queries[729].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_730: usize = 2; -const IN_730: usize = 2; -const OUT_730: usize = 1; -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 __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_52] = { let __args: [G; IN_52] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_4]; 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_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_24] = { let __args: [G; IN_24] = [__v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_730] = [__v_8]; record.function_queries[730].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_731: usize = 1; -const IN_731: usize = 1; -const OUT_731: usize = 3; -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_79] = { let __args: [G; IN_79] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_2]; let __cu = unconstrained; if ((!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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_3]; 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_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_731] = [__v_5, __v_9, __v_4]; record.function_queries[731].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_731] = [__v_4, __v_6, __v_2]; record.function_queries[731].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_5]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_3, __v_6]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_731] = [__v_9, __v_10, __v_8]; record.function_queries[731].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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() { _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_0, __v_2, __v_2, __v_49]; 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)? }, } } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_10]; 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)? }, } } }; break '__mc_0 []; }, } }, 6u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_10]; 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)? }, } } }; break '__mc_0 []; }, } }, 4u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_18]; 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)? }, } } }; break '__mc_0 []; }, } }, 5u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_10]; 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)? }, } } }; break '__mc_0 []; }, } }, _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_47, __v_49, __v_50]; 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 __ret: [G; OUT_728] = []; record.function_queries[728].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_729: usize = 3; +const IN_729: usize = 3; +const OUT_729: usize = 0; +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]; 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 __ret: [G; OUT_729] = []; record.function_queries[729].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_2]; 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_6: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_4]; 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)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_5, __v_1, __v_8]; 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 __ret: [G; OUT_729] = []; record.function_queries[729].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_730: usize = 4; +const IN_730: usize = 4; +const OUT_730: usize = 0; +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 __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 __ret: [G; OUT_730] = []; record.function_queries[730].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; 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_51: G = G::from_u64(1); let __v_52: G = (__v_3 + __v_51); let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_0, __v_1, __v_50, __v_52]; 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 __ret: [G; OUT_730] = []; record.function_queries[730].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_731: usize = 48; +const IN_731: usize = 48; +const OUT_731: usize = 0; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_1, __v_0, __v_47]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_48]; 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_49: 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_49.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_50: G = __loaded[0]; let __v_51: G = __loaded[1]; let __v_52: G = __loaded[2]; let __v_53: G = __loaded[3]; let __v_54: G = __loaded[4]; let __v_55: G = __loaded[5]; let __v_56: G = __loaded[6]; let __v_57: G = __loaded[7]; let __v_58: G = __loaded[8]; let __v_59: G = __loaded[9]; let __v_60: G = __loaded[10]; let __v_61: G = __loaded[11]; let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__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_48]; 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 __ret: [G; OUT_731] = []; record.function_queries[731].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_732: usize = 1; const IN_732: usize = 1; const OUT_732: usize = 1; -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 __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 = __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 = G::from_u64(14); if (__v_37 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("assumption tree: wrong tag4 flag".to_string()) }); } let __v_48: G = G::from_u64(2); if (__v_38 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("assumption tree: wrong tag4 variant".to_string()) }); } let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_46]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: 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_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]; if (__v_52 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) }); } if (__v_53 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) }); } if (__v_54 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.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_49.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; let __v_58: G = __loaded[3]; let __v_59: G = __loaded[4]; let __v_60: G = __loaded[5]; let __v_61: G = __loaded[6]; let __v_62: G = __loaded[7]; let __v_63: G = __loaded[8]; let __v_64: G = __loaded[9]; let __v_65: G = __loaded[10]; let __v_66: G = __loaded[11]; let __v_67: G = __loaded[12]; let __v_68: G = __loaded[13]; let __v_69: G = __loaded[14]; let __v_70: G = __loaded[15]; let __v_71: G = __loaded[16]; let __v_72: G = __loaded[17]; let __v_73: G = __loaded[18]; let __v_74: G = __loaded[19]; let __v_75: G = __loaded[20]; let __v_76: G = __loaded[21]; let __v_77: G = __loaded[22]; let __v_78: G = __loaded[23]; let __v_79: G = __loaded[24]; let __v_80: G = __loaded[25]; let __v_81: G = __loaded[26]; let __v_82: G = __loaded[27]; let __v_83: G = __loaded[28]; let __v_84: G = __loaded[29]; let __v_85: G = __loaded[30]; let __v_86: G = __loaded[31]; if (__v_55 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_56 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_57 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_58 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_59 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_60 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_61 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_62 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_63 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_64 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_65 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_66 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_67 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_68 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_69 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_70 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_71 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_72 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_73 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_74 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_75 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_76 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_77 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_78 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_79 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_80 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_81 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_82 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_83 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_84 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_85 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_86 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } let __ret: [G; OUT_732] = [__v_50]; record.function_queries[732].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_733: usize = 7; -const IN_733: usize = 7; -const OUT_733: usize = 6; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __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_733] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; record.function_queries[733].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_733] = { let __args: [G; IN_733] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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_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_733] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; record.function_queries[733].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_734: usize = 7; -const IN_734: usize = 7; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = 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_784] = { let __args: [G; IN_784] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_734] = [__v_8]; record.function_queries[734].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_735: usize = 14; -const IN_735: usize = 14; -const OUT_735: usize = 0; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_734] = { let __args: [G; IN_734] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_735] = []; record.function_queries[735].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("CheckEnv: walk reached a constant outside the owned set".to_string()) }); } break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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() { _ => { let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() { 8u64 => { let __v_63: G = G::from_u64(0); let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0, __v_16, __v_16, __v_63]; 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)? }, } } }; break '__mc_1 []; }, 7u64 => { match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_24, __v_1, __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(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)? }, } } }; break '__mc_1 []; }, } }, 6u64 => { match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_24, __v_1, __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(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)? }, } } }; break '__mc_1 []; }, } }, 4u64 => { match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_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]; 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)? }, } } }; break '__mc_1 []; }, } }, 5u64 => { match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_24, __v_1, __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(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)? }, } } }; break '__mc_1 []; }, } }, _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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)? }, } } }; break '__mc_1 []; }, } }; let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_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]; 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_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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 __ret: [G; OUT_735] = []; record.function_queries[735].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_736: usize = 16; -const IN_736: usize = 16; -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]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 __loaded: [G; 3] = { let __base = 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_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.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_724] = { let __args: [G; IN_724] = [__v_1, __v_2]; 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_19: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_17, __v_3, __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(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)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_2 + __v_20); let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_18, __v_1, __v_21, __v_3, __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(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 __ret: [G; OUT_736] = []; record.function_queries[736].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }) } -const INPUT_SIZE_737: usize = 13; -const IN_737: usize = 13; -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]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __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_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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_737] = []; record.function_queries[737].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; 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 __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 __ret: [G; OUT_737] = []; record.function_queries[737].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }) } -const INPUT_SIZE_738: usize = 3; -const IN_738: usize = 3; +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 = 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_53] = { let __args: [G; IN_53] = [__v_0, __v_2]; 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_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_732] = [__v_6]; record.function_queries[732].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_733: usize = 2; +const IN_733: usize = 2; +const OUT_733: usize = 1; +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 __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_53] = { let __args: [G; IN_53] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_4]; 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_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_733] = [__v_8]; record.function_queries[733].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_734: usize = 1; +const IN_734: usize = 1; +const OUT_734: usize = 3; +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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_3]; 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_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_734] = [__v_5, __v_9, __v_4]; record.function_queries[734].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_734] = [__v_4, __v_6, __v_2]; record.function_queries[734].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_2]; 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 __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_3, __v_6]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_734] = [__v_9, __v_10, __v_8]; record.function_queries[734].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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]; 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_80] = { let __args: [G; IN_80] = [__v_36]; 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_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_734] = { let __args: [G; IN_734] = [__v_38]; 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_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_735] = [__v_41]; record.function_queries[735].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_736: usize = 7; +const IN_736: usize = 7; +const OUT_736: usize = 6; +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]; let __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_736] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; record.function_queries[736].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_804] = { let __args: [G; IN_804] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(804, (&__args[..]))?) { [G::ZERO; OUT_804] } else { let (__hash, __hit) = record.function_queries[804].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[804].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[804].bump_multiplicity(__i); } let __ret: [G; OUT_804] = unsafe { (*(record.function_queries[804].output_at(__i).as_ptr() as *const [G; OUT_804])) }; __ret }, _ => { aiur_fn_804::(__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_736] = { let __args: [G; IN_736] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 __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_736] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; record.function_queries[736].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +const INPUT_SIZE_737: usize = 7; +const IN_737: usize = 7; +const OUT_737: usize = 1; +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]; let __v_3: G = 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_787] = { let __args: [G; IN_787] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_737] = [__v_8]; record.function_queries[737].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_738: usize = 14; +const IN_738: usize = 14; 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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__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 __ret: [G; OUT_738] = []; record.function_queries[738].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; 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_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_3, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; 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_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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_2]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_11, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; 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_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 __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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 __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 = 1; -const IN_739: usize = 1; +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]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_737] = { let __args: [G; IN_737] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_738] = []; record.function_queries[738].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("CheckEnv: walk reached a constant outside the owned set".to_string()) }); } break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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() { _ => { let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() { 8u64 => { let __v_63: G = G::from_u64(0); let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_0, __v_16, __v_16, __v_63]; 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)? }, } } }; break '__mc_1 []; }, 7u64 => { match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_24, __v_1, __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(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)? }, } } }; break '__mc_1 []; }, } }, 6u64 => { match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_24, __v_1, __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(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)? }, } } }; break '__mc_1 []; }, } }, 4u64 => { match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_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]; 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)? }, } } }; break '__mc_1 []; }, } }, 5u64 => { match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_24, __v_1, __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(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)? }, } } }; break '__mc_1 []; }, } }, _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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)? }, } } }; break '__mc_1 []; }, } }; let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_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]; 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_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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 __ret: [G; OUT_738] = []; record.function_queries[738].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +const INPUT_SIZE_739: usize = 16; +const IN_739: usize = 16; 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 __loaded: [G; 3] = { let __base = 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_739] = []; record.function_queries[739].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_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_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 __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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(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_739] = { let __args: [G; IN_739] = [__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 __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 = 32; -const IN_740: usize = 32; +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]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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 __loaded: [G; 3] = { let __base = 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_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_739] = []; record.function_queries[739].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_2]; 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_19: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_17, __v_3, __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(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)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_2 + __v_20); let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_18, __v_1, __v_21, __v_3, __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(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 __ret: [G; OUT_739] = []; record.function_queries[739].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }) } +const INPUT_SIZE_740: usize = 13; +const IN_740: usize = 13; 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]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_741] = { let __args: [G; IN_741] = [__v_32]; 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_740] = []; record.function_queries[740].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_741: usize = 1; -const IN_741: usize = 1; +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 __loaded: [G; 3] = { let __base = 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_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_740] = []; record.function_queries[740].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; 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_15, __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(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 __ret: [G; OUT_740] = []; record.function_queries[740].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_13.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 __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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_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() { _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0, __v_2, __v_2, __v_49]; 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)? }, } } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __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_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: 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_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; let __v_52: G = __loaded[3]; let __v_53: G = __loaded[4]; let __v_54: G = __loaded[5]; let __v_55: G = __loaded[6]; let __v_56: G = __loaded[7]; let __v_57: G = __loaded[8]; let __v_58: G = __loaded[9]; let __v_59: G = __loaded[10]; let __v_60: G = __loaded[11]; let __v_61: G = __loaded[12]; let __v_62: G = __loaded[13]; let __v_63: G = __loaded[14]; let __v_64: G = __loaded[15]; let __v_65: G = __loaded[16]; let __v_66: G = __loaded[17]; let __v_67: G = __loaded[18]; let __v_68: G = __loaded[19]; let __v_69: G = __loaded[20]; let __v_70: G = __loaded[21]; let __v_71: G = __loaded[22]; let __v_72: G = __loaded[23]; let __v_73: G = __loaded[24]; let __v_74: G = __loaded[25]; let __v_75: G = __loaded[26]; let __v_76: G = __loaded[27]; let __v_77: G = __loaded[28]; let __v_78: G = __loaded[29]; let __v_79: G = __loaded[30]; let __v_80: G = __loaded[31]; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__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]; 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)? }, } } }; break '__mc_0 []; }, } }, 6u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __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_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: 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_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; let __v_52: G = __loaded[3]; let __v_53: G = __loaded[4]; let __v_54: G = __loaded[5]; let __v_55: G = __loaded[6]; let __v_56: G = __loaded[7]; let __v_57: G = __loaded[8]; let __v_58: G = __loaded[9]; let __v_59: G = __loaded[10]; let __v_60: G = __loaded[11]; let __v_61: G = __loaded[12]; let __v_62: G = __loaded[13]; let __v_63: G = __loaded[14]; let __v_64: G = __loaded[15]; let __v_65: G = __loaded[16]; let __v_66: G = __loaded[17]; let __v_67: G = __loaded[18]; let __v_68: G = __loaded[19]; let __v_69: G = __loaded[20]; let __v_70: G = __loaded[21]; let __v_71: G = __loaded[22]; let __v_72: G = __loaded[23]; let __v_73: G = __loaded[24]; let __v_74: G = __loaded[25]; let __v_75: G = __loaded[26]; let __v_76: G = __loaded[27]; let __v_77: G = __loaded[28]; let __v_78: G = __loaded[29]; let __v_79: G = __loaded[30]; let __v_80: G = __loaded[31]; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__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]; 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)? }, } } }; break '__mc_0 []; }, } }, 4u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __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_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: 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_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; let __v_52: G = __loaded[3]; let __v_53: G = __loaded[4]; let __v_54: G = __loaded[5]; let __v_55: G = __loaded[6]; let __v_56: G = __loaded[7]; let __v_57: G = __loaded[8]; let __v_58: G = __loaded[9]; let __v_59: G = __loaded[10]; let __v_60: G = __loaded[11]; let __v_61: G = __loaded[12]; let __v_62: G = __loaded[13]; let __v_63: G = __loaded[14]; let __v_64: G = __loaded[15]; let __v_65: G = __loaded[16]; let __v_66: G = __loaded[17]; let __v_67: G = __loaded[18]; let __v_68: G = __loaded[19]; let __v_69: G = __loaded[20]; let __v_70: G = __loaded[21]; let __v_71: G = __loaded[22]; let __v_72: G = __loaded[23]; let __v_73: G = __loaded[24]; let __v_74: G = __loaded[25]; let __v_75: G = __loaded[26]; let __v_76: G = __loaded[27]; let __v_77: G = __loaded[28]; let __v_78: G = __loaded[29]; let __v_79: G = __loaded[30]; let __v_80: G = __loaded[31]; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__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]; 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)? }, } } }; break '__mc_0 []; }, } }, 5u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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 __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_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: 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_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; let __v_52: G = __loaded[3]; let __v_53: G = __loaded[4]; let __v_54: G = __loaded[5]; let __v_55: G = __loaded[6]; let __v_56: G = __loaded[7]; let __v_57: G = __loaded[8]; let __v_58: G = __loaded[9]; let __v_59: G = __loaded[10]; let __v_60: G = __loaded[11]; let __v_61: G = __loaded[12]; let __v_62: G = __loaded[13]; let __v_63: G = __loaded[14]; let __v_64: G = __loaded[15]; let __v_65: G = __loaded[16]; let __v_66: G = __loaded[17]; let __v_67: G = __loaded[18]; let __v_68: G = __loaded[19]; let __v_69: G = __loaded[20]; let __v_70: G = __loaded[21]; let __v_71: G = __loaded[22]; let __v_72: G = __loaded[23]; let __v_73: G = __loaded[24]; let __v_74: G = __loaded[25]; let __v_75: G = __loaded[26]; let __v_76: G = __loaded[27]; let __v_77: G = __loaded[28]; let __v_78: G = __loaded[29]; let __v_79: G = __loaded[30]; let __v_80: G = __loaded[31]; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__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]; 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)? }, } } }; break '__mc_0 []; }, } }, _ => { let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_47, __v_49, __v_50]; 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_741] = []; record.function_queries[741].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_742: usize = 3; -const IN_742: usize = 3; +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 __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_742] = { let __args: [G; IN_742] = [__v_3]; 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_741] = []; record.function_queries[741].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 __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_3, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; 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 __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 __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_11: G = __r_arr[0]; let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_11, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; 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 __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 __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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 __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 = 1; +const IN_742: usize = 1; 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]; let __loaded: [G; 3] = { let __base = 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 __ret: [G; OUT_742] = []; record.function_queries[742].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1, __v_2]; 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_6: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 1u64 => { 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_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 __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __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)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_5, __v_1, __v_8]; 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_742] = []; record.function_queries[742].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_743: usize = 1; -const IN_743: usize = 1; -const OUT_743: usize = 3; -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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; 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_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_743] = [__v_3, __v_3, __v_2]; record.function_queries[743].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __ret: [G; OUT_743] = [__v_5, __v_3, __v_4]; record.function_queries[743].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_744: usize = 2; -const IN_744: usize = 2; -const OUT_744: usize = 10; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_744] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_1]; record.function_queries[744].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1]; 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_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_744] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; record.function_queries[744].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_745: usize = 2; -const IN_745: usize = 2; -const OUT_745: usize = 3; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_745] = [__v_2, __v_2, __v_1]; record.function_queries[745].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); let __ret: [G; OUT_745] = [__v_4, __v_2, __v_3]; 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; +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 __loaded: [G; 3] = { let __base = 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_742] = []; record.function_queries[742].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_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_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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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(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 __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3]; 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_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 = 32; +const IN_743: usize = 32; +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 __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_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_744] = { let __args: [G; IN_744] = [__v_32]; 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_743] = []; record.function_queries[743].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_744: usize = 1; +const IN_744: usize = 1; +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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; 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_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() { _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_0, __v_2, __v_2, __v_49]; 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)? }, } } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __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_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: 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_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; let __v_52: G = __loaded[3]; let __v_53: G = __loaded[4]; let __v_54: G = __loaded[5]; let __v_55: G = __loaded[6]; let __v_56: G = __loaded[7]; let __v_57: G = __loaded[8]; let __v_58: G = __loaded[9]; let __v_59: G = __loaded[10]; let __v_60: G = __loaded[11]; let __v_61: G = __loaded[12]; let __v_62: G = __loaded[13]; let __v_63: G = __loaded[14]; let __v_64: G = __loaded[15]; let __v_65: G = __loaded[16]; let __v_66: G = __loaded[17]; let __v_67: G = __loaded[18]; let __v_68: G = __loaded[19]; let __v_69: G = __loaded[20]; let __v_70: G = __loaded[21]; let __v_71: G = __loaded[22]; let __v_72: G = __loaded[23]; let __v_73: G = __loaded[24]; let __v_74: G = __loaded[25]; let __v_75: G = __loaded[26]; let __v_76: G = __loaded[27]; let __v_77: G = __loaded[28]; let __v_78: G = __loaded[29]; let __v_79: G = __loaded[30]; let __v_80: G = __loaded[31]; let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__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]; 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)? }, } } }; break '__mc_0 []; }, } }, 6u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __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_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: 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_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; let __v_52: G = __loaded[3]; let __v_53: G = __loaded[4]; let __v_54: G = __loaded[5]; let __v_55: G = __loaded[6]; let __v_56: G = __loaded[7]; let __v_57: G = __loaded[8]; let __v_58: G = __loaded[9]; let __v_59: G = __loaded[10]; let __v_60: G = __loaded[11]; let __v_61: G = __loaded[12]; let __v_62: G = __loaded[13]; let __v_63: G = __loaded[14]; let __v_64: G = __loaded[15]; let __v_65: G = __loaded[16]; let __v_66: G = __loaded[17]; let __v_67: G = __loaded[18]; let __v_68: G = __loaded[19]; let __v_69: G = __loaded[20]; let __v_70: G = __loaded[21]; let __v_71: G = __loaded[22]; let __v_72: G = __loaded[23]; let __v_73: G = __loaded[24]; let __v_74: G = __loaded[25]; let __v_75: G = __loaded[26]; let __v_76: G = __loaded[27]; let __v_77: G = __loaded[28]; let __v_78: G = __loaded[29]; let __v_79: G = __loaded[30]; let __v_80: G = __loaded[31]; let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__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]; 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)? }, } } }; break '__mc_0 []; }, } }, 4u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __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_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: 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_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; let __v_52: G = __loaded[3]; let __v_53: G = __loaded[4]; let __v_54: G = __loaded[5]; let __v_55: G = __loaded[6]; let __v_56: G = __loaded[7]; let __v_57: G = __loaded[8]; let __v_58: G = __loaded[9]; let __v_59: G = __loaded[10]; let __v_60: G = __loaded[11]; let __v_61: G = __loaded[12]; let __v_62: G = __loaded[13]; let __v_63: G = __loaded[14]; let __v_64: G = __loaded[15]; let __v_65: G = __loaded[16]; let __v_66: G = __loaded[17]; let __v_67: G = __loaded[18]; let __v_68: G = __loaded[19]; let __v_69: G = __loaded[20]; let __v_70: G = __loaded[21]; let __v_71: G = __loaded[22]; let __v_72: G = __loaded[23]; let __v_73: G = __loaded[24]; let __v_74: G = __loaded[25]; let __v_75: G = __loaded[26]; let __v_76: G = __loaded[27]; let __v_77: G = __loaded[28]; let __v_78: G = __loaded[29]; let __v_79: G = __loaded[30]; let __v_80: G = __loaded[31]; let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__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]; 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)? }, } } }; break '__mc_0 []; }, } }, 5u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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 __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_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: 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_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; let __v_52: G = __loaded[3]; let __v_53: G = __loaded[4]; let __v_54: G = __loaded[5]; let __v_55: G = __loaded[6]; let __v_56: G = __loaded[7]; let __v_57: G = __loaded[8]; let __v_58: G = __loaded[9]; let __v_59: G = __loaded[10]; let __v_60: G = __loaded[11]; let __v_61: G = __loaded[12]; let __v_62: G = __loaded[13]; let __v_63: G = __loaded[14]; let __v_64: G = __loaded[15]; let __v_65: G = __loaded[16]; let __v_66: G = __loaded[17]; let __v_67: G = __loaded[18]; let __v_68: G = __loaded[19]; let __v_69: G = __loaded[20]; let __v_70: G = __loaded[21]; let __v_71: G = __loaded[22]; let __v_72: G = __loaded[23]; let __v_73: G = __loaded[24]; let __v_74: G = __loaded[25]; let __v_75: G = __loaded[26]; let __v_76: G = __loaded[27]; let __v_77: G = __loaded[28]; let __v_78: G = __loaded[29]; let __v_79: G = __loaded[30]; let __v_80: G = __loaded[31]; let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__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]; 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)? }, } } }; break '__mc_0 []; }, } }, _ => { let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0]; 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)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_47, __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 __ret: [G; OUT_744] = []; record.function_queries[744].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_745: usize = 3; +const IN_745: usize = 3; +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 __loaded: [G; 3] = { let __base = 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 __ret: [G; OUT_745] = []; record.function_queries[745].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_2]; 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_6: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 1u64 => { 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_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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __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)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_5, __v_1, __v_8]; 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 __ret: [G; OUT_745] = []; record.function_queries[745].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +const INPUT_SIZE_746: usize = 1; +const IN_746: usize = 1; const OUT_746: usize = 3; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_746] = [__v_2, __v_2, __v_1]; record.function_queries[746].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); let __ret: [G; OUT_746] = [__v_4, __v_2, __v_3]; record.function_queries[746].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; 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_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_746] = [__v_3, __v_3, __v_2]; record.function_queries[746].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __ret: [G; OUT_746] = [__v_5, __v_3, __v_4]; record.function_queries[746].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_747: usize = 2; const IN_747: usize = 2; -const OUT_747: usize = 3; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_747] = [__v_2, __v_2, __v_1]; record.function_queries[747].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_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_747] = [__v_4, __v_4, __v_3]; record.function_queries[747].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_747] = [__v_4, __v_5, __v_3]; record.function_queries[747].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_747] = [__v_4, __v_5, __v_3]; record.function_queries[747].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } +const OUT_747: usize = 10; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_747] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_1]; record.function_queries[747].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_1]; 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_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_747] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; record.function_queries[747].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_748: usize = 2; const IN_748: usize = 2; const OUT_748: usize = 3; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_748] = [__v_2, __v_2, __v_1]; record.function_queries[748].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_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_748] = [__v_4, __v_4, __v_3]; record.function_queries[748].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_748] = [__v_4, __v_5, __v_3]; record.function_queries[748].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_748] = [__v_4, __v_5, __v_3]; record.function_queries[748].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_748] = [__v_4, __v_5, __v_3]; record.function_queries[748].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_749: usize = 9; -const IN_749: usize = 9; -const OUT_749: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_749] = [__v_11, __v_0]; record.function_queries[749].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_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_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_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_749] = { let __args: [G; IN_749] = [__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(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 __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_749] = [__v_39, __v_37]; record.function_queries[749].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_748] = [__v_2, __v_2, __v_1]; record.function_queries[748].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); let __ret: [G; OUT_748] = [__v_4, __v_2, __v_3]; record.function_queries[748].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_749: usize = 2; +const IN_749: usize = 2; +const OUT_749: usize = 3; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_749] = [__v_2, __v_2, __v_1]; record.function_queries[749].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); let __ret: [G; OUT_749] = [__v_4, __v_2, __v_3]; record.function_queries[749].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_750: usize = 2; const IN_750: usize = 2; const OUT_750: usize = 3; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_750] = [__v_2, __v_2, __v_1]; record.function_queries[750].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1]; 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_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_749] = { let __args: [G; IN_749] = [__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(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 __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_750] = [__v_13, __v_11, __v_12]; record.function_queries[750].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_751: usize = 1; -const IN_751: usize = 1; -const OUT_751: usize = 41; -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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; 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_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_746] = { let __args: [G; IN_746] = [__v_10, __v_9]; 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 __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_744] = { let __args: [G; IN_744] = [__v_11, __v_20]; 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 __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_744] = { let __args: [G; IN_744] = [__v_12, __v_30]; 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 __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_744] = { let __args: [G; IN_744] = [__v_13, __v_40]; 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 __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_744] = { let __args: [G; IN_744] = [__v_14, __v_50]; 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 __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_745] = { let __args: [G; IN_745] = [__v_15, __v_60]; 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 __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __ret: [G; OUT_751] = [__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[751].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_752: usize = 1; -const IN_752: usize = 1; -const OUT_752: usize = 49; -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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; 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_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_751] = { let __args: [G; IN_751] = [__v_9]; 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 __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_752] = [__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[752].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_753: usize = 9; -const IN_753: usize = 9; -const OUT_753: usize = 2; -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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_753] = [__v_11, __v_0]; record.function_queries[753].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_0]; 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 __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_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_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_753] = { let __args: [G; IN_753] = [__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(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_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_753] = [__v_70, __v_68]; record.function_queries[753].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_754: usize = 2; -const IN_754: usize = 2; -const OUT_754: usize = 3; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_754] = [__v_2, __v_2, __v_1]; record.function_queries[754].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1]; 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_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_753] = { let __args: [G; IN_753] = [__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(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]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); let __ret: [G; OUT_754] = [__v_13, __v_11, __v_12]; record.function_queries[754].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_750] = [__v_2, __v_2, __v_1]; record.function_queries[750].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_1]; 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_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_750] = [__v_4, __v_4, __v_3]; record.function_queries[750].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_750] = [__v_4, __v_5, __v_3]; record.function_queries[750].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_750] = [__v_4, __v_5, __v_3]; record.function_queries[750].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_751: usize = 2; +const IN_751: usize = 2; +const OUT_751: usize = 3; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_751] = [__v_2, __v_2, __v_1]; record.function_queries[751].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_1]; 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_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_751] = [__v_4, __v_4, __v_3]; record.function_queries[751].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_751] = [__v_4, __v_5, __v_3]; record.function_queries[751].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_751] = [__v_4, __v_5, __v_3]; record.function_queries[751].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_751] = [__v_4, __v_5, __v_3]; record.function_queries[751].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_752: usize = 9; +const IN_752: usize = 9; +const OUT_752: usize = 2; +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 = 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_752] = [__v_11, __v_0]; record.function_queries[752].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; 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 = __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_752] = { let __args: [G; IN_752] = [__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(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 __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_752] = [__v_39, __v_37]; record.function_queries[752].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_753: usize = 2; +const IN_753: usize = 2; +const OUT_753: usize = 3; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_753] = [__v_2, __v_2, __v_1]; record.function_queries[753].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_1]; 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_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_752] = { let __args: [G; IN_752] = [__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(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 __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_753] = [__v_13, __v_11, __v_12]; record.function_queries[753].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_754: usize = 1; +const IN_754: usize = 1; +const OUT_754: usize = 41; +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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __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_749] = { let __args: [G; IN_749] = [__v_10, __v_9]; 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 __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_747] = { let __args: [G; IN_747] = [__v_11, __v_20]; 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 __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_747] = { let __args: [G; IN_747] = [__v_12, __v_30]; 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 __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_747] = { let __args: [G; IN_747] = [__v_13, __v_40]; 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 __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_747] = { let __args: [G; IN_747] = [__v_14, __v_50]; 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 __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_748] = { let __args: [G; IN_748] = [__v_15, __v_60]; 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 __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __ret: [G; OUT_754] = [__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[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 = 55; -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_79] = { let __args: [G; IN_79] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; 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_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_747] = { let __args: [G; IN_747] = [__v_12, __v_11]; 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 __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_747] = { let __args: [G; IN_747] = [__v_13, __v_30]; 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 __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_744] = { let __args: [G; IN_744] = [__v_14, __v_33]; 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 __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_745] = { let __args: [G; IN_745] = [__v_15, __v_43]; 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 __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_745] = { let __args: [G; IN_745] = [__v_16, __v_46]; 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 __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_755] = [__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[755].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_12, __v_11]; 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 __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_744] = { let __args: [G; IN_744] = [__v_13, __v_30]; 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 __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_744] = { let __args: [G; IN_744] = [__v_14, __v_40]; 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 __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_744] = { let __args: [G; IN_744] = [__v_15, __v_50]; 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 __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_745] = { let __args: [G; IN_745] = [__v_16, __v_60]; 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 __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_754] = { let __args: [G; IN_754] = [__v_17, __v_63]; 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_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_755] = [__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[755].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_12, __v_11]; 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 __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_746] = { let __args: [G; IN_746] = [__v_13, __v_30]; 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 __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_744] = { let __args: [G; IN_744] = [__v_14, __v_33]; 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 __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_744] = { let __args: [G; IN_744] = [__v_15, __v_43]; 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 __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_744] = { let __args: [G; IN_744] = [__v_16, __v_53]; 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 __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_744] = { let __args: [G; IN_744] = [__v_17, __v_63]; 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 __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_744] = { let __args: [G; IN_744] = [__v_18, __v_73]; 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 __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_745] = { let __args: [G; IN_745] = [__v_19, __v_83]; 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 __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_750] = { let __args: [G; IN_750] = [__v_20, __v_86]; 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 __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_755] = [__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[755].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_756: usize = 1; -const IN_756: usize = 1; -const OUT_756: usize = 63; -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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; 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_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_755] = { let __args: [G; IN_755] = [__v_9]; 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_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_756] = [__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[756].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_757: usize = 9; -const IN_757: usize = 9; -const OUT_757: usize = 2; -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 __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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__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_757] = [__v_11, __v_0]; record.function_queries[757].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; 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_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_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_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_757] = { let __args: [G; IN_757] = [__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(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 __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_757] = [__v_84, __v_82]; record.function_queries[757].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const OUT_755: usize = 49; +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_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __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_754] = { let __args: [G; IN_754] = [__v_9]; 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_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_755] = [__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[755].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_756: usize = 9; +const IN_756: usize = 9; +const OUT_756: usize = 2; +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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_756] = [__v_11, __v_0]; record.function_queries[756].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_0]; 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_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_756] = { let __args: [G; IN_756] = [__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(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_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_756] = [__v_70, __v_68]; record.function_queries[756].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_757: usize = 2; +const IN_757: usize = 2; +const OUT_757: usize = 3; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_757] = [__v_2, __v_2, __v_1]; record.function_queries[757].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_1]; 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_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_756] = { let __args: [G; IN_756] = [__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(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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); let __ret: [G; OUT_757] = [__v_13, __v_11, __v_12]; record.function_queries[757].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_758: usize = 1; const IN_758: usize = 1; const OUT_758: usize = 55; -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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; 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_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_747] = { let __args: [G; IN_747] = [__v_12, __v_11]; 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 __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_747] = { let __args: [G; IN_747] = [__v_13, __v_30]; 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 __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_744] = { let __args: [G; IN_744] = [__v_14, __v_33]; 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 __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_745] = { let __args: [G; IN_745] = [__v_15, __v_43]; 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 __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_745] = { let __args: [G; IN_745] = [__v_16, __v_46]; 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 __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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_12, __v_11]; 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 __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_746] = { let __args: [G; IN_746] = [__v_13, __v_30]; 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 __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_744] = { let __args: [G; IN_744] = [__v_14, __v_33]; 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 __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_744] = { let __args: [G; IN_744] = [__v_15, __v_43]; 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 __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_744] = { let __args: [G; IN_744] = [__v_16, __v_53]; 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 __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_744] = { let __args: [G; IN_744] = [__v_17, __v_63]; 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 __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_744] = { let __args: [G; IN_744] = [__v_18, __v_73]; 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 __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_745] = { let __args: [G; IN_745] = [__v_19, __v_83]; 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 __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_750] = { let __args: [G; IN_750] = [__v_20, __v_86]; 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 __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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_12, __v_11]; 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 __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_744] = { let __args: [G; IN_744] = [__v_13, __v_30]; 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 __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_745] = { let __args: [G; IN_745] = [__v_14, __v_40]; 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 __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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_12, __v_11]; 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 __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_744] = { let __args: [G; IN_744] = [__v_13, __v_30]; 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 __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_745] = { let __args: [G; IN_745] = [__v_14, __v_40]; 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 __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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_12, __v_11]; 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 __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_744] = { let __args: [G; IN_744] = [__v_13, __v_37]; 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 __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_745] = { let __args: [G; IN_745] = [__v_14, __v_47]; 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 __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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_12, __v_11]; 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 __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_745] = { let __args: [G; IN_745] = [__v_13, __v_37]; 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 __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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_12, __v_11]; 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 __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_745] = { let __args: [G; IN_745] = [__v_13, __v_37]; 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 __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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_12, __v_11]; 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 __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_745] = { let __args: [G; IN_745] = [__v_13, __v_37]; 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 __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_758] = [__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[758].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_81] = { let __args: [G; IN_81] = [__v_11]; 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_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_757] = { let __args: [G; IN_757] = [__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(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 __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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __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_750] = { let __args: [G; IN_750] = [__v_12, __v_11]; 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 __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_750] = { let __args: [G; IN_750] = [__v_13, __v_30]; 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 __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_747] = { let __args: [G; IN_747] = [__v_14, __v_33]; 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 __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_748] = { let __args: [G; IN_748] = [__v_15, __v_43]; 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 __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_748] = { let __args: [G; IN_748] = [__v_16, __v_46]; 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 __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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_12, __v_11]; 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 __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_747] = { let __args: [G; IN_747] = [__v_13, __v_30]; 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 __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_747] = { let __args: [G; IN_747] = [__v_14, __v_40]; 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 __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_747] = { let __args: [G; IN_747] = [__v_15, __v_50]; 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 __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_748] = { let __args: [G; IN_748] = [__v_16, __v_60]; 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 __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_757] = { let __args: [G; IN_757] = [__v_17, __v_63]; 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 __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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_12, __v_11]; 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 __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_749] = { let __args: [G; IN_749] = [__v_13, __v_30]; 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 __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_747] = { let __args: [G; IN_747] = [__v_14, __v_33]; 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 __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_747] = { let __args: [G; IN_747] = [__v_15, __v_43]; 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 __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_747] = { let __args: [G; IN_747] = [__v_16, __v_53]; 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 __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_747] = { let __args: [G; IN_747] = [__v_17, __v_63]; 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 __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_747] = { let __args: [G; IN_747] = [__v_18, __v_73]; 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 __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_748] = { let __args: [G; IN_748] = [__v_19, __v_83]; 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 __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_753] = { let __args: [G; IN_753] = [__v_20, __v_86]; 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_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_758] = [__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[758].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_759: usize = 1; const IN_759: usize = 1; -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 __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_36] = { let __args: [G; IN_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_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 __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_21]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_759] = [__v_22]; record.function_queries[759].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_760: usize = 1; -const IN_760: usize = 1; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_760] = [__v_1]; record.function_queries[760].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_760] = [__v_1]; record.function_queries[760].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_760] = [__v_1]; record.function_queries[760].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_761: usize = 3; -const IN_761: usize = 3; -const OUT_761: usize = 0; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_761] = []; record.function_queries[761].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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_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_761] = []; 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 = 3; -const IN_762: usize = 3; -const OUT_762: usize = 0; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_762] = []; record.function_queries[762].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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_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_762] = []; 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 = 3; -const IN_763: usize = 3; -const OUT_763: usize = 0; -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]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_763] = []; record.function_queries[763].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_0]; 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 __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_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_763] = []; record.function_queries[763].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const OUT_759: usize = 63; +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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __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_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(758, (&__args[..]))?) { [G::ZERO; OUT_758] } else { let (__hash, __hit) = record.function_queries[758].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[758].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { (*(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758])) }; __ret }, _ => { aiur_fn_758::(__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_759] = [__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[759].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_760: usize = 9; +const IN_760: usize = 9; +const OUT_760: usize = 2; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_760] = [__v_11, __v_0]; record.function_queries[760].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_0]; 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_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_760] = { let __args: [G; IN_760] = [__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(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_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_760] = [__v_84, __v_82]; record.function_queries[760].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_761: usize = 1; +const IN_761: usize = 1; +const OUT_761: usize = 55; +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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __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_750] = { let __args: [G; IN_750] = [__v_12, __v_11]; 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 __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_750] = { let __args: [G; IN_750] = [__v_13, __v_30]; 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 __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_747] = { let __args: [G; IN_747] = [__v_14, __v_33]; 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 __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_748] = { let __args: [G; IN_748] = [__v_15, __v_43]; 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 __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_748] = { let __args: [G; IN_748] = [__v_16, __v_46]; 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 __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_761] = [__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[761].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_12, __v_11]; 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 __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_749] = { let __args: [G; IN_749] = [__v_13, __v_30]; 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 __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_747] = { let __args: [G; IN_747] = [__v_14, __v_33]; 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 __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_747] = { let __args: [G; IN_747] = [__v_15, __v_43]; 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 __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_747] = { let __args: [G; IN_747] = [__v_16, __v_53]; 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 __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_747] = { let __args: [G; IN_747] = [__v_17, __v_63]; 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 __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_747] = { let __args: [G; IN_747] = [__v_18, __v_73]; 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 __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_748] = { let __args: [G; IN_748] = [__v_19, __v_83]; 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 __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_753] = { let __args: [G; IN_753] = [__v_20, __v_86]; 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_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_761] = [__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[761].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_12, __v_11]; 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 __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_747] = { let __args: [G; IN_747] = [__v_13, __v_30]; 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 __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_748] = { let __args: [G; IN_748] = [__v_14, __v_40]; 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 __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_761] = [__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[761].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_12, __v_11]; 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 __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_747] = { let __args: [G; IN_747] = [__v_13, __v_30]; 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 __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_748] = { let __args: [G; IN_748] = [__v_14, __v_40]; 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 __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_761] = [__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[761].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_12, __v_11]; 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 __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_747] = { let __args: [G; IN_747] = [__v_13, __v_37]; 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 __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_748] = { let __args: [G; IN_748] = [__v_14, __v_47]; 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 __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_761] = [__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[761].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_12, __v_11]; 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 __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_748] = { let __args: [G; IN_748] = [__v_13, __v_37]; 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 __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_761] = [__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[761].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_12, __v_11]; 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 __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_748] = { let __args: [G; IN_748] = [__v_13, __v_37]; 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 __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_761] = [__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[761].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_12, __v_11]; 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 __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_748] = { let __args: [G; IN_748] = [__v_13, __v_37]; 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 __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_761] = [__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[761].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_84] = { let __args: [G; IN_84] = [__v_11]; 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_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_760] = { let __args: [G; IN_760] = [__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(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_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_761] = [__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[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 = 1; +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; 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_35] = { let __args: [G; IN_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_20]; 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_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_762] = [__v_22]; record.function_queries[762].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_763: usize = 1; +const IN_763: usize = 1; +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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_763] = [__v_1]; record.function_queries[763].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_763] = [__v_1]; record.function_queries[763].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_763] = [__v_1]; record.function_queries[763].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_764: usize = 3; const IN_764: usize = 3; const OUT_764: usize = 0; -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 = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_764] = []; record.function_queries[764].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_764] = []; record.function_queries[764].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_765: usize = 17; -const IN_765: usize = 17; +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 = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_764] = []; record.function_queries[764].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2]; 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_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_764] = []; record.function_queries[764].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_765: usize = 3; +const IN_765: usize = 3; const OUT_765: usize = 0; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_765] = []; record.function_queries[765].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_765] = []; record.function_queries[765].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +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 __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_765] = []; record.function_queries[765].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2]; 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_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_765] = []; record.function_queries[765].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_766: usize = 3; const IN_766: usize = 3; const OUT_766: usize = 0; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_766] = []; record.function_queries[766].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_766] = []; record.function_queries[766].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_766] = []; record.function_queries[766].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; 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 __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_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_766] = []; 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 = 3; const IN_767: usize = 3; const OUT_767: usize = 0; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_767] = []; record.function_queries[767].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_0]; 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_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_767] = []; 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 = 10; -const IN_768: usize = 10; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_767] = []; record.function_queries[767].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_767] = []; 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 = 17; +const IN_768: usize = 17; const OUT_768: usize = 0; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __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_768] = []; record.function_queries[768].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_767] = { let __args: [G; IN_767] = [__v_38, __v_40, __v_27]; 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 __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_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_768] = { let __args: [G; IN_768] = [__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(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 __ret: [G; OUT_768] = []; record.function_queries[768].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())); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_768] = []; record.function_queries[768].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_768] = []; record.function_queries[768].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } const INPUT_SIZE_769: usize = 3; const IN_769: usize = 3; const OUT_769: usize = 0; -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]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_769] = []; record.function_queries[769].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __ret: [G; OUT_769] = []; record.function_queries[769].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_770: usize = 49; -const IN_770: usize = 49; +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]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_769] = []; record.function_queries[769].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_769] = []; record.function_queries[769].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_770: usize = 3; +const IN_770: usize = 3; const OUT_770: usize = 0; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_794] = { let __args: [G; IN_794] = [__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(794, (&__args[..]))?) { [G::ZERO; OUT_794] } else { let (__hash, __hit) = record.function_queries[794].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[794].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[794].bump_multiplicity(__i); } let __ret: [G; OUT_794] = unsafe { (*(record.function_queries[794].output_at(__i).as_ptr() as *const [G; OUT_794])) }; __ret }, _ => { aiur_fn_794::(__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_764] = { let __args: [G; IN_764] = [__v_49, __v_9, __v_10]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_82, __v_47, __v_48]; 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 __ret: [G; OUT_770] = []; record.function_queries[770].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_771: usize = 2; -const IN_771: usize = 2; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_770] = []; record.function_queries[770].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_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_770] = []; 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 = 10; +const IN_771: usize = 10; const OUT_771: usize = 0; -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 __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_771] = []; record.function_queries[771].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__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(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 __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_51]; 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 __ret: [G; OUT_771] = []; record.function_queries[771].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __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_771] = []; record.function_queries[771].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_770] = { let __args: [G; IN_770] = [__v_38, __v_40, __v_27]; 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 __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_771] = { let __args: [G; IN_771] = [__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(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 __ret: [G; OUT_771] = []; record.function_queries[771].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_772: usize = 3; const IN_772: usize = 3; const OUT_772: usize = 0; -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]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_772] = []; record.function_queries[772].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; 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 __ret: [G; OUT_772] = []; record.function_queries[772].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_773: usize = 99; -const IN_773: usize = 99; +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]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_772] = []; record.function_queries[772].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__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(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 __ret: [G; OUT_772] = []; record.function_queries[772].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_773: usize = 49; +const IN_773: usize = 49; const OUT_773: usize = 0; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_761] = { let __args: [G; IN_761] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_48, __v_49]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_11, __v_59, __v_60]; 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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_12, __v_61, __v_62]; 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 __ret: [G; OUT_773] = []; record.function_queries[773].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_764] = { let __args: [G; IN_764] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_26, __v_75, __v_76]; 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 __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_27, __v_77, __v_78]; 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 __ret: [G; OUT_773] = []; record.function_queries[773].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_764] = { let __args: [G; IN_764] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2, __v_48, __v_49]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_43, __v_95, __v_96]; 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 __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_44, __v_97, __v_98]; 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 __ret: [G; OUT_773] = []; record.function_queries[773].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())); }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_797] = { let __args: [G; IN_797] = [__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(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__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_767] = { let __args: [G; IN_767] = [__v_49, __v_9, __v_10]; 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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_82, __v_47, __v_48]; 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 __ret: [G; OUT_773] = []; record.function_queries[773].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_774: usize = 2; const IN_774: usize = 2; const OUT_774: usize = 0; -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 __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_774] = []; record.function_queries[774].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__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(791, (&__args[..]))?) { [G::ZERO; OUT_791] } else { let (__hash, __hit) = record.function_queries[791].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[791].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { (*(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791])) }; __ret }, _ => { aiur_fn_791::(__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_773] = { let __args: [G; IN_773] = [__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(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 __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_65]; 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 __ret: [G; OUT_774] = []; record.function_queries[774].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_775: usize = 55; -const IN_775: usize = 55; +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 __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_774] = []; record.function_queries[774].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__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(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 __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_51]; 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 __ret: [G; OUT_774] = []; record.function_queries[774].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_775: usize = 3; +const IN_775: usize = 3; const OUT_775: usize = 0; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_290] = { let __args: [G; IN_290] = [__v_0]; 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_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_761] = { let __args: [G; IN_761] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_57, __v_4, __v_5]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_66, __v_15, __v_16]; 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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_67, __v_17, __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 __ret: [G; OUT_775] = []; record.function_queries[775].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_764] = { let __args: [G; IN_764] = [__v_56, __v_2, __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 __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_57, __v_4, __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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_98, __v_51, __v_52]; 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 __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_99, __v_53, __v_54]; 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 __ret: [G; OUT_775] = []; record.function_queries[775].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_764] = { let __args: [G; IN_764] = [__v_56, __v_2, __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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_775] = []; record.function_queries[775].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_763] = { let __args: [G; IN_763] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_775] = []; record.function_queries[775].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_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_72, __v_20, __v_21]; 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 __ret: [G; OUT_775] = []; record.function_queries[775].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_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_775] = []; record.function_queries[775].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_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_775] = []; record.function_queries[775].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_765] = { let __args: [G; IN_765] = [__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(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 __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_775] = []; record.function_queries[775].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_774] = { let __args: [G; IN_774] = [__v_56, __v_2]; 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 __ret: [G; OUT_775] = []; record.function_queries[775].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_776: usize = 2; -const IN_776: usize = 2; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_775] = []; record.function_queries[775].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_2]; 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 __ret: [G; OUT_775] = []; 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 = 99; +const IN_776: usize = 99; const OUT_776: usize = 0; -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]; let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_2]; 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_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_776] = []; record.function_queries[776].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_777: usize = 8; -const IN_777: usize = 8; +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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_764] = { let __args: [G; IN_764] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_2, __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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_59, __v_60]; 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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_12, __v_61, __v_62]; 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 __ret: [G; OUT_776] = []; record.function_queries[776].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_767] = { let __args: [G; IN_767] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_26, __v_75, __v_76]; 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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_27, __v_77, __v_78]; 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 __ret: [G; OUT_776] = []; record.function_queries[776].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_767] = { let __args: [G; IN_767] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_48, __v_49]; 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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_43, __v_95, __v_96]; 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 __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_44, __v_97, __v_98]; 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 __ret: [G; OUT_776] = []; record.function_queries[776].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_777: usize = 2; +const IN_777: usize = 2; const OUT_777: usize = 0; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = 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_27] = { let __args: [G; IN_27] = [__v_11, __v_44, __v_8, __v_8, __v_45, __v_46, __v_47]; 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_48: G = __r_arr[0]; 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 __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 = G::from_u64(65536); let __v_84: G = (__v_83 * __v_51); let __v_85: G = G::from_u64(16777216); let __v_86: G = (__v_85 * __v_52); let __v_87: G = (__v_84 + __v_86); let __v_88: G = (__v_82 + __v_87); let __v_89: G = (__v_49 + __v_88); let __v_90: G = (__v_81 * __v_54); let __v_91: G = (__v_83 * __v_55); let __v_92: G = (__v_85 * __v_56); let __v_93: G = (__v_91 + __v_92); let __v_94: G = (__v_90 + __v_93); let __v_95: G = (__v_53 + __v_94); let __v_96: G = (__v_81 * __v_58); let __v_97: G = (__v_83 * __v_59); let __v_98: G = (__v_85 * __v_60); let __v_99: G = (__v_97 + __v_98); let __v_100: G = (__v_96 + __v_99); let __v_101: G = (__v_57 + __v_100); let __v_102: G = (__v_81 * __v_62); let __v_103: G = (__v_83 * __v_63); let __v_104: G = (__v_85 * __v_64); let __v_105: G = (__v_103 + __v_104); let __v_106: G = (__v_102 + __v_105); let __v_107: G = (__v_61 + __v_106); let __v_108: G = (__v_81 * __v_66); let __v_109: G = (__v_83 * __v_67); let __v_110: G = (__v_85 * __v_68); let __v_111: G = (__v_109 + __v_110); let __v_112: G = (__v_108 + __v_111); let __v_113: G = (__v_65 + __v_112); let __v_114: G = (__v_81 * __v_70); let __v_115: G = (__v_83 * __v_71); let __v_116: G = (__v_85 * __v_72); let __v_117: G = (__v_115 + __v_116); let __v_118: G = (__v_114 + __v_117); let __v_119: G = (__v_69 + __v_118); let __v_120: G = (__v_81 * __v_74); let __v_121: G = (__v_83 * __v_75); let __v_122: G = (__v_85 * __v_76); let __v_123: G = (__v_121 + __v_122); let __v_124: G = (__v_120 + __v_123); let __v_125: G = (__v_73 + __v_124); let __v_126: G = (__v_81 * __v_78); let __v_127: G = (__v_83 * __v_79); let __v_128: G = (__v_85 * __v_80); let __v_129: G = (__v_127 + __v_128); let __v_130: G = (__v_126 + __v_129); let __v_131: G = (__v_77 + __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_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_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 tag4 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: tag4 size exceeds a single byte".to_string()) }); } let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_141]; 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_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = G::from_u64(3); 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_79] = { let __args: [G; IN_79] = [__v_149]; 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_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; match __v_133.as_canonical_u64() { 4u64 => { let __v_153: G = G::from_u64(1); 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_96] = { let __args: [G; IN_96] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_155]; 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 __v_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __v_158: 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_158.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_159: G = __loaded[0]; let __v_160: G = __loaded[1]; let __v_161: G = __loaded[2]; if (__v_159 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_160 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_161 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_161.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } match __v_156.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_154]; 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 __ret: [G; OUT_777] = []; record.function_queries[777].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_157]; 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_162: G = __r_arr[0]; let __v_163: G = G::from_u64(1); let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_162, __v_163, __v_163, __v_163, __v_163, __v_163, __v_163]; 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_164: G = __r_arr[0]; let __v_165: G = __r_arr[1]; let __v_166: G = __r_arr[2]; let __v_167: G = __r_arr[3]; let __v_168: G = __r_arr[4]; let __v_169: G = __r_arr[5]; let __v_170: G = G::from_u64(0); let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_154, __v_163, __v_163, __v_163, __v_163, __v_163, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170]; 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 __ret: [G; OUT_777] = []; record.function_queries[777].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_156.as_canonical_u64())); }, } }, 5u64 => { let __v_153: G = G::from_u64(1); 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_96] = { let __args: [G; IN_96] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_155]; 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 __v_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __v_158: 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_158.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_159: G = __loaded[0]; let __v_160: G = __loaded[1]; let __v_161: G = __loaded[2]; if (__v_159 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_160 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_161 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_161.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_154, __v_156, __v_157]; 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 __ret: [G; OUT_777] = []; record.function_queries[777].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_96] = { let __args: [G; IN_96] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_155]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(758, (&__args[..]))?) { [G::ZERO; OUT_758] } else { let (__hash, __hit) = record.function_queries[758].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[758].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { (*(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758])) }; __ret }, _ => { aiur_fn_758::(__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_775] = { let __args: [G; IN_775] = [__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(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 __ret: [G; OUT_777] = []; record.function_queries[777].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_96] = { let __args: [G; IN_96] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_155]; 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_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_776] = { let __args: [G; IN_776] = [__v_154, __v_156]; 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 __ret: [G; OUT_777] = []; record.function_queries[777].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_777] = []; record.function_queries[777].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); }, } }) } -const INPUT_SIZE_778: usize = 8; -const IN_778: usize = 8; +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]; 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_777] = []; record.function_queries[777].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__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(794, (&__args[..]))?) { [G::ZERO; OUT_794] } else { let (__hash, __hit) = record.function_queries[794].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[794].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[794].bump_multiplicity(__i); } let __ret: [G; OUT_794] = unsafe { (*(record.function_queries[794].output_at(__i).as_ptr() as *const [G; OUT_794])) }; __ret }, _ => { aiur_fn_794::(__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_776] = { let __args: [G; IN_776] = [__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(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 __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_65]; 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 __ret: [G; OUT_777] = []; record.function_queries[777].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_778: usize = 55; +const IN_778: usize = 55; const OUT_778: usize = 0; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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 __ret: [G; OUT_778] = []; record.function_queries[778].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_779: usize = 3; -const IN_779: usize = 3; -const OUT_779: usize = 1; -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 __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_779] = [__v_2]; record.function_queries[779].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_779] = [__v_5]; record.function_queries[779].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_780: usize = 2; -const IN_780: usize = 2; -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 __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_780] = [__v_8]; record.function_queries[780].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4, __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_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_780] = [__v_7]; record.function_queries[780].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_781: usize = 1; -const IN_781: usize = 1; -const OUT_781: usize = 8; -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 __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_781] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; record.function_queries[781].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_10]; 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_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_17] = { let __args: [G; IN_17] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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 __ret: [G; OUT_781] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[781].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_782: usize = 2; -const IN_782: usize = 2; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_293] = { let __args: [G; IN_293] = [__v_0]; 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_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_764] = { let __args: [G; IN_764] = [__v_56, __v_2, __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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_57, __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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_66, __v_15, __v_16]; 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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_67, __v_17, __v_18]; 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 __ret: [G; OUT_778] = []; record.function_queries[778].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_767] = { let __args: [G; IN_767] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_57, __v_4, __v_5]; 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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_98, __v_51, __v_52]; 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 __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_99, __v_53, __v_54]; 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 __ret: [G; OUT_778] = []; record.function_queries[778].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_767] = { let __args: [G; IN_767] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_778] = []; record.function_queries[778].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_766] = { let __args: [G; IN_766] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_778] = []; record.function_queries[778].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_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_72, __v_20, __v_21]; 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 __ret: [G; OUT_778] = []; record.function_queries[778].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_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_778] = []; record.function_queries[778].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_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_778] = []; record.function_queries[778].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_768] = { let __args: [G; IN_768] = [__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(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 __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_778] = []; record.function_queries[778].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_777] = { let __args: [G; IN_777] = [__v_56, __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 __ret: [G; OUT_778] = []; record.function_queries[778].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_779: usize = 2; +const IN_779: usize = 2; +const OUT_779: usize = 0; +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 __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_2: G = __r_arr[0]; let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1, __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_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_779] = []; record.function_queries[779].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_780: usize = 8; +const IN_780: usize = 8; +const OUT_780: usize = 0; +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = 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 = G::from_u64(65536); let __v_84: G = (__v_83 * __v_51); let __v_85: G = G::from_u64(16777216); let __v_86: G = (__v_85 * __v_52); let __v_87: G = (__v_84 + __v_86); let __v_88: G = (__v_82 + __v_87); let __v_89: G = (__v_49 + __v_88); let __v_90: G = (__v_81 * __v_54); let __v_91: G = (__v_83 * __v_55); let __v_92: G = (__v_85 * __v_56); let __v_93: G = (__v_91 + __v_92); let __v_94: G = (__v_90 + __v_93); let __v_95: G = (__v_53 + __v_94); let __v_96: G = (__v_81 * __v_58); let __v_97: G = (__v_83 * __v_59); let __v_98: G = (__v_85 * __v_60); let __v_99: G = (__v_97 + __v_98); let __v_100: G = (__v_96 + __v_99); let __v_101: G = (__v_57 + __v_100); let __v_102: G = (__v_81 * __v_62); let __v_103: G = (__v_83 * __v_63); let __v_104: G = (__v_85 * __v_64); let __v_105: G = (__v_103 + __v_104); let __v_106: G = (__v_102 + __v_105); let __v_107: G = (__v_61 + __v_106); let __v_108: G = (__v_81 * __v_66); let __v_109: G = (__v_83 * __v_67); let __v_110: G = (__v_85 * __v_68); let __v_111: G = (__v_109 + __v_110); let __v_112: G = (__v_108 + __v_111); let __v_113: G = (__v_65 + __v_112); let __v_114: G = (__v_81 * __v_70); let __v_115: G = (__v_83 * __v_71); let __v_116: G = (__v_85 * __v_72); let __v_117: G = (__v_115 + __v_116); let __v_118: G = (__v_114 + __v_117); let __v_119: G = (__v_69 + __v_118); let __v_120: G = (__v_81 * __v_74); let __v_121: G = (__v_83 * __v_75); let __v_122: G = (__v_85 * __v_76); let __v_123: G = (__v_121 + __v_122); let __v_124: G = (__v_120 + __v_123); let __v_125: G = (__v_73 + __v_124); let __v_126: G = (__v_81 * __v_78); let __v_127: G = (__v_83 * __v_79); let __v_128: G = (__v_85 * __v_80); let __v_129: G = (__v_127 + __v_128); let __v_130: G = (__v_126 + __v_129); let __v_131: G = (__v_77 + __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_82] = { let __args: [G; IN_82] = [__v_11]; 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_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_80] = { let __args: [G; IN_80] = [__v_141]; 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_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_80] = { let __args: [G; IN_80] = [__v_149]; 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_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; match __v_133.as_canonical_u64() { 4u64 => { let __v_153: G = G::from_u64(1); 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_99] = { let __args: [G; IN_99] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_155]; 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 __v_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __v_158: 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_158.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_159: G = __loaded[0]; let __v_160: G = __loaded[1]; let __v_161: G = __loaded[2]; if (__v_159 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_160 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_161 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_161.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } match __v_156.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_154]; 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 __ret: [G; OUT_780] = []; record.function_queries[780].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_157]; 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_162: G = __r_arr[0]; let __v_163: G = G::from_u64(1); let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_162, __v_163, __v_163, __v_163, __v_163, __v_163, __v_163]; 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 __v_164: G = __r_arr[0]; let __v_165: G = __r_arr[1]; let __v_166: G = __r_arr[2]; let __v_167: G = __r_arr[3]; let __v_168: G = __r_arr[4]; let __v_169: G = __r_arr[5]; let __v_170: G = G::from_u64(0); let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_154, __v_163, __v_163, __v_163, __v_163, __v_163, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170]; 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 __ret: [G; OUT_780] = []; record.function_queries[780].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_156.as_canonical_u64())); }, } }, 5u64 => { let __v_153: G = G::from_u64(1); 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_99] = { let __args: [G; IN_99] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_155]; 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 __v_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __v_158: 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_158.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_159: G = __loaded[0]; let __v_160: G = __loaded[1]; let __v_161: G = __loaded[2]; if (__v_159 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_160 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_161 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_161.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_154, __v_156, __v_157]; 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_780] = []; record.function_queries[780].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_99] = { let __args: [G; IN_99] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_155]; 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_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_778] = { let __args: [G; IN_778] = [__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(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 __ret: [G; OUT_780] = []; record.function_queries[780].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_99] = { let __args: [G; IN_99] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_155]; 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_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_779] = { let __args: [G; IN_779] = [__v_154, __v_156]; 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 __ret: [G; OUT_780] = []; record.function_queries[780].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_780] = []; record.function_queries[780].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); }, } }) } +const INPUT_SIZE_781: usize = 8; +const IN_781: usize = 8; +const OUT_781: usize = 0; +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_780] = { let __args: [G; IN_780] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __ret: [G; OUT_781] = []; record.function_queries[781].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +const INPUT_SIZE_782: usize = 3; +const IN_782: usize = 3; const OUT_782: usize = 1; -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 __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() { 1u64 => { let __ret: [G; OUT_782] = [__v_1]; record.function_queries[782].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_5, __v_1]; 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_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_782] = [__v_8]; 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 = 1; -const IN_783: usize = 1; -const OUT_783: usize = 8; -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 __loaded: [G; 3] = { let __base = 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_783] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; record.function_queries[783].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_3]; 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_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_17] = { let __args: [G; IN_17] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; 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 __ret: [G; OUT_783] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; record.function_queries[783].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_784: usize = 8; -const IN_784: usize = 8; -const OUT_784: usize = 1; -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]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_784] = [__v_7]; record.function_queries[784].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_784] = { let __args: [G; IN_784] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_784] = [__v_21]; record.function_queries[784].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_784] = [__v_4]; record.function_queries[784].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_784] = [__v_22]; record.function_queries[784].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_785: usize = 1; -const IN_785: usize = 1; +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 __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_782] = [__v_2]; record.function_queries[782].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_782] = [__v_5]; record.function_queries[782].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +const INPUT_SIZE_783: usize = 2; +const IN_783: usize = 2; +const OUT_783: usize = 1; +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 __loaded: [G; 3] = { let __base = 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_783] = [__v_8]; record.function_queries[783].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_4, __v_1]; 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_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_783] = [__v_7]; record.function_queries[783].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_784: usize = 1; +const IN_784: usize = 1; +const OUT_784: usize = 8; +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 __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_784] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; record.function_queries[784].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_10]; 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_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_784] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[784].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_785: usize = 2; +const IN_785: usize = 2; const OUT_785: usize = 1; -fn aiur_fn_785(inp: [G; IN_785], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_785], ExecError> { stacker::maybe_grow((64 * 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_803] = { let __args: [G; IN_803] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(803, (&__args[..]))?) { [G::ZERO; OUT_803] } else { let (__hash, __hit) = record.function_queries[803].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[803].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[803].bump_multiplicity(__i); } let __ret: [G; OUT_803] = unsafe { (*(record.function_queries[803].output_at(__i).as_ptr() as *const [G; OUT_803])) }; __ret }, _ => { aiur_fn_803::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_785] = [__v_3]; record.function_queries[785].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_786: usize = 2; -const IN_786: usize = 2; -const OUT_786: usize = 1; -fn aiur_fn_786(inp: [G; IN_786], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_786], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 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_786] = [__v_1]; record.function_queries[786].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__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_786] = [__v_7]; record.function_queries[786].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_787: usize = 1; -const IN_787: usize = 1; +fn aiur_fn_785(inp: [G; IN_785], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_785], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 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() { 1u64 => { let __ret: [G; OUT_785] = [__v_1]; record.function_queries[785].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(785, (&__args[..]))?) { [G::ZERO; OUT_785] } else { let (__hash, __hit) = record.function_queries[785].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[785].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { (*(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785])) }; __ret }, _ => { aiur_fn_785::(__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_785] = [__v_8]; record.function_queries[785].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_786: usize = 1; +const IN_786: usize = 1; +const OUT_786: usize = 8; +fn aiur_fn_786(inp: [G; IN_786], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_786], ExecError> { stacker::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_786] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; record.function_queries[786].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(786, (&__args[..]))?) { [G::ZERO; OUT_786] } else { let (__hash, __hit) = record.function_queries[786].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[786].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { (*(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786])) }; __ret }, _ => { aiur_fn_786::(__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_786] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; record.function_queries[786].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_787: usize = 8; +const IN_787: usize = 8; const OUT_787: usize = 1; -fn aiur_fn_787(inp: [G; IN_787], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_787], ExecError> { stacker::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_787] = [__v_4]; record.function_queries[787].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__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_787] = [__v_6]; record.function_queries[787].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_787(inp: [G; IN_787], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_787], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; 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_787] = [__v_7]; record.function_queries[787].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_787] = { let __args: [G; IN_787] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_787] = [__v_21]; record.function_queries[787].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_787] = [__v_4]; record.function_queries[787].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(787, (&__args[..]))?) { [G::ZERO; OUT_787] } else { let (__hash, __hit) = record.function_queries[787].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[787].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { (*(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787])) }; __ret }, _ => { aiur_fn_787::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_787] = [__v_22]; record.function_queries[787].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_788: usize = 1; const IN_788: usize = 1; -const OUT_788: usize = 8; -fn aiur_fn_788(inp: [G; IN_788], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_788], ExecError> { stacker::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_788] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; record.function_queries[788].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(788, (&__args[..]))?) { [G::ZERO; OUT_788] } else { let (__hash, __hit) = record.function_queries[788].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[788].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { (*(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788])) }; __ret }, _ => { aiur_fn_788::(__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_17] = { let __args: [G; IN_17] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; 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 __ret: [G; OUT_788] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; record.function_queries[788].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const OUT_788: usize = 1; +fn aiur_fn_788(inp: [G; IN_788], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_788], ExecError> { stacker::maybe_grow((64 * 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_806] = { let __args: [G; IN_806] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(806, (&__args[..]))?) { [G::ZERO; OUT_806] } else { let (__hash, __hit) = record.function_queries[806].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[806].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[806].bump_multiplicity(__i); } let __ret: [G; OUT_806] = unsafe { (*(record.function_queries[806].output_at(__i).as_ptr() as *const [G; OUT_806])) }; __ret }, _ => { aiur_fn_806::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_788] = [__v_3]; record.function_queries[788].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_789: usize = 2; const IN_789: usize = 2; const OUT_789: usize = 1; -fn aiur_fn_789(inp: [G; IN_789], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_789], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 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_798] = { let __args: [G; IN_798] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_789] = [__v_4]; record.function_queries[789].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_789(inp: [G; IN_789], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_789], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 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_789] = [__v_1]; record.function_queries[789].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(789, (&__args[..]))?) { [G::ZERO; OUT_789] } else { let (__hash, __hit) = record.function_queries[789].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[789].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { (*(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789])) }; __ret }, _ => { aiur_fn_789::(__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_789] = [__v_7]; record.function_queries[789].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_790: usize = 1; const IN_790: usize = 1; const OUT_790: usize = 1; -fn aiur_fn_790(inp: [G; IN_790], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_790], ExecError> { stacker::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_790] = [__v_11]; record.function_queries[790].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_790] = [__v_13]; record.function_queries[790].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_791: usize = 9; -const IN_791: usize = 9; -const OUT_791: usize = 45; -fn aiur_fn_791(inp: [G; IN_791], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_791], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_791] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[791].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_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_791] = { let __args: [G; IN_791] = [__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(791, (&__args[..]))?) { [G::ZERO; OUT_791] } else { let (__hash, __hit) = record.function_queries[791].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[791].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { (*(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791])) }; __ret }, _ => { aiur_fn_791::(__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_791] = [__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[791].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_792: usize = 1; -const IN_792: usize = 1; -const OUT_792: usize = 8; -fn aiur_fn_792(inp: [G; IN_792], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_792], ExecError> { stacker::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_792] = [__v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; record.function_queries[792].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(792, (&__args[..]))?) { [G::ZERO; OUT_792] } else { let (__hash, __hit) = record.function_queries[792].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[792].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { (*(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792])) }; __ret }, _ => { aiur_fn_792::(__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_17] = { let __args: [G; IN_17] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; 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 __ret: [G; OUT_792] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; record.function_queries[792].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_790(inp: [G; IN_790], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_790], ExecError> { stacker::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_790] = [__v_4]; record.function_queries[790].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(790, (&__args[..]))?) { [G::ZERO; OUT_790] } else { let (__hash, __hit) = record.function_queries[790].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[790].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { (*(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790])) }; __ret }, _ => { aiur_fn_790::(__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_790] = [__v_6]; record.function_queries[790].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_791: usize = 1; +const IN_791: usize = 1; +const OUT_791: usize = 8; +fn aiur_fn_791(inp: [G; IN_791], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_791], ExecError> { stacker::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_791] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; record.function_queries[791].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(791, (&__args[..]))?) { [G::ZERO; OUT_791] } else { let (__hash, __hit) = record.function_queries[791].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[791].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { (*(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791])) }; __ret }, _ => { aiur_fn_791::(__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_791] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; record.function_queries[791].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_792: usize = 2; +const IN_792: usize = 2; +const OUT_792: usize = 1; +fn aiur_fn_792(inp: [G; IN_792], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_792], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 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_801] = { let __args: [G; IN_801] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_792] = [__v_4]; record.function_queries[792].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_793: usize = 1; const IN_793: usize = 1; -const OUT_793: usize = 8; -fn aiur_fn_793(inp: [G; IN_793], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_793], ExecError> { stacker::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_793] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; record.function_queries[793].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(793, (&__args[..]))?) { [G::ZERO; OUT_793] } else { let (__hash, __hit) = record.function_queries[793].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[793].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[793].bump_multiplicity(__i); } let __ret: [G; OUT_793] = unsafe { (*(record.function_queries[793].output_at(__i).as_ptr() as *const [G; OUT_793])) }; __ret }, _ => { aiur_fn_793::(__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_17] = { let __args: [G; IN_17] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; 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 __ret: [G; OUT_793] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; record.function_queries[793].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const OUT_793: usize = 1; +fn aiur_fn_793(inp: [G; IN_793], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_793], ExecError> { stacker::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_793] = [__v_11]; record.function_queries[793].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(793, (&__args[..]))?) { [G::ZERO; OUT_793] } else { let (__hash, __hit) = record.function_queries[793].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[793].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[793].bump_multiplicity(__i); } let __ret: [G; OUT_793] = unsafe { (*(record.function_queries[793].output_at(__i).as_ptr() as *const [G; OUT_793])) }; __ret }, _ => { aiur_fn_793::(__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_793] = [__v_13]; record.function_queries[793].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_794: usize = 9; const IN_794: usize = 9; -const OUT_794: usize = 34; -fn aiur_fn_794(inp: [G; IN_794], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_794], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_7] = { let __args: [G; IN_7] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(7, (&__args[..]))?) { [G::ZERO; OUT_7] } else { let (__hash, __hit) = record.function_queries[7].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[7].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[7].bump_multiplicity(__i); } let __ret: [G; OUT_7] = unsafe { (*(record.function_queries[7].output_at(__i).as_ptr() as *const [G; OUT_7])) }; __ret }, _ => { aiur_fn_7::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_794] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[794].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_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_794] = { let __args: [G; IN_794] = [__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(794, (&__args[..]))?) { [G::ZERO; OUT_794] } else { let (__hash, __hit) = record.function_queries[794].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[794].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[794].bump_multiplicity(__i); } let __ret: [G; OUT_794] = unsafe { (*(record.function_queries[794].output_at(__i).as_ptr() as *const [G; OUT_794])) }; __ret }, _ => { aiur_fn_794::(__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_794] = [__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[794].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 OUT_794: usize = 45; +fn aiur_fn_794(inp: [G; IN_794], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_794], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_794] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[794].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_794] = { let __args: [G; IN_794] = [__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(794, (&__args[..]))?) { [G::ZERO; OUT_794] } else { let (__hash, __hit) = record.function_queries[794].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[794].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[794].bump_multiplicity(__i); } let __ret: [G; OUT_794] = unsafe { (*(record.function_queries[794].output_at(__i).as_ptr() as *const [G; OUT_794])) }; __ret }, _ => { aiur_fn_794::(__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_794] = [__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[794].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_795: usize = 1; const IN_795: usize = 1; -const OUT_795: usize = 1; -fn aiur_fn_795(inp: [G; IN_795], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_795], ExecError> { stacker::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_795] = [__v_4]; record.function_queries[795].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_795] = [__v_4]; record.function_queries[795].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_796: usize = 5; -const IN_796: usize = 5; -const OUT_796: usize = 1; -fn aiur_fn_796(inp: [G; IN_796], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_796], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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_796] = [__v_14]; record.function_queries[796].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(796, (&__args[..]))?) { [G::ZERO; OUT_796] } else { let (__hash, __hit) = record.function_queries[796].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[796].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[796].bump_multiplicity(__i); } let __ret: [G; OUT_796] = unsafe { (*(record.function_queries[796].output_at(__i).as_ptr() as *const [G; OUT_796])) }; __ret }, _ => { aiur_fn_796::(__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_796] = [__v_13]; record.function_queries[796].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_797: usize = 2; -const IN_797: usize = 2; -const OUT_797: usize = 1; -fn aiur_fn_797(inp: [G; IN_797], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_797], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 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_797] = [__v_3]; record.function_queries[797].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_797] = { let __args: [G; IN_797] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__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_797] = [__v_9]; record.function_queries[797].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_798: usize = 2; -const IN_798: usize = 2; +const OUT_795: usize = 8; +fn aiur_fn_795(inp: [G; IN_795], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_795], ExecError> { stacker::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_795] = [__v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; record.function_queries[795].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(795, (&__args[..]))?) { [G::ZERO; OUT_795] } else { let (__hash, __hit) = record.function_queries[795].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[795].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[795].bump_multiplicity(__i); } let __ret: [G; OUT_795] = unsafe { (*(record.function_queries[795].output_at(__i).as_ptr() as *const [G; OUT_795])) }; __ret }, _ => { aiur_fn_795::(__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_795] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; record.function_queries[795].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_796: usize = 1; +const IN_796: usize = 1; +const OUT_796: usize = 8; +fn aiur_fn_796(inp: [G; IN_796], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_796], ExecError> { stacker::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_796] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; record.function_queries[796].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(796, (&__args[..]))?) { [G::ZERO; OUT_796] } else { let (__hash, __hit) = record.function_queries[796].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[796].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[796].bump_multiplicity(__i); } let __ret: [G; OUT_796] = unsafe { (*(record.function_queries[796].output_at(__i).as_ptr() as *const [G; OUT_796])) }; __ret }, _ => { aiur_fn_796::(__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_796] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; record.function_queries[796].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_797: usize = 9; +const IN_797: usize = 9; +const OUT_797: usize = 34; +fn aiur_fn_797(inp: [G; IN_797], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_797], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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_797] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[797].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_797] = { let __args: [G; IN_797] = [__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(797, (&__args[..]))?) { [G::ZERO; OUT_797] } else { let (__hash, __hit) = record.function_queries[797].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[797].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { (*(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797])) }; __ret }, _ => { aiur_fn_797::(__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_797] = [__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[797].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_798: usize = 1; +const IN_798: usize = 1; const OUT_798: usize = 1; -fn aiur_fn_798(inp: [G; IN_798], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_798], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 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_798] = [__v_0]; record.function_queries[798].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_798] = { let __args: [G; IN_798] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(798, (&__args[..]))?) { [G::ZERO; OUT_798] } else { let (__hash, __hit) = record.function_queries[798].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[798].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { (*(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798])) }; __ret }, _ => { aiur_fn_798::(__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_798] = [__v_7]; record.function_queries[798].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_799: usize = 1; -const IN_799: usize = 1; +fn aiur_fn_798(inp: [G; IN_798], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_798], ExecError> { stacker::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_798] = [__v_4]; record.function_queries[798].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_798] = [__v_4]; record.function_queries[798].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_799: usize = 5; +const IN_799: usize = 5; const OUT_799: usize = 1; -fn aiur_fn_799(inp: [G; IN_799], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_799], ExecError> { stacker::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_799] = [__v_6]; record.function_queries[799].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(799, (&__args[..]))?) { [G::ZERO; OUT_799] } else { let (__hash, __hit) = record.function_queries[799].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[799].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[799].bump_multiplicity(__i); } let __ret: [G; OUT_799] = unsafe { (*(record.function_queries[799].output_at(__i).as_ptr() as *const [G; OUT_799])) }; __ret }, _ => { aiur_fn_799::(__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_799] = [__v_8]; record.function_queries[799].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_800: usize = 1; -const IN_800: usize = 1; +fn aiur_fn_799(inp: [G; IN_799], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_799], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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_799] = [__v_14]; record.function_queries[799].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(799, (&__args[..]))?) { [G::ZERO; OUT_799] } else { let (__hash, __hit) = record.function_queries[799].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[799].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[799].bump_multiplicity(__i); } let __ret: [G; OUT_799] = unsafe { (*(record.function_queries[799].output_at(__i).as_ptr() as *const [G; OUT_799])) }; __ret }, _ => { aiur_fn_799::(__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_799] = [__v_13]; record.function_queries[799].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +const INPUT_SIZE_800: usize = 2; +const IN_800: usize = 2; const OUT_800: usize = 1; -fn aiur_fn_800(inp: [G; IN_800], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_800], ExecError> { stacker::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_800] = [__v_4]; record.function_queries[800].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_3] = { let __args: [G; IN_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 __ret: [G; OUT_800] = [__v_5]; record.function_queries[800].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_801: usize = 8; -const IN_801: usize = 8; -const OUT_801: usize = 6; -fn aiur_fn_801(inp: [G; IN_801], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_801], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_804] = { let __args: [G; IN_804] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(804, (&__args[..]))?) { [G::ZERO; OUT_804] } else { let (__hash, __hit) = record.function_queries[804].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[804].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[804].bump_multiplicity(__i); } let __ret: [G; OUT_804] = unsafe { (*(record.function_queries[804].output_at(__i).as_ptr() as *const [G; OUT_804])) }; __ret }, _ => { aiur_fn_804::(__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_801] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; record.function_queries[801].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +fn aiur_fn_800(inp: [G; IN_800], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_800], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 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_800] = [__v_3]; record.function_queries[800].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_800] = { let __args: [G; IN_800] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(800, (&__args[..]))?) { [G::ZERO; OUT_800] } else { let (__hash, __hit) = record.function_queries[800].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[800].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[800].bump_multiplicity(__i); } let __ret: [G; OUT_800] = unsafe { (*(record.function_queries[800].output_at(__i).as_ptr() as *const [G; OUT_800])) }; __ret }, _ => { aiur_fn_800::(__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_800] = [__v_9]; record.function_queries[800].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } +const INPUT_SIZE_801: usize = 2; +const IN_801: usize = 2; +const OUT_801: usize = 1; +fn aiur_fn_801(inp: [G; IN_801], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_801], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 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_801] = [__v_0]; record.function_queries[801].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_801] = { let __args: [G; IN_801] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(801, (&__args[..]))?) { [G::ZERO; OUT_801] } else { let (__hash, __hit) = record.function_queries[801].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[801].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[801].bump_multiplicity(__i); } let __ret: [G; OUT_801] = unsafe { (*(record.function_queries[801].output_at(__i).as_ptr() as *const [G; OUT_801])) }; __ret }, _ => { aiur_fn_801::(__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_801] = [__v_7]; record.function_queries[801].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_802: usize = 1; const IN_802: usize = 1; const OUT_802: usize = 1; -fn aiur_fn_802(inp: [G; IN_802], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_802], ExecError> { stacker::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_802] = [__v_7]; record.function_queries[802].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_802] = { let __args: [G; IN_802] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(802, (&__args[..]))?) { [G::ZERO; OUT_802] } else { let (__hash, __hit) = record.function_queries[802].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[802].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[802].bump_multiplicity(__i); } let __ret: [G; OUT_802] = unsafe { (*(record.function_queries[802].output_at(__i).as_ptr() as *const [G; OUT_802])) }; __ret }, _ => { aiur_fn_802::(__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_802] = [__v_9]; record.function_queries[802].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_803: usize = 2; -const IN_803: usize = 2; +fn aiur_fn_802(inp: [G; IN_802], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_802], ExecError> { stacker::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_802] = [__v_6]; record.function_queries[802].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_802] = { let __args: [G; IN_802] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(802, (&__args[..]))?) { [G::ZERO; OUT_802] } else { let (__hash, __hit) = record.function_queries[802].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[802].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[802].bump_multiplicity(__i); } let __ret: [G; OUT_802] = unsafe { (*(record.function_queries[802].output_at(__i).as_ptr() as *const [G; OUT_802])) }; __ret }, _ => { aiur_fn_802::(__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_802] = [__v_8]; record.function_queries[802].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_803: usize = 1; +const IN_803: usize = 1; const OUT_803: usize = 1; -fn aiur_fn_803(inp: [G; IN_803], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_803], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 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_803] = [__v_1]; record.function_queries[803].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_803] = { let __args: [G; IN_803] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(803, (&__args[..]))?) { [G::ZERO; OUT_803] } else { let (__hash, __hit) = record.function_queries[803].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[803].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[803].bump_multiplicity(__i); } let __ret: [G; OUT_803] = unsafe { (*(record.function_queries[803].output_at(__i).as_ptr() as *const [G; OUT_803])) }; __ret }, _ => { aiur_fn_803::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_803] = [__v_7]; record.function_queries[803].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_803(inp: [G; IN_803], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_803], ExecError> { stacker::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_803] = [__v_4]; record.function_queries[803].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_803] = { let __args: [G; IN_803] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(803, (&__args[..]))?) { [G::ZERO; OUT_803] } else { let (__hash, __hit) = record.function_queries[803].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[803].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[803].bump_multiplicity(__i); } let __ret: [G; OUT_803] = unsafe { (*(record.function_queries[803].output_at(__i).as_ptr() as *const [G; OUT_803])) }; __ret }, _ => { aiur_fn_803::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_3] = { let __args: [G; IN_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 __ret: [G; OUT_803] = [__v_5]; record.function_queries[803].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_804: usize = 8; const IN_804: usize = 8; const OUT_804: usize = 6; -fn aiur_fn_804(inp: [G; IN_804], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_804], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; 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_804] = [__v_8, __v_8, __v_0, __v_1, __v_10, __v_10]; record.function_queries[804].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_804] = { let __args: [G; IN_804] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(804, (&__args[..]))?) { [G::ZERO; OUT_804] } else { let (__hash, __hit) = record.function_queries[804].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[804].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[804].bump_multiplicity(__i); } let __ret: [G; OUT_804] = unsafe { (*(record.function_queries[804].output_at(__i).as_ptr() as *const [G; OUT_804])) }; __ret }, _ => { aiur_fn_804::(__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_805] = { let __args: [G; IN_805] = [__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(805, (&__args[..]))?) { [G::ZERO; OUT_805] } else { let (__hash, __hit) = record.function_queries[805].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[805].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[805].bump_multiplicity(__i); } let __ret: [G; OUT_805] = unsafe { (*(record.function_queries[805].output_at(__i).as_ptr() as *const [G; OUT_805])) }; __ret }, _ => { aiur_fn_805::(__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_804] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; record.function_queries[804].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_804] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; record.function_queries[804].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_804] = { let __args: [G; IN_804] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(804, (&__args[..]))?) { [G::ZERO; OUT_804] } else { let (__hash, __hit) = record.function_queries[804].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[804].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[804].bump_multiplicity(__i); } let __ret: [G; OUT_804] = unsafe { (*(record.function_queries[804].output_at(__i).as_ptr() as *const [G; OUT_804])) }; __ret }, _ => { aiur_fn_804::(__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_805] = { let __args: [G; IN_805] = [__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(805, (&__args[..]))?) { [G::ZERO; OUT_805] } else { let (__hash, __hit) = record.function_queries[805].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[805].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[805].bump_multiplicity(__i); } let __ret: [G; OUT_805] = unsafe { (*(record.function_queries[805].output_at(__i).as_ptr() as *const [G; OUT_805])) }; __ret }, _ => { aiur_fn_805::(__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_804] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[804].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_805: usize = 15; -const IN_805: usize = 15; -const OUT_805: usize = 6; -fn aiur_fn_805(inp: [G; IN_805], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_805], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_806] = { let __args: [G; IN_806] = [__v_1, __v_2, __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(806, (&__args[..]))?) { [G::ZERO; OUT_806] } else { let (__hash, __hit) = record.function_queries[806].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[806].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[806].bump_multiplicity(__i); } let __ret: [G; OUT_806] = unsafe { (*(record.function_queries[806].output_at(__i).as_ptr() as *const [G; OUT_806])) }; __ret }, _ => { aiur_fn_806::(__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_805] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; record.function_queries[805].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_805] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; record.function_queries[805].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_806: usize = 14; -const IN_806: usize = 14; -const OUT_806: usize = 6; -fn aiur_fn_806(inp: [G; IN_806], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_806], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_806] = [__v_20, __v_20, __v_4, __v_5, __v_22, __v_24]; record.function_queries[806].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_806] = [__v_26, __v_26, __v_22, __v_23, __v_28, __v_30]; record.function_queries[806].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_806] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[806].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_806] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[806].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_806] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_26, __v_22, __v_23, __v_28, __v_30]; record.function_queries[806].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_806] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[806].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_806] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[806].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_806] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_20, __v_20, __v_16, __v_17, __v_23, __v_24]; record.function_queries[806].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_806] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[806].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_806] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[806].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_806] = [__v_20, __v_20, __v_16, __v_17, __v_23, __v_24]; record.function_queries[806].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_806] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[806].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_806] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[806].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_806] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[806].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()); }, 785u64 => { let __inp: [G; IN_785] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_785::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 786u64 => { let __inp: [G; IN_786] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_786::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 787u64 => { let __inp: [G; IN_787] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_787::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 788u64 => { let __inp: [G; IN_788] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_788::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 789u64 => { let __inp: [G; IN_789] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_789::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 790u64 => { let __inp: [G; IN_790] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_790::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 791u64 => { let __inp: [G; IN_791] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_791::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 792u64 => { let __inp: [G; IN_792] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_792::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 793u64 => { let __inp: [G; IN_793] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_793::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 794u64 => { let __inp: [G; IN_794] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_794::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 795u64 => { let __inp: [G; IN_795] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_795::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 796u64 => { let __inp: [G; IN_796] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_796::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 797u64 => { let __inp: [G; IN_797] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_797::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 798u64 => { let __inp: [G; IN_798] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_798::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 799u64 => { let __inp: [G; IN_799] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_799::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 800u64 => { let __inp: [G; IN_800] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_800::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 801u64 => { let __inp: [G; IN_801] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_801::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 802u64 => { let __inp: [G; IN_802] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_802::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 803u64 => { let __inp: [G; IN_803] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_803::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 804u64 => { let __inp: [G; IN_804] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_804::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 805u64 => { let __inp: [G; IN_805] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_805::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 806u64 => { let __inp: [G; IN_806] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_806::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, } } +fn aiur_fn_804(inp: [G; IN_804], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_804], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_807] = { let __args: [G; IN_807] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(807, (&__args[..]))?) { [G::ZERO; OUT_807] } else { let (__hash, __hit) = record.function_queries[807].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[807].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[807].bump_multiplicity(__i); } let __ret: [G; OUT_807] = unsafe { (*(record.function_queries[807].output_at(__i).as_ptr() as *const [G; OUT_807])) }; __ret }, _ => { aiur_fn_807::(__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_804] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; record.function_queries[804].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +const INPUT_SIZE_805: usize = 1; +const IN_805: usize = 1; +const OUT_805: usize = 1; +fn aiur_fn_805(inp: [G; IN_805], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_805], ExecError> { stacker::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_805] = [__v_7]; record.function_queries[805].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_805] = { let __args: [G; IN_805] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(805, (&__args[..]))?) { [G::ZERO; OUT_805] } else { let (__hash, __hit) = record.function_queries[805].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[805].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[805].bump_multiplicity(__i); } let __ret: [G; OUT_805] = unsafe { (*(record.function_queries[805].output_at(__i).as_ptr() as *const [G; OUT_805])) }; __ret }, _ => { aiur_fn_805::(__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_805] = [__v_9]; record.function_queries[805].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +const INPUT_SIZE_806: usize = 2; +const IN_806: usize = 2; +const OUT_806: usize = 1; +fn aiur_fn_806(inp: [G; IN_806], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_806], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 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_806] = [__v_1]; record.function_queries[806].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_806] = { let __args: [G; IN_806] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(806, (&__args[..]))?) { [G::ZERO; OUT_806] } else { let (__hash, __hit) = record.function_queries[806].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[806].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[806].bump_multiplicity(__i); } let __ret: [G; OUT_806] = unsafe { (*(record.function_queries[806].output_at(__i).as_ptr() as *const [G; OUT_806])) }; __ret }, _ => { aiur_fn_806::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_806] = [__v_7]; record.function_queries[806].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_807: usize = 8; +const IN_807: usize = 8; +const OUT_807: usize = 6; +fn aiur_fn_807(inp: [G; IN_807], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_807], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; 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_807] = [__v_8, __v_8, __v_0, __v_1, __v_10, __v_10]; record.function_queries[807].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_807] = { let __args: [G; IN_807] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(807, (&__args[..]))?) { [G::ZERO; OUT_807] } else { let (__hash, __hit) = record.function_queries[807].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[807].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[807].bump_multiplicity(__i); } let __ret: [G; OUT_807] = unsafe { (*(record.function_queries[807].output_at(__i).as_ptr() as *const [G; OUT_807])) }; __ret }, _ => { aiur_fn_807::(__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_808] = { let __args: [G; IN_808] = [__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(808, (&__args[..]))?) { [G::ZERO; OUT_808] } else { let (__hash, __hit) = record.function_queries[808].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[808].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[808].bump_multiplicity(__i); } let __ret: [G; OUT_808] = unsafe { (*(record.function_queries[808].output_at(__i).as_ptr() as *const [G; OUT_808])) }; __ret }, _ => { aiur_fn_808::(__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_807] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; record.function_queries[807].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_807] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; record.function_queries[807].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_807] = { let __args: [G; IN_807] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(807, (&__args[..]))?) { [G::ZERO; OUT_807] } else { let (__hash, __hit) = record.function_queries[807].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[807].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[807].bump_multiplicity(__i); } let __ret: [G; OUT_807] = unsafe { (*(record.function_queries[807].output_at(__i).as_ptr() as *const [G; OUT_807])) }; __ret }, _ => { aiur_fn_807::(__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_808] = { let __args: [G; IN_808] = [__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(808, (&__args[..]))?) { [G::ZERO; OUT_808] } else { let (__hash, __hit) = record.function_queries[808].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[808].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[808].bump_multiplicity(__i); } let __ret: [G; OUT_808] = unsafe { (*(record.function_queries[808].output_at(__i).as_ptr() as *const [G; OUT_808])) }; __ret }, _ => { aiur_fn_808::(__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_807] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[807].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +const INPUT_SIZE_808: usize = 15; +const IN_808: usize = 15; +const OUT_808: usize = 6; +fn aiur_fn_808(inp: [G; IN_808], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_808], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_809] = { let __args: [G; IN_809] = [__v_1, __v_2, __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(809, (&__args[..]))?) { [G::ZERO; OUT_809] } else { let (__hash, __hit) = record.function_queries[809].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[809].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[809].bump_multiplicity(__i); } let __ret: [G; OUT_809] = unsafe { (*(record.function_queries[809].output_at(__i).as_ptr() as *const [G; OUT_809])) }; __ret }, _ => { aiur_fn_809::(__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_808] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; record.function_queries[808].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_808] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; record.function_queries[808].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +const INPUT_SIZE_809: usize = 14; +const IN_809: usize = 14; +const OUT_809: usize = 6; +fn aiur_fn_809(inp: [G; IN_809], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_809], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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_809] = [__v_20, __v_20, __v_4, __v_5, __v_22, __v_24]; record.function_queries[809].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_809] = [__v_26, __v_26, __v_22, __v_23, __v_28, __v_30]; record.function_queries[809].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_809] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[809].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_809] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[809].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_809] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_26, __v_22, __v_23, __v_28, __v_30]; record.function_queries[809].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_809] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[809].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_809] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[809].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_809] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_20, __v_20, __v_16, __v_17, __v_23, __v_24]; record.function_queries[809].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_809] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[809].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_809] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[809].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_809] = [__v_20, __v_20, __v_16, __v_17, __v_23, __v_24]; record.function_queries[809].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_809] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[809].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_809] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[809].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_809] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[809].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()); }, 785u64 => { let __inp: [G; IN_785] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_785::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 786u64 => { let __inp: [G; IN_786] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_786::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 787u64 => { let __inp: [G; IN_787] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_787::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 788u64 => { let __inp: [G; IN_788] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_788::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 789u64 => { let __inp: [G; IN_789] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_789::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 790u64 => { let __inp: [G; IN_790] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_790::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 791u64 => { let __inp: [G; IN_791] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_791::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 792u64 => { let __inp: [G; IN_792] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_792::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 793u64 => { let __inp: [G; IN_793] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_793::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 794u64 => { let __inp: [G; IN_794] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_794::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 795u64 => { let __inp: [G; IN_795] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_795::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 796u64 => { let __inp: [G; IN_796] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_796::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 797u64 => { let __inp: [G; IN_797] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_797::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 798u64 => { let __inp: [G; IN_798] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_798::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 799u64 => { let __inp: [G; IN_799] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_799::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 800u64 => { let __inp: [G; IN_800] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_800::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 801u64 => { let __inp: [G; IN_801] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_801::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 802u64 => { let __inp: [G; IN_802] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_802::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 803u64 => { let __inp: [G; IN_803] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_803::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 804u64 => { let __inp: [G; IN_804] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_804::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 805u64 => { let __inp: [G; IN_805] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_805::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 806u64 => { let __inp: [G; IN_806] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_806::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 807u64 => { let __inp: [G; IN_807] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_807::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 808u64 => { let __inp: [G; IN_808] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_808::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 809u64 => { let __inp: [G; IN_809] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_809::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, } } diff --git a/crates/kernel/src/anon_work.rs b/crates/kernel/src/anon_work.rs index 8acefae79..0fdb11610 100644 --- a/crates/kernel/src/anon_work.rs +++ b/crates/kernel/src/anon_work.rs @@ -26,7 +26,7 @@ //! inductive member). Checking the primary triggers the kernel's //! block-coordination logic which covers every target. //! -//! Dispatch on the outer `Tag4` byte via +//! Dispatch on the outer `TagN` byte via //! [`ixon::lazy::LazyConstant::peek_variant`] avoids body parse + //! `Arc` allocation for the ~95% of constants that are //! standalones or projections. @@ -110,7 +110,7 @@ impl AnonWorkItem { /// `work.iter().map(|w| w.targets().len()).sum()`. /// /// Errors only on a corrupted env (missing const at an enumerated -/// address, or a Tag4 head byte that doesn't correspond to a known +/// address, or a TagN head byte that doesn't correspond to a known /// `ConstantInfo` variant). pub fn build_anon_work(env: &IxonEnv) -> Result, String> { use ConstVariantTag as Tag; diff --git a/crates/kernel/src/resource.rs b/crates/kernel/src/resource.rs index 9f7015dca..d67bda145 100644 --- a/crates/kernel/src/resource.rs +++ b/crates/kernel/src/resource.rs @@ -1,4 +1,4 @@ -//! Combined resource and erased-type validation for addressed Ixon v3. +//! Combined resource and erased-type validation for addressed Ixon. //! Kernel typechecking on its own makes no resource promise. use crate::anon_work::build_anon_work; @@ -127,23 +127,23 @@ mod tests { #[test] fn cross_language_consumer_handoff() { let profile = Profile::from_bytes(include_bytes!( - "../../../Tests/Fixtures/ixon-v3/handoff/profile.bin" + "../../../Tests/Fixtures/ixon-v4/handoff/profile.bin" )) .unwrap(); let claim = ixon::proof::Claim::from_bytes(include_bytes!( - "../../../Tests/Fixtures/ixon-v3/handoff/accepted.claim" + "../../../Tests/Fixtures/ixon-v4/handoff/accepted.claim" )) .unwrap(); let accepted = Env::get( &mut include_bytes!( - "../../../Tests/Fixtures/ixon-v3/handoff/accepted.ixe" + "../../../Tests/Fixtures/ixon-v4/handoff/accepted.ixe" ) .as_slice(), ) .unwrap(); let rejected = Env::get( &mut include_bytes!( - "../../../Tests/Fixtures/ixon-v3/handoff/rejected-local-escape.ixe" + "../../../Tests/Fixtures/ixon-v4/handoff/rejected-local-escape.ixe" ) .as_slice(), ) diff --git a/crates/kernel/src/whnf.rs b/crates/kernel/src/whnf.rs index 0a04f2aeb..84bd5fdd1 100644 --- a/crates/kernel/src/whnf.rs +++ b/crates/kernel/src/whnf.rs @@ -4452,10 +4452,10 @@ mod tests { let prims = Primitives::from_env(&KEnv::::new()); let string_to_list_id = canonical_id( - "8cece559b9901256cce90e9bf1fa09fce136ff433a24fed990e6734a9c0bdba4", + "85bfb457e4487849a08e03ec1d7288888726463caf9768c06a12bf4451e2a7db", ); let list_length_id = canonical_id( - "040eac73ee2bdc17f6f276c3660f7e8cf84cb82df9259591d6a808a39571bf25", + "a9f286f64c677e133822d2fd2167ca5c5ab29ae6a78fe1ac1f4eec8a452f56b2", ); let list_id = mk_id("Test.List"); let list_nil_id = mk_id("Test.List.nil"); diff --git a/docs/Ixon-v3.md b/docs/Ixon-v4.md similarity index 56% rename from docs/Ixon-v3.md rename to docs/Ixon-v4.md index 928b1a9a9..2e1f7d0e9 100644 --- a/docs/Ixon-v3.md +++ b/docs/Ixon-v4.md @@ -1,16 +1,41 @@ -# Ixon v3: usage, ownership, and relative locality +# Ixon v4: contracts, TagN integers, and canonical sharing -This specification describes the implemented Ixon v3 format and the admitted -Ix source fragment. Relative locality replaces explicit lifetime parameters. -The format is incompatible with v2; all typed addresses and primitive pins -must be regenerated. +This specification describes the Ixon v4 format and the admitted Ix source +fragment. + +Version 4 keeps the contract model that v3 introduced: usage, ownership and +relative locality, with no explicit lifetime parameters (§1–§3). It changes +the byte grammar in two ways (§5): + +- **TagN integers.** One integer code, TagN, replaces v3's Tag0, Tag2 and + Tag4 everywhere. +- **Canonical sharing.** A constant's sharing table is part of its canonical + definition, built by the two-phase construction instead of a heuristic. + +The format is incompatible with v3: all typed addresses, primitive pins, +claims and `.ixe` files must be regenerated. + +This file replaces the v3 specification (`Ixon-v3.md`). That file's content +is preserved here: §1–§3 and §6 are unchanged, and §4 has been updated for +v4. The byte-level reference is [Ixon](Ixon.md). See the [text format](ixon-text-v3.md) and the [resource checker](resource-checking.md) for supported behavior and checking -limits, and the [consumer handoff](compilatrix-ixon-v3.md) for migration fixtures. -Native resource claims are implemented. IxVM checks erased Lean typing and -explicitly rejects resource-proof requests. The [verification record](ixon-v3-verification.md) -lists the executed gates and formal trust boundary. +limits, and the [consumer handoff](compilatrix-ixon-v3.md) for migration +fixtures. Native resource claims are implemented. IxVM checks erased Lean +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 +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 +bytes. Its claim readers require object format `4`, and its kernel +recognizes primitives by their v4 canonical addresses. The circuit reads +neither `.ixe` headers nor `ConstantMeta`. ## 1. Independent contracts @@ -154,11 +179,17 @@ Ordinary typechecking and native calling-convention hints do not certify them. ## 4. Representation and canonical wire layout -The binary environment version is **3** and the typed-constant protocol -identifier is **`ixon-v3`**. Constants remain BLAKE3-addressed canonical bytes; -the surrounding catalog/artifact protocol binds the format. Blob addresses -remain BLAKE3 of raw bytes. No v2 fallback or mixed-version typed environment -is admitted. +The binary environment version is **4**, the `.ixe` header byte is `0xE4` +(`TagN(0xE, 4)`), and the typed-constant protocol identifier is +**`ixon-v4`**. Constants remain BLAKE3-addressed canonical bytes; the +surrounding catalog/artifact protocol binds the format. Claims and proofs +carry object format `4`, and the resource validator identity is +`ixon-v4/resource-v1`. Blob addresses remain BLAKE3 of raw bytes. No v3 +fallback or mixed-version typed environment is admitted. + +The `0xE4` header byte is also the byte of the Check claim tag (`0xE3` was +also the Eval claim tag). Readers interpret it by context, and the enclosing +protocol identifies the object kind. The original twelve expression variants remain. Lambda and forall payloads carry complete contracts. The let payload carries `LetContract`. Declaration @@ -181,25 +212,129 @@ Lambda binders require one contract byte and forall binders require one contract byte. Application, lambda, and forall use their original maximal ordinary telescopes, with no term/region packet discriminants. -Let uses its existing Tag4 category `0xA`. The size encodes the non-dependent -flag in bit 0 and `borrowShared` in bit 1. Sizes above 3 are invalid. The -payload is one binder-contract byte followed by type, initializer, and body -expressions, in that order. Ordinary let sizes remain 0 or 1; shared-borrow -sizes are 2 or 3. Borrowing introduces no new expression constructor or tag. +Let uses expression flag `0xA` (a TagN header with a 4-bit flag). The header +value encodes the non-dependent flag in bit 0 and `borrowShared` in bit 1. +Values above 3 are invalid. The payload is one binder-contract byte followed +by type, initializer, and body expressions, in that order. Ordinary lets use +values 0 or 1; shared borrows use 2 or 3. Borrowing introduces no new +expression constructor or flag. + +All counts, indices and headers use TagN (§5). TagN is bijective, so no value +has a non-minimal encoding. Readers reject: + +- invalid TagN codes and values reaching `2^64`; +- reserved mode bits and invalid enum/Boolean flags; +- empty or non-maximal telescopes; +- impossible counts; +- truncation, and trailing bytes at a whole-object boundary. -All counts and indices use the shortest existing unsigned encodings. Readers -reject nonminimal tags, reserved mode bits, invalid enum/Boolean flags, empty -or nonmaximal telescopes, impossible counts, truncation, and trailing bytes -at a whole-object boundary. Native readers bound count-based preallocation by -the remaining byte budget. IxVM parses counted lists incrementally and rejects -exhausted input through strict byte reads, without a preliminary byte traversal. -Readers do not normalize adversarial bytes into other addresses. +Native readers bound count-based preallocation by the remaining byte budget. +IxVM parses counted lists incrementally and rejects exhausted input through +strict byte reads, without a preliminary byte traversal. Readers do not +normalize adversarial bytes into other addresses. Source annotations, semantic contracts, canonical bytes, structural sharing -hashes, equality, and cache keys must all distinguish the four value modes, +IDs, equality, and cache keys must all distinguish the four value modes, four quantities, independent arrow results, and two let kinds. -## 5. Admission, transport, and verification +## 5. Integers and canonical sharing + +These are the two byte-level changes from v3. [Ixon](Ixon.md) gives the full +layouts, examples and proof references. + +**TagN.** Every variable-length integer is a TagN integer. That is one header +byte `[flag : f bits][payload : 8 − f bits]` with `f ∈ {0, 2, 4}`, followed +by 0, 1, 2, 3, 4 or 8 bytes: + +- `f = 4` is used for expression, constant, environment, claim and proof + headers; +- `f = 2` for universe terms; +- `f = 0` for counts, indices and lengths. + +The rungs hold 1, 2, 3, 4, 5 and 9 bytes, and each rung starts where the +previous one ends, so the code is bijective. Values below 128, 32 or 8 (for +`f` = 0, 2 or 4) encode to the same single byte as v3's Tag0, Tag2 or Tag4. +Larger values encode differently: for example, `Share(8)` is `B8 00`, and the +Resource claim tag is `E8 01`. The Lean proofs of injectivity, canonicity +and rejection are in `Ix/Compile/Verify/TagN.lean`. + +**Canonical sharing.** A constant's sharing table, and every `Share` +occurrence, is determined by its expanded anonymous expressions. It is the +output of the two-phase construction `canonicalSharingTiered .tagN`: + +1. **Phase 1:** an exact minimum of the uniform-width model at each width + `w ∈ {1, 2, 3}`. +2. **Phase 2:** an exact first tier of at most eight 1-byte slots, followed by + the Kahn priority order. +3. **Phase 3:** minimum-length re-materialization of each part at the real + TagN widths. +4. **Selection:** the candidate with the fewest real bytes is kept, ties going + to the lower `w`. + +The construction keeps two properties: + +- **Backward references.** Entry `i` references only entries below `i`. +- **Independence from metadata and history.** By definition, metadata never + influences the table, and neither do pointer sharing, construction history + or the compiler that ran. + +**Scope of the guarantees.** [Ixon](Ixon.md#what-is-proved-and-what-is-not) +gives the exact statements. + +- **Machine-checked (Lean),** for a successful run on the canonical DAG of the + input: + - Phase 1 returns the `setPrec`-least minimum of the uniform model over + tables of in-degree ≥ 2 terms (`optimizeUniform_minimum`, + `optimizeUniform_least`). + - Phases 2 and 3 and the width selection meet their per-phase + specifications (`allocate_spec`, `allocate_optimal`, + `materializeTable_min`, `rematerialize_spec`, + `canonicalTieredCore_select`). + - The length the construction minimizes and reports is the serialized TagN + length of its output (`canonicalSharingTiered_serialized`). + - Every output entry and root is in the codec's wire domain, the table + count is below `2^64` and Shares point backward + (`canonicalSharingTiered_format`). The compiler endpoint theorems are + stated over it: a compiler run returns an exactly decodable block or + fails with an error of the sharing builder. + - The compiler runs fast twins of the specifications, each tied to its + specification by an audited `@[csimp]` equality. +- **Not claimed.** + - The composed result is not claimed to be a global byte minimum. + - The step that builds the canonical DAG from the input expressions + (`expand`, with the interner's pointer cache) is outside the proofs. + Independence from in-memory pointer sharing is tested and the round trip + is checked at run time, not proved. + - The Rust implementation is checked by differential tests, not proofs. + Its phase-1 length arithmetic is 128-bit and fails closed beyond that + range, where Lean succeeds; no Init or Mathlib constant comes near it. + +Both compilers build every table with this construction; it is the only +sharing construction. + +**Metadata expressions.** A `Share(i)` inside entry `j` of +`ConstantMeta.metaSharing` (the collapsed call-site arguments) is read in an +extended index space. With `p` the size of the primary table: + +- `i < p` refers to primary entry `i`; +- `p ≤ i < p + j` refers to `metaSharing[i − p]`; +- every other index is a decode error (out of range, or a forward or self + reference). + +A `Share` in a primary expression always refers to the primary table. The +two decompilers implement this rule; the compilers emit no such `Share`, and +there is no canonical metadata construction. +[Ixon](Ixon.md#sharing-in-metadata-expressions) gives the details. + +**Compilation failures.** The construction runs under explicit resource +limits, a safety net far above every corpus maximum that +`ix compile --sharing-limits` overrides. Exceeding one is a compile error +that names the limit. There is no fallback construction. + +These changes do not affect the contract model: §1–§3 and the admission +rules of §6 are the same as in v3. + +## 6. Admission, transport, and verification Wire validation establishes representation. Scope/type validation establishes term scope, types, and permitted owner-place shapes. Resource validation diff --git a/docs/Ixon.md b/docs/Ixon.md index 8d95a618c..e1d459f9c 100644 --- a/docs/Ixon.md +++ b/docs/Ixon.md @@ -8,7 +8,7 @@ Ixon is a content-addressed, alpha-invariant binary serialization format for Lea 2. **Content-addressing**: Every constant is identified by the blake3 hash of its serialized content. This enables deduplication and cryptographic verification. -3. **Compact storage**: Variable-length encoding, telescope compression, and expression sharing minimize serialized size. +3. **Compact storage**: One variable-length integer code (TagN), telescope compression, and canonical expression sharing keep serialized constants small. 4. **Metadata separation**: Names, binder info, and other source information are stored separately from the alpha-invariant core, enabling roundtrip compilation while preserving deterministic hashing. @@ -42,11 +42,11 @@ This separation means cosmetic changes (renaming variables) don't change the con | Section | Contents | |---------|----------| -| [Tag Encoding](#tag-encoding-schemes) | Variable-length integer encoding | +| [Integer Encoding](#integer-encoding-tagn) | TagN variable-length integers | | [Universes](#universes) | Type-level hierarchy | | [Expressions](#expressions) | Lambda calculus terms | | [Constants](#constants) | Top-level declarations | -| [Sharing](#sharing-system) | Expression deduplication | +| [Sharing](#sharing-system) | Canonical expression sharing | | [Metadata](#metadata) | Names and source info | | [Environment](#environment) | Storage and serialization | | [The .ixc Catalog](#the-ixc-catalog-manifest) | Multi-env merkle catalog | @@ -58,25 +58,81 @@ This separation means cosmetic changes (renaming variables) don't change the con --- -## Tag Encoding Schemes +## Integer Encoding (TagN) -Ixon uses three variable-length encoding schemes for compact representation. +Every variable-length integer in the Ixon grammar uses one code, **TagN**. +That includes expression, constant, environment, claim and proof headers, +universe terms, counts, indices and lengths. Fixed-width fields are raw bytes, +unchanged: packed flag bytes, contract bytes, option bytes, variant tags and +32-byte addresses. A TagN integer carries a flag of `f ∈ {0, 2, 4}` bits: -### Tag4 (4-bit flag) +| `f` | Used for | Notation in this document | +|---|---|---| +| 4 | Expression, constant, environment, claim and proof headers | `N4(flag, v)` | +| 2 | Universe terms | `N2(flag, v)` | +| 0 | Counts, indices, lengths and other unsigned integers | `N0(v)` | -Used for expressions, constants, and environment/proof structures. Header byte format: +Format version 4 introduced TagN. It replaces v3's three codes Tag4, Tag2 +and Tag0, which had the same flag widths (4, 2 and 0 bits). For values below +128 (`f = 0`), 32 (`f = 2`) or 8 (`f = 4`), both codes write the same single +byte. Larger values are encoded differently. + +The implementation is Lean `Ixon.putTagN f flag value` / `Ixon.getTagN f` +(`Ix/Ixon.lean`, which documents the bit layout) and Rust +`ixon::tag::TagN::put` / `TagN::get`. + +### Layout + +A TagN integer is one header byte followed by 0, 1, 2, 3, 4 or 8 bytes. The +header is ``` -[flag:4][large:1][size:3] +[flag : f bits][payload : r = 8 − f bits] ``` -- **flag** (4 bits): Discriminates type (see table below) -- **large** (1 bit): If 0, size is in the low 3 bits. If 1, (size+1) bytes follow with the actual value -- **size** (3 bits): Small values 0-7, or byte count for large values +Let `L` be the top payload bit, `M` the next bit, and `c` the remaining low +`r − 2` bits: + +| Header payload | Bytes that follow | Values | Decoded value | +|---|---|---|---| +| `L = 0` | none | `[0, R₁)` | the low `r − 1` payload bits | +| `L = 1, M = 0` | 1 | `[R₁, R₂)` | `R₁ + c·256 + byte` (`c` is the high part, the byte the low 8 bits) | +| `L = 1, M = 1, c = 0` | 2, little-endian | `[R₂, R₃)` | `R₂ + u16` | +| `L = 1, M = 1, c = 1` | 3, little-endian | `[R₃, R₄)` | `R₃ + u24` | +| `L = 1, M = 1, c = 2` | 4, little-endian | `[R₄, R₅)` | `R₄ + u32` | +| `L = 1, M = 1, c = 3` | 8, little-endian | `[R₅, 2^64)` | `R₅ + u64` | +| `L = 1, M = 1, c ≥ 4` | — | invalid (`f = 0, 2` only: for `f = 4`, `c` has two bits) | | + +The rung ends are `R₁ = 2^(r−1)`, `R₂ = R₁ + 2^(r−2+8)`, `R₃ = R₂ + 2^16`, +`R₄ = R₃ + 2^24` and `R₅ = R₄ + 2^32`. The encoded widths are 1, 2, 3, 4, 5 +and 9 bytes. + +| `f` | R₁ | R₂ | R₃ | R₄ | R₅ | +|---|---:|---:|---:|---:|---:| +| 0 | 128 | 16,512 | 82,048 | 16,859,264 | 4,311,826,560 | +| 2 | 32 | 4,128 | 69,664 | 16,846,880 | 4,311,814,176 | +| 4 | 8 | 1,032 | 66,568 | 16,843,784 | 4,311,811,080 | + +**Bijective.** Each rung starts where the previous one ends. So every +`UInt64` value has exactly one encoding, and every accepted byte string is the +encoding of the value it decodes to. There is no non-minimal form for readers +to reject. A reader rejects only three things: + +- a code `c ≥ 4` (`f = 0` or `2`); +- an 8-byte rung whose value would reach `2^64`; +- truncated input. + +The Lean proofs are in `Ix/Compile/Verify/TagN.lean`: + +- `runGetExact_getTagN_eq`: accepted encodings are canonical; +- `putTagN_inj`: distinct values or flags have distinct encodings; +- `getTagN_rejects_code` and `getTagN_rejects_overflow`: the two rejection rules. + +All four are roots of the compiler audit manifest. -**Complete Tag4 flag allocation:** +### Flag allocation (`f = 4`) -| Flag | Category | Type | Size field meaning | +| Flag | Category | Type | Header value meaning | |------|----------|------|-------------------| | 0x0 | Expr | Sort | Universe index | | 0x1 | Expr | Var | De Bruijn index | @@ -88,88 +144,42 @@ Used for expressions, constants, and environment/proof structures. Header byte f | 0x7 | Expr | App | Application count (telescoped) | | 0x8 | Expr | Lam | Binder count (telescoped) | | 0x9 | Expr | All | Binder count (telescoped) | -| 0xA | Expr | Let | 0=dep, 1=non_dep | -| 0xB | Expr | Share | Share vector index | +| 0xA | Expr | Let | Bit 0 non-dependent, bit 1 shared borrow (values 0–3) | +| 0xB | Expr | Share | Sharing table index | | 0xC | Constant | Muts | Entry count | | 0xD | Constant | Non-Muts | Variant (0-7) | -| 0xE | Env/Claim | Env/Comm/AssumptionTree/Claim | `.ixe` header: format version (see below); Comm/AssumptionTree/Claim: variant | -| 0xF | Proof | ZK proofs | Variant (0-4); 5-7 reserved | - -```rust -pub struct Tag4 { - pub flag: u8, // 0-15 - pub size: u64, // Variable-length payload -} -``` - -**Examples:** - -``` -Tag4 { flag: 0x1, size: 5 } -Header: 0b0001_0_101 = 0x15 -Total: 1 byte - -Tag4 { flag: 0x2, size: 256 } -Header: 0b0010_1_001 = 0x29 (large=1, 2 bytes follow) -Bytes: 0x00 0x01 (256 in little-endian) -Total: 3 bytes -``` - -### Tag2 (2-bit flag) - -Used for universes. Header byte format: - -``` -[flag:2][large:1][size:5] -``` - -- **flag** (2 bits): Discriminates universe type (0-3) -- **large** (1 bit): If 0, size is in the low 5 bits (0-31). If 1, (size+1) bytes follow -- **size** (5 bits): Small values 0-31, or byte count - -```rust -pub struct Tag2 { - pub flag: u8, // 0-3 - pub size: u64, // Variable-length payload -} -``` - -**Examples:** - -``` -Tag2 { flag: 0, size: 15 } -Header: 0b00_0_01111 = 0x0F -Total: 1 byte - -Tag2 { flag: 3, size: 100 } -Header: 0b11_1_00000 = 0xE0 (large=1, 1 byte follows) -Bytes: 0x64 (100) -Total: 2 bytes -``` - -### Tag0 (no flag) - -Used for plain variable-length u64 values. Header byte format: - -``` -[large:1][size:7] -``` - -- **large** (1 bit): If 0, size is in the low 7 bits (0-127). If 1, (size+1) bytes follow -- **size** (7 bits): Small values 0-127, or byte count - -**Examples:** +| 0xE | Env/Claim | Env/Comm/AssumptionTree/Claim | `.ixe` header: format version (4, byte `0xE4`); Comm/AssumptionTree/Claim: variant | +| 0xF | Proof | ZK proofs | Variant (0-6) | -``` -Tag0 { size: 42 } -Header: 0b0_0101010 = 0x2A -Total: 1 byte +### Examples -Tag0 { size: 1000 } -Header: 0b1_0000001 = 0x81 (large=1, 2 bytes follow) -Bytes: 0xE8 0x03 (1000 in little-endian) -Total: 3 bytes -``` +These bytes were produced by `Ixon.putTagN`, and each decodes back to its +value with `Ixon.getTagN`: + +| Integer | Bytes | Width | +|---|---|---:| +| `N4(0x1, 5)` (`Var(5)`) | `15` | 1 | +| `N4(0xB, 7)` (`Share(7)`) | `B7` | 1 | +| `N4(0xB, 8)` (`Share(8)`) | `B8 00` | 2 | +| `N4(0xB, 1031)` | `BB FF` | 2 | +| `N4(0xB, 1032)` | `BC 00 00` | 3 | +| `N4(0xB, 66568)` | `BD 00 00 00` | 4 | +| `N4(0xB, 16843784)` | `BE 00 00 00 00` | 5 | +| `N4(0xB, 4311811080)` | `BF 00 00 00 00 00 00 00 00` | 9 | +| `N4(0x2, 256)` (`Ref` with 256 universe arguments) | `28 F8` | 2 | +| `N4(0xE, 4)` (the version-4 `.ixe` header) | `E4` | 1 | +| `N4(0xE, 9)` (Resource claim) | `E8 01` | 2 | +| `N2(3, 100)` (`Univ::Var(100)`) | `E0 44` | 2 | +| `N0(42)` | `2A` | 1 | +| `N0(128)` | `80 00` | 2 | +| `N0(1000)` | `83 68` | 2 | +| `N0(16512)` | `C0 00 00` | 3 | +| `N0(82048)` | `C1 00 00 00` | 4 | +| `N0(16859264)` | `C2 00 00 00 00` | 5 | +| `N0(2^64 − 1)` | `C3 7F BF FE FE FE FF FF FF` | 9 | + +`getTagN 0` rejects the header `C4` (`L = M = 1`, `c = 4`) with "invalid TagN +code 4". `getTagN 4` has no invalid header: its code `c` has two bits. --- @@ -187,43 +197,47 @@ pub enum Univ { } ``` -### Serialization (Tag2) +### Serialization (TagN, `f = 2`) -| Flag | Variant | Size field | Body | +| Flag | Variant | Value | Body | |------|---------|------------|------| | 0 | Zero/Succ | Succ count (0 = Zero) | None | | 1 | Max | Unused | Two Univs | | 2 | IMax | Unused | Two Univs | | 3 | Var | Variable index | None | -**Telescope compression**: Nested `Succ` constructors are collapsed. `Succ(Succ(Succ(Zero)))` serializes as a single Tag2 with flag=0 and size=3. +**Telescope compression**: Nested `Succ` constructors are collapsed. `Succ(Succ(Succ(Zero)))` serializes as the single integer `N2(0, 3)`. ### Examples ``` Univ::Zero -Tag2 { flag: 0, size: 0 } = 0b00_0_00000 +N2(0, 0) Bytes: 0x00 Univ::Succ(Zero) // Type 1 -Tag2 { flag: 0, size: 1 } + base +N2(0, 1) + base Bytes: 0x01 0x00 Univ::Succ(Succ(Succ(Zero))) // Type 3 -Tag2 { flag: 0, size: 3 } + base +N2(0, 3) + base Bytes: 0x03 0x00 Univ::Var(0) // First universe parameter -Tag2 { flag: 3, size: 0 } = 0b11_0_00000 +N2(3, 0) Bytes: 0xC0 Univ::Var(1) // Second universe parameter -Tag2 { flag: 3, size: 1 } = 0b11_0_00001 +N2(3, 1) Bytes: 0xC1 Univ::Max(Zero, Var(1)) -Tag2 { flag: 1, size: 0 } + Zero + Var(1) +N2(1, 0) + Zero + Var(1) Bytes: 0x40 0x00 0xC1 + +Univ::Var(100) // 101st universe parameter (value ≥ 32: two bytes) +N2(3, 100) +Bytes: 0xE0 0x44 ``` --- @@ -253,7 +267,7 @@ pub enum Expr { 1. **No names**: Binders have no names—they use de Bruijn indices. Names are stored in metadata. -2. **Independent v3 contracts**: `BinderContract { uses, value }` separates +2. **Independent contracts** (introduced in v3, unchanged in v4): `BinderContract { uses, value }` separates quantity (`erased`, `linear`, `affine`, `many`) from the `ValueContract { owned, locality }` axes. Both bound and returned values can be unique/shared and local/unrestricted. Foralls carry an independent @@ -261,28 +275,28 @@ pub enum Expr { ordinary binding from a scoped shared borrow. Ordinary Lean compilation uses many/shared/unrestricted inputs and shared/unrestricted results. Names and implicit/explicit binder information remain metadata. - See [the v3 specification](Ixon-v3.md) for the resource semantics. + See [the v4 specification](Ixon-v4.md) for the resource semantics. 3. **Indirection tables**: `Ref`, `Str`, `Nat` store indices into the constant's `refs` table, not raw addresses. `Sort` stores an index into the `univs` table. -4. **Share nodes**: Common subexpressions can be deduplicated via `Share(idx)` references to the constant's `sharing` vector. +4. **Share nodes**: Repeated subexpressions are written once in the constant's `sharing` table and referenced with `Share(idx)`. The table is canonical: see [Sharing System](#sharing-system). -### Serialization (Tag4) +### Serialization (TagN, `f = 4`) -| Flag | Variant | Size field | Body | +| Flag | Variant | Header value | Body | |------|---------|------------|------| | 0x0 | Sort | Universe index | None | | 0x1 | Var | De Bruijn index | None | -| 0x2 | Ref | Univ count | Ref index (Tag0) + univ indices | -| 0x3 | Rec | Univ count | Rec index (Tag0) + univ indices | -| 0x4 | Prj | Field index | Type ref index (Tag0) + value Expr | +| 0x2 | Ref | Univ count | Ref index (`N0`) + univ indices (`N0` each) | +| 0x3 | Rec | Univ count | Rec index (`N0`) + univ indices (`N0` each) | +| 0x4 | Prj | Field index | Type ref index (`N0`) + value Expr | | 0x5 | Str | Refs index | None | | 0x6 | Nat | Refs index | None | | 0x7 | App | App count | Function + args (telescoped) | | 0x8 | Lam | Binder count | `(input-contract byte + type)` per binder + body | | 0x9 | All | Binder count | `(input/result-contract byte + type)` per binder + body | | 0xA | Let | Non-dependent flag in bit 0; borrow flag in bit 1 | Binder-contract byte + type + value + body | -| 0xB | Share | Share index | None | +| 0xB | Share | Sharing table index | None | ### Telescope Compression @@ -290,13 +304,13 @@ Nested constructors of the same kind are collapsed: **Applications**: `App(App(App(f, a), b), c)` becomes: ``` -Tag4 { flag: 0x7, size: 3 } // 3 applications +N4(0x7, 3) // 3 applications + f + a + b + c ``` **Lambdas**: `Lam(t1, Lam(t2, Lam(t3, body)))` becomes: ``` -Tag4 { flag: 0x8, size: 3 } // 3 binders +N4(0x8, 3) // 3 binders + contract1 + t1 + contract2 + t2 + contract3 + t3 + body ``` @@ -309,35 +323,43 @@ the ordinary forall byte is `0x17`. Foralls use the same telescope layout with flag 0x9. Readers require nonempty, maximal telescopes and reject a nested constructor of the same -kind as the decoded base/body. Let sizes above 3 and nonminimal integer -encodings are invalid. A syntactically valid borrow record is still subject +kind as the decoded base/body. Let header values above 3 and invalid TagN codes +are rejected. TagN has no non-minimal encodings to reject. A syntactically valid borrow record is still subject to the separate owner-place and resource checks. ### Expression Examples ``` Expr::Var(0) // Innermost bound variable -Tag4 { flag: 0x1, size: 0 } +N4(0x1, 0) Bytes: 0x10 Expr::Sort(0) // First universe in univs table -Tag4 { flag: 0x0, size: 0 } +N4(0x0, 0) Bytes: 0x00 Expr::Ref(0, vec![0, 1]) // First constant with 2 univ args -Tag4 { flag: 0x2, size: 2 } -+ Tag0(0) // refs index -+ Tag0(0) // first univ index -+ Tag0(1) // second univ index +N4(0x2, 2) ++ N0(0) // refs index ++ N0(0) // first univ index ++ N0(1) // second univ index Bytes: 0x22 0x00 0x00 0x01 Expr::Lam(many_shared, type_expr, Lam(affine_shared, type_expr2, body)) -Tag4 { flag: 0x8, size: 2 } +N4(0x8, 2) + 0x07 + type_expr + 0x06 + type_expr2 + body Expr::Share(5) // Reference to sharing[5] -Tag4 { flag: 0xB, size: 5 } +N4(0xB, 5) Bytes: 0xB5 + +Expr::Share(8) // first index of the 2-byte rung +N4(0xB, 8) +Bytes: 0xB8 0x00 + +Expr::Share(1032) // first index of the 3-byte rung +N4(0xB, 1032) +Bytes: 0xBC 0x00 0x00 ``` --- @@ -375,22 +397,22 @@ recompile it" parse error. ### Serialization -Constants use two Tag4 flags: -- **Flag 0xD**: Non-Muts constants. Size field (0-7) holds the variant. Always 1-byte tag. -- **Flag 0xC**: Muts constants. Size field holds the entry count. +Constants use two `f = 4` flags: +- **Flag 0xD**: Non-Muts constants. The header value (0-7) is the variant, so the header is always 1 byte. +- **Flag 0xC**: Muts constants. The header value is the entry count. **Non-Muts format:** ``` -Tag4 { flag: 0xD, size: variant } // Always 1 byte (variant 0-7) +N4(0xD, variant) // Always 1 byte (variant 0-7) + ConstantInfo payload -+ sharing vector (Tag0 length + expressions) -+ refs vector (Tag0 length + 32-byte addresses) -+ univs vector (Tag0 length + universes) ++ sharing vector (N0 length + expressions) ++ refs vector (N0 length + 32-byte addresses) ++ univs vector (N0 length + universes) ``` **Muts format:** ``` -Tag4 { flag: 0xC, size: entry_count } +N4(0xC, entry_count) + MutConst entries (no length prefix - count is in tag) + sharing vector + refs vector @@ -444,7 +466,7 @@ pub struct Definition { DefKind+Safety packed (1 byte): (kind << 2) | safety - kind: 0=Definition, 1=Opaque, 2=Theorem - safety: 0=Unsafe, 1=Safe, 2=Partial -+ lvls (Tag0) ++ lvls (N0) + typ (Expr) + value (Expr) ``` @@ -475,19 +497,19 @@ pub struct RecursorRule { **Serialization**: ``` Packed bools (1 byte): bit 0 = k, bit 1 = is_unsafe -+ lvls (Tag0) -+ params (Tag0) -+ indices (Tag0) -+ motives (Tag0) -+ minors (Tag0) ++ lvls (N0) ++ params (N0) ++ indices (N0) ++ motives (N0) ++ minors (N0) + typ (Expr) -+ rules.len (Tag0) ++ rules.len (N0) + [RecursorRule]* ``` Each `RecursorRule` serializes as: ``` -fields (Tag0) +fields (N0) + rhs (Expr) ``` @@ -504,7 +526,7 @@ pub struct Axiom { **Serialization**: ``` is_unsafe (1 byte: 0 or 1) -+ lvls (Tag0) ++ lvls (N0) + typ (Expr) ``` @@ -523,7 +545,7 @@ pub struct Quotient { **Serialization**: ``` QuotKind (1 byte: 0=Type, 1=Ctor, 2=Lift, 3=Ind) -+ lvls (Tag0) ++ lvls (N0) + typ (Expr) ``` @@ -574,11 +596,11 @@ pub struct Inductive { **Serialization**: ``` is_unsafe (1 byte: 0 or 1) -+ lvls (Tag0) -+ params (Tag0) -+ indices (Tag0) ++ lvls (N0) ++ params (N0) ++ indices (N0) + typ (Expr) -+ ctors.len (Tag0) ++ ctors.len (N0) + [Constructor]* ``` @@ -600,10 +622,10 @@ pub struct Constructor { **Serialization**: ``` is_unsafe (1 byte: 0 or 1) -+ lvls (Tag0) -+ cidx (Tag0) -+ params (Tag0) -+ fields (Tag0) ++ lvls (N0) ++ cidx (N0) ++ params (N0) ++ fields (N0) + typ (Expr) ``` @@ -611,57 +633,382 @@ is_unsafe (1 byte: 0 or 1) ## Sharing System -The sharing system deduplicates common subexpressions within a constant. - -### How It Works - -1. **Merkle hashing**: Every subexpression is assigned a structural hash using blake3. Its preimage is the canonical isolated-node scalar/contract header followed by one fixed 32-byte hash per child, in structural order. Input, result, locality, let-kind, and dependency fields all participate. -2. **Usage counting**: Count how many times each unique subexpression appears -3. **Profitability analysis**: Decide which subexpressions to share based on size savings -4. **Rewriting**: Replace selected subexpressions with `Share(idx)` references - -### Profitability Heuristic - -Sharing a subterm is profitable when: - -``` -(N - 1) * term_size > N * share_ref_size -``` - -Where: -- `N` = number of occurrences -- `term_size` = serialized size of the subterm -- `share_ref_size` = size of `Share(idx)` tag (typically 1-2 bytes) - -### Sharing Vector - -The sharing vector is built incrementally: -- Each entry can only reference earlier entries (no forward references) -- Entries are sorted by profitability (most savings first) -- Root expressions are rewritten using all available share indices +A constant's `sharing` table holds subexpressions that its roots, and +later table entries, reference with `Share(idx)`. In format version 4 the +table is part of the canonical definition of the constant. The canonical +sharing of a constant is defined as a function of its anonymous +expressions. Two constants with equal expanded roots, `ConstantInfo` +fields, `refs`, `univs` and format must get identical bytes, whatever their +in-memory pointer sharing, construction history, compiler (Lean or Rust) or +existing table. Metadata never influences it. Which parts of this the proofs +cover, and which are checked at run time or by tests, is stated in +[What is proved, and what is not](#what-is-proved-and-what-is-not). + +Both compilers build every table with this construction +(`Ix.Sharing.Exact.canonicalSharingTiered .tagN`, Rust +`canonical_sharing_tiered(ShareLayout::TagN, ..)`): single constants, +mutual blocks and aux-gen blocks, and in Rust also kernel egress and the +decompiler's recompile check. It is the only sharing construction. + +### Table rules + +- **Roots.** The roots are the expressions of the `ConstantInfo`, in this + order: + - definitions: type, then value; + - axioms and quotients: type; + - recursors: type, then each rule's right-hand side; + - mutual blocks: each member's roots in member order, where an inductive + contributes its type and then its constructors' types. + + Projections have no roots (`Ix.CompileM.constantInfoRootExprs`). +- **Backward references.** Entry `i` references only entries `j < i`. + Roots may reference any entry. Expanding each `Share(j)` to entry `j`, + left to right, reproduces the roots exactly. No de Bruijn index is shifted + at a `Share`. Readers reject a `Share` index outside the table; the + decompilers and kernel ingress do not yet check backwardness (see + [Sharing in metadata expressions](#sharing-in-metadata-expressions)). The + canonical construction guarantees it for compiler output. +- **Encoding.** A Share is `N4(0xB, idx)`: 1 byte for indices 0–7, 2 bytes + for 8–1,031, 3 bytes for 1,032–66,567, then 4, 5 and 9 bytes. The table is + written as `N0(count)` followed by the entries in order. A `Share` written + where a telescope would continue ends that telescope. For example, the body + `Share(j)` of an `All` ends the `All` telescope, even if entry `j` is an + `All`. + +### Canonical construction + +The canonical table is the output of `Ix.Sharing.Exact.canonicalSharingTiered +.tagN` (Lean, `Ix/Sharing/Exact/Tiered.lean`) and of +`canonical_sharing_tiered(ShareLayout::TagN, ..)` (Rust, +`crates/ixon/src/sharing_exact/tiered.rs`). It runs on the roots with every +existing `Share` expanded. A constant that already carries its canonical +table normalizes to the same bytes (tested; proved under a hypothesis, see +"Idempotence" below). + +1. **Structural IDs.** The distinct subterms of the roots form a DAG + (`expand`: share expansion, then interning). Nodes are numbered by + height, then by (constructor tag, scalar fields, child IDs) + (`docs/sharing-minimum.md` §3.2). Hashes and the interner's pointer + cache only speed up discovery: identity is the structural key, never a + hash, pointer or traversal order. `canonicalize_det` + (`Ix/Compile/Verify/SharingExactCanon.lean`) proves that the numbering + of interned terms depends only on the terms the roots denote, not on the + interner's temporary IDs. +2. **Phase 1: selection, at each uniform width `w ∈ {1, 2, 3}`.** + `optimizeSharingUniform w` finds a stored set that minimizes the + constant's length when every `Share` costs `w` bytes and everything else + is priced at its encoded length, telescopes and table count included. + - Only terms with compact in-degree at least 2 are considered. The + in-degree counts DAG edges with multiplicity, plus root occurrences. + - Ties go to the minimum that is least in the pinned order `setPrec`. + - Each candidate is classified as certain-stored, certain-excluded or + uncertain using DAG bounds. The uncertain ones are searched exhaustively, + component by component. +3. **Phase 2: slot allocation.** Let `ref(t)` be the number of `Share(t)` in + the phase-1 output. + - The 1-byte tier (indices 0–7) gets a set of at most 8 stored terms that + is closed under body references and has the maximum total `ref`. + Among such sets, it is the first in the order (`ref` descending, ID + ascending). + - Those terms come first, in the pinned order: stored descendants first, + then larger in-degree, then smaller ID. + - The rest follow in the Kahn priority order: repeatedly, the available + entry with the largest `ref`, ties broken by the smaller ID. + - If this order's reference cost `Σ ref · width` exceeds the phase-1 + order's, the phase-1 order is kept. +4. **Phase 3: re-materialization.** Each entry is re-encoded at minimum + length against the entries before it, with every `Share` priced at its + real TagN width. The roots are re-encoded against the whole table. An + occurrence may now be written inline instead of shared. +5. **Width selection.** The canonical result is the one of the three + (one per `w`) with the fewest real bytes, ties going to the lower `w`. + An error at any width fails the whole construction, with the error of + the lowest failing width. + +**Run-time checks.** Each candidate is checked as it is built, and a failed +check is an internal error, never a different table. Lean builds and checks +all three candidates. Phase 3's checks (`rematerialize`) are, in order: the +layout length equals the evaluated length; it is at most phase 1's layout +length; the output re-expands, through the same interner, to the stored terms +and to the input's root IDs; and every output expression is in the wire +domain. On a DAG of at least 1,024 terms the three widths run as parallel +tasks (`tieredCandidates`; `tieredCandidates_eq` proves the result and the +error order equal to the sequential run). Rust's default mode, which the +compiler uses, applies every limit and every length check of phases 1 to 3 +to all three candidates, but builds only the returned candidate's expressions +and checks those: their layout price, their re-expansion and node count, and +their serialized length. Its checked mode (`ExactSharingLimits::full_check`, +used by the unit tests, the FFI parity hooks and `sharing_corpus +--full-check`) builds and checks all three; over all of Init and all of +Mathlib it returns the same output as the default mode. The exact list is the +"Checks" section of the module documentation of +`crates/ixon/src/sharing_exact/tiered.rs`. + +**Limits.** The construction runs under explicit resource limits (Lean +`Ix.Sharing.Exact.Limits`, Rust `ExactSharingLimits`). They are a safety net, +not part of the definition: they decide whether a run succeeds, never which +bytes a success produces. The defaults are far above every value observed on +the Init and Mathlib corpora. Each limit is at least 2^6 (Lean) or 2^8 (Rust) +times the earlier default under which those corpora were measured, for +example `states` 2^40 and `materialize_work` 2^56. `knapsack_cells` is 2^28 in +both languages, about 27 times the largest table-count knapsack of any width +on Init and Mathlib (9,959,424 cells). The number of sharing candidates is +recorded but not limited on this path in either language: Rust's +`candidates` limit (2^16) bounds only the exhaustive width-state search kept as +a test oracle, which is also the only meter of `transitions`. + +`ix compile --sharing-limits SPEC` (also `ix compile-lean --sharing-limits`) +overrides the defaults. It sets the `IX_SHARING_LIMITS` environment variable, +which both compilers read once per run: Rust once per compile or decompile +entry point (`CompileState::sharing_limits`), Lean in `compileEnvParallelAux` +and `decompileEnvFullParallel`. An invalid value therefore fails the run once, +before any block is shared. `SPEC` is a comma-separated list of items, each +`key=value` or the word `unbounded` (every production limit at its maximum). A +value is ASCII decimal digits (no sign, no `_` separator), `2^k` with +`k ≤ 63`, or `max` (2^64 − 1). Items, keys and values are trimmed of spaces, +tabs, line feeds and carriage returns only. The keys are the limit names of +either implementation (for example `states`, `depth`, `materialize_work`, +`distinct_nodes`); keys of the other language are accepted and ignored, so one +string serves both compilers. One list of 35 specifications pins both parsers +(`LIMIT_SPEC_PARITY` in `crates/ixon/src/sharing_exact/tests.rs`, +`limitSpecParity` in `Tests/Ix/SharingExact.lean`). + +Exceeding a limit is a compile error (`CompileError.resourceLimit`) that +names the limit's key and the override, for example `canonical sharing: +resource exhausted: states (limit 1099511627776); raise it with +--sharing-limits states=N (IX_SHARING_LIMITS)`. Every other construction +failure is `CompileError.sharingConstruction`. In Rust, kernel egress and the +decompiler's recompile name the constant in the message (`egress '': +…`, `recompile of '' (sharing): …`). There is no fallback to another +construction, and a partial or best-so-far table is never emitted. + +### What is proved, and what is not + +The following theorems are machine-checked in Lean. They are roots of the +compiler audit manifest `Ix/Compile/Verify/Audit/Statements.lean` (250 roots at +this PR's head), which `lake build IxCompileVerify` checks: every root +uses exactly its listed axioms, and no declaration of `Ix.Compile.Verify` or +`Ix.Sharing` uses `sorry`. The construction theorems are stated for a +successful run on the canonical DAG of the input (`ex.dag`, `ex.roots`); the +step that builds that DAG is outside them (see "Expansion" below). + +- **Phase 1 minimality** (`Ix/Compile/Verify/UniformOptimality.lean`): + `optimizeUniform_minimum` and `optimizeUniform_least`. Suppose + `optimizeUniformExpanded w limits ex` succeeds with the default + branch-and-bound search (`limits.uniformSubsetSearch = false`; the + compiler cannot change it). Then: + - its stored set minimizes the uniform-width length `ulen` over all stored + sets of terms with in-degree at least 2; + - its `modelBytes` is that minimum; + - it is the `setPrec`-least such minimum. + + The certain-excluded rule needs every telescope spine to be shorter than + `teleSubaddEnd` (the fifth TagN rung end for `f = 4`, 4,311,811,080). The + optimizer checks this before it runs and otherwise fails with a format + error, so the theorems carry no extra hypothesis. +- **Phase 2** (`TieredTier.lean`: `allocate_spec`, `firstTier_spec`; + `TieredGuard.lean`: `allocate_optimal`): + - the first tier is a maximum-`ref` set of at most 8 terms closed under + body references, and the first such set in the tie order; + - the final order is a permutation of the phase-1 table in which every + entry's body references come before it; + - it is the phase-1 order when the guard kept that order, and otherwise + the first tier followed by the Kahn order; + - its reference cost is at most that of the phase-1 order; + - when the table has at most 1,032 entries, so that every index from 8 on + has width 2, its reference cost `Σ ref · width` is the minimum over all + orders that place every body reference first. +- **Phase 3** (`TieredPhase3.lean`: `materializeTable_min`, + `rematerialize_spec`; `TieredIdem.lean`: `canonicalTiered_reexpand`): + - every entry, and every root, has the minimum layout length among all + writings of its term with its dictionary; + - the output re-expands, against the canonical DAG, to the stored terms + and exactly the input's root IDs; + - entry `k` references only entries below `k`; + - the layout length is at most the phase-1 candidate's. +- **Width selection** (`TieredSelect.lean`: `canonicalTieredCore_select`): the + result has the fewest final layout bytes of the three candidates, and the + lowest width among ties. +- **Serialized length** (`TieredWire.lean`: `canonicalSharingTiered_serialized`; + `canonicalSharingTieredTable_serialized` for roots given with a table): if + `canonicalSharingTiered .tagN roots limits` returns `r`, then the length it + reports, `r.result.variableBytes`, is the length of the table count + (`tag0Size`) plus the serialized length (`serExpr`) of every table entry and + root, and the layout price it minimized, `r.result.modelBytes`, equals it. + So the layout bytes that phase 3 and the width selection minimize are + serialized bytes. +- **Wire validity** (`TieredWire.lean`: `canonicalSharingTiered_format`): + every output entry and root is `wireWF`, the table count is below `2^64`, + and Shares are backward: entry `k` references only entries below `k`, and + roots only table entries. +- **Compiler endpoints** (`buildConstantWithSharing_wireWF` and the + `*_codecWF` theorems of `Ix/Compile/Verify/Compile*Codec.lean`, stated over + the wire-validity theorem): a compiler run either returns a block that is + `wireWF` and decodes exactly from its bytes, or fails with an error that + the sharing builder returns (`SharingRunOK`; the builder's payload in that + case is existentially quantified, so the theorem does not say it is this + block's). +- **Structural IDs** (`SharingExactCanon.lean`: `canonicalize_det`): two + interner outputs that pass the interner's checks, are hash-consed and + whose roots denote the same terms canonicalize to the same DAG and root + IDs. +- **Integers**: the TagN theorems of [Integer Encoding](#integer-encoding-tagn). + +**Compiled code.** The compiler runs faster bodies than the specifications +the theorems describe. Each fast twin is attached to its specification by a +`@[csimp]` theorem `@f = @fFast`, an unconditional equality over every input +(results, metered counts and errors), so compiled code calls the twin while +every theorem keeps talking about the specification; the module map of +`Ix/Sharing/Exact.lean` lists them. The audit module +`Ix/Compile/Verify/Audit/CompiledCode.lean` fails the build unless every +`@[csimp]` theorem of an `Ix` module on the compiler's import path is an audit +root (19 at this PR's head), and unless no declaration of `Ix.Sharing.*` is +`unsafe`, `partial`, `@[implemented_by]` or `@[extern]`, except the +interner's pointer-cache key `exprPtr`. + +**Role of the run-time checks.** The phase-3 checks listed under +[Canonical construction](#canonical-construction) stay in the code: the +layout length against the evaluated length and against phase 1, the +re-expansion to the stored terms and the input's root IDs, and the wire +domain (`phase3_le_phase1` proves that the comparison with phase 1 never +fails). Rust runs every check listed in the module documentation of +`sharing_exact/tiered.rs`. The theorems are stated for successful runs, so a +failing check turns a run into an error, never into a different table. + +Not claimed: + +- **No global minimum.** The canonical table is not a global byte minimum + over all tables, orders and occurrence choices. Each phase is exact for + its own problem; their composition is not claimed to be optimal. +- **Phase 2 on larger tables.** For tables of more than 1,032 entries, whose + indices span the 2- and 3-byte rungs, the Kahn order is not claimed to + minimize `Σ ref · width`. +- **Expansion.** The step from the input expressions to the canonical DAG + (`expand`: share expansion and interning, with a pointer cache keyed by + `exprPtr`, an `unsafe` address read) is not covered: no theorem states + that the DAG denotes the input expressions. The round trip to the input is + therefore proved only relative to that DAG; the run-time re-expansion + check uses the same interner, so it does not check the expansion + independently. Logically `exprPtr` is an arbitrary function of the + expression; no theorem inspects it, so the theorems hold whatever addresses + a run sees. Independence from in-memory pointer sharing is tested, not + proved: in `exact-sharing`, pool-shared, deserialized, DAG-shared and + re-encoded inputs give identical bytes under the tiered construction and + the exact search (120 generated inputs). +- **Idempotence** is proved only under the hypothesis that expanding the + output yields the input's canonical DAG and root IDs + (`canonicalSharingTieredTable_idem`). It is tested: re-running the Rust + construction on every stored constant of the Init and Mathlib files + compiled at this PR's head reproduces the stored bytes. +- **Rust.** The Rust implementation is not proved. It is checked against + Lean by differential tests (`exact-sharing-ffi`; with `IX_SHARING_CORPUS` + it runs over a whole `.ixe`). Its phase-1 search evaluates each + component's area under a truncated cost model, where Lean's specification + evaluates the component's whole closure; the outputs are equal on every + input tested. On corpora compiled with `ix compile` at this PR's head, + with Rust in its checked mode, Lean and Rust produce the same bytes for + all 56,622 Init constants and for all 20,284 constants of a Mathlib sample + (every 50th constant, plus every constant with more than 2,000 + candidates), with no resource exhaustion on either side. The merge-queue + suite `lake test -- --ignored compile` compiles every constant of its test + environment (237,295) with the Lean and the Rust compiler and requires + identical serialized environments + ([performance](sharing-minimum-performance.md)). +- **Length range in Rust.** Lean computes lengths with arbitrary-precision + `Nat`. Rust's phase 1 uses 128-bit length arithmetic and fails closed + (`format bound: LengthOverflow`) on an input whose phase-1 lengths leave + that range, where Lean succeeds: for example the chain + `e(i+1) = App(e(i), e(i))` at depth 127 or more (at depth 126 both give the + same bytes). No Init or Mathlib constant comes near this bound. This is a + known divergence of the two implementations. +- **Failure.** The theorems describe successful runs. A run that exceeds a + limit returns an error. ### Example -Before sharing: -``` -App( - Lam(Nat, Lam(Nat, App(add, Var(1), Var(0)))), - App( - Lam(Nat, Lam(Nat, App(add, Var(1), Var(0)))), // Duplicate! - zero - ) -) -``` +`T2 → T2`, where `T2 = Prop → Prop → Prop`, is a fixture from +`docs/sharing-minimum.md` §2. As an axiom with `univs = [Zero]`, so that +`Sort(0)` is `Prop`, the unshared constant is 20 bytes: + +``` +D2 00 00 -- N4(0xD, 2) Axiom, not unsafe, lvls = 0 +93 17 92 17 00 17 00 00 17 -- typ: one All telescope of 3 binders + 00 17 00 00 +00 -- sharing: N0(0) +00 -- refs: N0(0) +01 00 -- univs: N0(1), Zero +``` + +The canonical construction stores `T2` once and gives 17 bytes: + +``` +D2 00 00 -- N4(0xD, 2) Axiom, not unsafe, lvls = 0 +91 17 B0 B0 -- typ: All(Share(0), Share(0)); the body Share + -- ends the telescope +01 -- sharing: N0(1) +92 17 00 17 00 00 -- entry 0 = T2 = All(Sort 0, All(Sort 0, Sort 0)) +00 -- refs: N0(0) +01 00 -- univs: N0(1), Zero +``` + +The bytes were produced by `normalizeConstantSharingTiered .tagN`, and the +`exact-sharing` suite checks them. The compilers' sharing builders +(`Ix.CompileM.buildConstantWithSharing`, Rust +`apply_sharing_to_axiom_with_limits`) build the same bytes from the unshared +constant (`exact-sharing-ffi`). Every integer here is below the first TagN +rung end, so v3's integer codes would write the same bytes for this table. + +### Sharing in metadata expressions + +Metadata expressions are the entries of `ConstantMeta.metaSharing`: the +compiled call-site arguments that call-site surgery collapsed, and rewritten +call-site heads. A `Share(i)` inside them is read in an extended index +space. This is a reader rule; it adds no bytes. Let `p` be the size of the +primary `sharing` table (for a projection, the table of its `Muts` block) +and `q` the size of `metaSharing`. + +- **Primary expressions** (roots and primary entries): `Share(i)` is + `sharing[i]` and needs `i < p`. Metadata never changes how primary bytes + decode. +- **Inside `metaSharing[j]`:** + - `Share(i)` with `i < p` is primary entry `i`. Shares nested inside that + entry are again primary. + - `Share(i)` with `p ≤ i < p + j` is `metaSharing[i − p]`, read in the + scope of entry `i − p`. + - Any other index is rejected: `i ≥ p + q` is out of range, and + `p + j ≤ i < p + q` is a forward or self reference. + + Every metadata-to-metadata step goes to a lower entry, so expansion + terminates. +- **Call-site references.** `CallSiteEntry.collapsed sharingIdx` and + `origHead = some (sharingIdx, _)` index `metaSharing` directly, not offset + by `p`, and read that entry in its own scope. + +Both decompilers implement the rule: Lean `Ix.DecompileM` (`ShareScope`, +`resolveShareIn`) and Rust `ix_compile::decompile` (`ShareScope`). When a +constant's metadata is loaded, they check the whole table first +(`validateMetaSharing`, Rust `validate_meta_sharing`): every `Share(i)` +occurring in `metaSharing[j]` must have `i < p + j`. The first violation, in +entry order and then left-to-right pre-order, is reported as +`invalidMetaShareIndex` (Rust `DecompileError::InvalidMetaShareIndex`, +error tag 11). An out-of-range index in a primary expression, or an +out-of-range call-site `sharingIdx`, is `invalidShareIndex`. The +semantic-contract scan (`Ix.SemanticContract.containsIxon`, Rust +`semantic_contract::contains_ixon`) expands Shares with the same scopes. +Kernel ingress, the IxVM circuit and the resource validators do not read +`metaSharing` contents. Two older gaps remain: a call site nested inside a +metadata expression may reference any `metaSharing` entry, including its own, +and neither the decompilers nor kernel ingress check that primary entries +reference only earlier entries. A malformed table of either kind can make +them loop instead of failing; hardening the readers against malformed input +is follow-up work. + +The primary table is built first and never depends on metadata. No compiler +emits a `Share` in metadata expressions, and there is no canonical metadata +construction. On Mathlib, metadata expressions total 42,929 bytes (0.0013% +of the environment file), and no metadata expression contains a `Share` +([measurements](sharing-minimum-measurements.md#metasharing)). -After sharing: -``` -sharing[0] = Lam(Nat, Lam(Nat, App(add, Var(1), Var(0)))) - -App( - Share(0), - App(Share(0), zero) -) -``` --- @@ -690,22 +1037,57 @@ pub enum ExprMetaData { } ``` -**ExprMetaData Serialization** (tags 0-9, with BinderInfo packed into Binder tags): - -| Tag | Variant | Payload | -|-----|---------|---------| -| 0 | Leaf | (none) | -| 1 | App | children: [u64, u64] | -| 2 | Binder (Default) | name_idx + children: [u64, u64] | -| 3 | Binder (Implicit) | name_idx + children: [u64, u64] | -| 4 | Binder (StrictImplicit) | name_idx + children: [u64, u64] | -| 5 | Binder (InstImplicit) | name_idx + children: [u64, u64] | -| 6 | LetBinder | name_idx + children: [u64, u64, u64] | -| 7 | Ref | name_idx | -| 8 | Prj | struct_name_idx + child: u64 | -| 9 | Mdata | kvmap_count + kvmaps + child: u64 | - -Packing BinderInfo into the Binder tag (tags 2-5) saves 1 byte per binder. Name addresses are serialized as indices into a `NameIndex` for compactness. +**ExprMeta serialization.** An arena is `N0(len)` followed by its nodes in +index order. Node `i` starts with a tag byte `kind << 3 | mask`; the fields +follow in declaration order: + +| kind | Variant | Payload (in order) | structural slots | +|-----|---------|---------|---| +| 0 | Leaf | (none) | — | +| 1 | App | fun?, arg? | fun, arg | +| 2–5 | Binder (2 + BinderInfo: Default, Implicit, StrictImplicit, InstImplicit) | name_idx, type?, body? | type, body | +| 6 | LetBinder | name_idx, type?, value?, body? | type, value, body | +| 7 | Ref | name_idx | — | +| 8 | Prj | struct_name_idx, child? | child | +| 9 | Mdata | kvmap_count + kvmaps, child? | child | +| 10 | CallSite | name_idx, entries, canon_meta, orig_head | — | +| 11 | EtaCallSite | n_synth, name_idx, entries, canon_meta, wrapper_meta | — | + +Child references are never absolute indices: + +- **Implicit (post-order) children.** Bit `s` of `mask` set means + structural slot `s` is not written: it is the node a post-order cursor + expects. The cursor `top` starts at `i` and visits the slots last to + first; an implicit slot is node `top − 1`, after which `top` becomes + `lo[top − 1]`, and `lo[i]` is `top` after the last slot (the first index + of node `i`'s contiguous post-order block; `lo[i] = i` for a node without + structural slots). The compiler allocates the arena bottom-up in + post-order, so an unshared subtree costs one tag byte per App and no + child bytes at all. +- **Explicit references.** A structural slot whose bit is clear (a shared + node: an expression-cache hit, or any other position), and every + call-site reference (entry `meta`, `canon_meta`, `orig_head` meta, + `wrapper_meta`), is `N0` of the backward delta `(i − 1 − c) mod 2^64`. + Forward references are representable (they wrap), so every arena of + `u64` indices has an encoding. +- **One encoding per arena.** The writer marks a slot implicit exactly + when its child is `top − 1`; the reader rejects an explicit slot equal to + `top − 1`, an implicit slot with `top = 0`, mask bits beyond the kind's + slot count, and kinds above 11. + +The decoded arena (absolute `u64` indices) is identical to the one the +compiler built, so readers of `ExprMeta` see no difference. + +Example: `fun (x : T) => f x` allocated as `[Ref T, Ref f, Leaf, App(1, 2), +Binder(x, Default, [0, 3])]` serializes (name indices `T = 1`, `f = x = 0`) +to `05 38 01 38 00 00 0B 13 00`: both App children and both Binder children +are implicit (`0B = 1 << 3 | 0b11`, `13 = 2 << 3 | 0b11`). Sharing the leaf +in `[Leaf, App(0, 0)]` gives `02 00 0A 00`: the argument is implicit, the +function an explicit delta `1 − 1 − 0 = 0`. + +Name addresses are serialized as indices into a `NameIndex` for +compactness. Measurements and the design are in +[`sharing-minimum-arena.md`](sharing-minimum-arena.md). ### ConstantMeta @@ -728,11 +1110,12 @@ pub struct UnivPatch { } ``` -Each wrapper vector serializes as a `Tag0` count + entries and is +Each wrapper vector serializes as an `N0` count + entries and is empty (one zero byte) on most constants. `meta_univs`/`univ_patches` restore source level spellings the §10.6 canonicalization displaced from content; `meta_sharing` holds call-site surgery's collapsed -arguments. Each `ConstantMetaInfo` variant stores a name, universe +arguments, whose `Share` references use the extended index space of +[Sharing in metadata expressions](#sharing-in-metadata-expressions). Each `ConstantMetaInfo` variant stores a name, universe parameter names, an `ExprMeta` arena, and root indices pointing into the arena: @@ -762,7 +1145,7 @@ pub enum ConstantMetaInfo { | 3 | Indc | name_idx, lvl_idxs, ctor_idxs, all_idxs, ctx_idxs, arena, type_root | | 4 | Ctor | name_idx, lvl_idxs, induct_idx, arena, type_root | | 5 | Rec | name_idx, lvl_idxs, rule_idxs, all_idxs, ctx_idxs, arena, type_root, rule_roots | -| 6 | Muts | class count (Tag0) + per-class name-idx vecs, then `Option` | +| 6 | Muts | class count (N0) + per-class name-idx vecs, then `Option` | | 255 | Empty | (none) | **`AuxLayout`** (the `Muts` sidecar — nested-auxiliary layout for @@ -772,9 +1155,9 @@ only, never entering any content hash): ``` 0x00 -- None (no nested auxes) 0x01 -- Some, followed by: - perm count (Tag0) + [Tag0]* -- perm[sourceJ] = canonicalI - ctor-count count (Tag0) + [Tag0]* -- per-source-position aux ctor counts - evaporated count (Tag0) + [u8]* -- one 0/1 flag per perm entry + perm count (N0) + [N0]* -- perm[sourceJ] = canonicalI + ctor-count count (N0) + [N0]* -- per-source-position aux ctor counts + evaporated count (N0) + [u8]* -- one 0/1 flag per perm entry ``` The three vectors always serialize together (one unified format), and @@ -858,8 +1241,8 @@ pub enum NameData { ``` Tag (1 byte): 0 = Anonymous, 1 = Str, 2 = Num + (if Str/Num) parent_address (32 bytes) -+ (if Str) string_len (Tag0) + UTF-8 bytes -+ (if Num) nat_len (Tag0) + little-endian bytes ++ (if Str) string_len (N0) + UTF-8 bytes ++ (if Num) nat_len (N0) + little-endian bytes ``` Names are topologically sorted in the environment so parents are serialized before children, enabling reconstruction during deserialization. @@ -869,26 +1252,40 @@ Names are topologically sorted in the environment so parents are serialized befo Serialized environments are stored on disk with the **`.ixe`** file extension (e.g., `compilemathlib.ixe`). The `ix compile` CLI produces these files; the default output name is the lowercased input file stem -plus `.ixe`. See `src/ix/ixon/serialize.rs::Env::put` for the +plus `.ixe`. See `crates/ixon/src/serialize.rs` (`Env::put`) for the byte-level layout. -The .ixe layout is a `Tag4(0xE, VERSION)` header byte followed by a +The .ixe layout is an `N4(0xE, VERSION)` header byte followed by a 32-byte canonical merkle root, the bundle header fields, and then 6 sections (hot data first, metadata last). -The format has the stable identifier `ixon-v3`. The Tag4 size field is the -numeric **format version** (`Env::VERSION`, currently `3`, so the first byte -of a v3 file is `0xE3`). Any change +The format has the stable identifier `ixon-v4`. The header value is the +numeric **format version** (`Env::VERSION`, currently `4`, so the first byte +of a v4 file is `0xE4`). Any change to serialized bytes bumps the version; every reader (`read_env_header` on the Rust side, `Ixon.getEnv` / `getEnvVerifiedLazy` on the Lean side) rejects a mismatch with an error naming both versions and asking for a recompile. There is no back-compat reading of old versions — `.ixe` files are regenerated -artifacts. Versions 0–7 cost zero additional bytes (inline Tag4 -size); later versions cost a trimmed varint. +artifacts. Versions 0–7 fit in the header byte; later versions use the +multi-byte TagN rungs. + +Format version 4 also sets the object-format byte of claims, proofs and +catalog manifests (`Ixon.Env.OBJECT_FORMAT`, Rust `Env::OBJECT_FORMAT`, equal +to the version). Artifacts that cache `.ixe` files key them by the version: +the TruthMines piece cache includes `ixe=` in its key, and the test +environment `tc-parity.ixe` is recompiled when its header carries another +version. + +The version-4 header byte `0xE4` is the same byte as the Check claim tag +`N4(0xE, 4)` (see [Proofs and Claims](#proofs-and-claims)), just as +version 3's `0xE3` was the same byte as the Eval claim tag. Readers decide +what the byte means from context: an `.ixe` reader expects an environment +header and a claim reader expects a claim. The byte alone does not identify +the object kind. ``` -Header: Tag4 { flag: 0xE, size: VERSION } -- 0xE3 for version 3 +Header: N4(0xE, VERSION) -- 0xE4 for version 4 Root: 32 bytes -- canonical merkle root over consts.keys(); for empty const sets this is the @@ -897,7 +1294,7 @@ Root: 32 bytes -- canonical merkle root over Main: 1 byte (0x00 | 0x01) + 32 bytes if 0x01 -- optional bundle root; see "Bundles" below. -Assumptions: count (Tag0) + [Address (32 bytes)]* +Assumptions: count (N0) + [Address (32 bytes)]* -- strictly ascending; the bundle trust boundary. ``` @@ -917,8 +1314,8 @@ root `AssumptionTree::canonical` produces over the same leaves). **Section 1: Blobs** (Address → raw bytes) ``` -count (Tag0) -[Address (32 bytes) + len (Tag0) + bytes]* +count (N0) +[Address (32 bytes) + len (N0) + bytes]* ``` Every reader verifies `blake3(bytes) == addr` per blob entry — a @@ -927,22 +1324,22 @@ value under an otherwise-valid file. **Section 2: Constants** (Address → length-prefixed Constant bytes) ``` -count (Tag0) -[Address (32 bytes) + len (Tag0) + Constant bytes (Tag4-bounded)]* +count (N0) +[Address (32 bytes) + len (N0) + Constant bytes]* ``` -The Tag0 length sidecar is a **section-level** framing byte: it is not +The `N0` length sidecar is a **section-level** framing integer: it is not part of the constant's content-addressed bytes. The address is -computed as `blake3` over only the Tag4 constant body (verified per +computed as `blake3` over only the constant bytes (verified per entry on load). This layout lets a lazy loader slice each constant directly into a [`LazyConstant`](../crates/ixon/src/lazy.rs) without -parsing its Tag4 envelope, deferring full deserialization until first +parsing its header, deferring full deserialization until first access. **Section 3: Reducibility hints** (§2 index → ReducibilityHints) ``` -count (Tag0) -- must be ≤ the §2 count -[index_delta (Tag0) + fused_hint (Tag0)]* +count (N0) -- must be ≤ the §2 count +[index_delta (N0) + fused_hint (N0)]* ``` The **anon hint channel** — merged advisory hints per constant @@ -953,7 +1350,7 @@ constant index is `idx_k = idx_{k-1} + delta_k` with `idx_{-1} = -1` (so the first delta stores `index + 1`). Every delta must be ≥ 1, which makes the section strictly ascending and duplicate-free by construction; an index ≥ the §2 count is malformed. The hint fuses -variant and height into one Tag0 value: `0` = Opaque, `1` = Abbrev, +variant and height into one `N0` value: `0` = Opaque, `1` = Abbrev, `h + 2` = Regular(h) with `h : u32`. A typical entry is 2-3 bytes (previously a 32-byte address + 1-3 bytes). @@ -970,18 +1367,18 @@ and are intentionally outside the consts merkle root. **Section 4: Names** (Address → NameComponent, topologically sorted) ``` -count (Tag0) +count (N0) [Address (32 bytes) + NameComponent]* ``` **Section 5: Named** (name §4-index → Named with indexed metadata) ``` -count (Tag0) -[ name_idx (Tag0) -- absolute index into §4's topo order - const_idx (Tag0) -- absolute index into §2's ascending order - hint (Tag0) -- fused option: 0 = none, 1 = Opaque, +count (N0) +[ name_idx (N0) -- absolute index into §4's topo order + const_idx (N0) -- absolute index into §2's ascending order + hint (N0) -- fused option: 0 = none, 1 = Opaque, 2 = Abbrev, h+3 = Regular(h) - meta_len (Tag0) -- byte length of the metadata blob below + meta_len (N0) -- byte length of the metadata blob below ConstantMeta -- name references are §4 indices original: 0x00 | 0x01 + Address (32 bytes) + ConstantMeta ]* -- ConstantMeta + original span meta_len bytes @@ -1014,7 +1411,7 @@ recompute, with no re-sort). **Section 6: Commitments** (Address → Comm) ``` -count (Tag0) +count (N0) [Address (32 bytes) + secret_addr (32 bytes) + payload_addr (32 bytes)]* ``` @@ -1156,7 +1553,7 @@ fixed-width little-endian like `.ixes`; source of truth magic b"IXC\0\0\0\0\0" (8) version u32 = 2 flags u32 # bit0: storage profile (0 = fat, 1 = chunked) -object_format u8 = 3 # ixon-v3 +object_format u8 = 4 # ixon-v4 validator u8 = 1 # erased-lean-v1 catalog claims members_root 32 bytes content_root 32 bytes @@ -1196,23 +1593,28 @@ source of truth). The `Catalog` claim (below) binds both roots. ## Proofs and Claims Envs, commitments, the AssumptionTree data type, and all claims share -Tag4 flag 0xE. Proofs (opaque ZK bytes) share Tag4 flag 0xF. Sizes -0..=7 fit in single-byte tags. Catalog (variant 8) and Resource (variant 9) -use `0xE8 0x08` and `0xE8 0x09`. Environment tags are interpreted in -the `.ixe` context: the v3 environment header is `0xE3`, independently of -the Eval claim tag. The enclosing protocol must identify the object kind. - -Every claim and proof payload starts with two bytes immediately after Tag4: -object format `3`, then validator `0` (structural-v1), `1` (erased-lean-v1), -or `2` (resource-v1). Readers require the validator assigned to that variant. -Whole-object readers reject trailing bytes and earlier unscoped encodings. -These bytes are included in the claim digest and proof statement. - -### Tag4 0xE Variant Layout (Env + Comm + AssumptionTree + Claims) - -| Size | Byte | Type | Payload | +the `f = 4` flag 0xE. Proofs (opaque ZK bytes) share flag 0xF. Values +0..=7 fit in single-byte headers. Catalog (variant 8) and Resource +(variant 9) are in TagN's two-byte rung: `0xE8 0x00` and `0xE8 0x01`. +Environment headers are interpreted in the `.ixe` context: the v4 +environment header is `0xE4`, the same byte as the Check claim tag. The +enclosing protocol must identify the object kind. + +Every claim and proof payload starts with two bytes immediately after its +header: object format `4`, then validator `0` (structural-v1), +`1` (erased-lean-v1), or `2` (resource-v1). Readers require the validator +assigned to that variant. Whole-object readers reject trailing bytes and +earlier unscoped encodings. These bytes are included in the claim digest +and proof statement. A claim with another object format is rejected with +`claim: unsupported object format N, expected 4 — regenerate the claim` +(catalog manifests likewise: `catalog: unsupported object format N, expected +4 — regenerate the catalog`). + +### Flag 0xE Variant Layout (Env + Comm + AssumptionTree + Claims) + +| Value | Bytes | Type | Payload | |------|------|------|---------| -| 3 (format) | `0xE3` | Environment (`.ixe` context) | 32-byte merkle root + main/assumptions + 6 sections | +| 4 (format) | `0xE4` | Environment (`.ixe` context) | 32-byte merkle root + main/assumptions + 6 sections | | 1 | `0xE1` | Commitment | 2 addr: secret, payload | | 2 | `0xE2` | AssumptionTree | recursive merkle-tree body (see below) | | 3 | `0xE3` | Eval claim | 2 addr (input, output) + opt assumptions | @@ -1220,8 +1622,8 @@ These bytes are included in the claim digest and proof statement. | 5 | `0xE5` | CheckEnv claim | 1 addr (env root) + opt assumptions | | 6 | `0xE6` | Reveal claim | 1 addr (comm) + RevealConstantInfo | | 7 | `0xE7` | Contains claim | 2 addr (tree, const) | -| 8 | `0xE8 0x08` | Catalog claim | 2 addr (members root, content root) + opt assumptions | -| 9 | `0xE8 0x09` | Resource claim | 2 addr (complete env root, resource profile) | +| 8 | `0xE8 0x00` | Catalog claim | 2 addr (members root, content root) + opt assumptions | +| 9 | `0xE8 0x01` | Resource claim | 2 addr (complete env root, resource profile) | The claim payloads in this table follow the two scope bytes. Reveal and Contains require validator `0`; Eval, Check, CheckEnv, and Catalog require @@ -1239,17 +1641,17 @@ exact wire bytes are pinned by twin tests digest-parity test) so the Rust and Lean serializers cannot drift on the multi-byte-tag path. -### Tag4 0xF Variant Layout (Proofs) +### Flag 0xF Variant Layout (Proofs) -| Size | Byte | Type | Payload | +| Value | Byte | Type | Payload | |------|------|------|---------| -| 0 | `0xF0` | Eval proof | claim payload + Tag0 length + opaque ZK bytes | -| 1 | `0xF1` | Check proof | claim payload + Tag0 length + opaque ZK bytes | -| 2 | `0xF2` | CheckEnv proof | claim payload + Tag0 length + opaque ZK bytes | -| 3 | `0xF3` | Reveal proof | claim payload + Tag0 length + opaque ZK bytes | -| 4 | `0xF4` | Contains proof | claim payload + Tag0 length + opaque ZK bytes | -| 5 | `0xF5` | Catalog proof | claim payload + Tag0 length + opaque ZK bytes | -| 6 | `0xF6` | Resource proof wrapper | claim payload + Tag0 length + opaque proof bytes | +| 0 | `0xF0` | Eval proof | claim payload + N0 length + opaque ZK bytes | +| 1 | `0xF1` | Check proof | claim payload + N0 length + opaque ZK bytes | +| 2 | `0xF2` | CheckEnv proof | claim payload + N0 length + opaque ZK bytes | +| 3 | `0xF3` | Reveal proof | claim payload + N0 length + opaque ZK bytes | +| 4 | `0xF4` | Contains proof | claim payload + N0 length + opaque ZK bytes | +| 5 | `0xF5` | Catalog proof | claim payload + N0 length + opaque ZK bytes | +| 6 | `0xF6` | Resource proof wrapper | claim payload + N0 length + opaque proof bytes | Proof bytes are uniform opaque ZK proofs — witness data (e.g., merkle paths for Contains) is prover-side scratch consumed by the ZK circuit @@ -1296,7 +1698,7 @@ odd-count levels so the byte-tree matches `merkle_root_canonical`'s zero-mixing shape (a `Padding` hashes to `zero_address()`). ``` -[Tag4(0xE, 2) = 0xE2] [body] +[N4(0xE, 2) = 0xE2] [body] body recursive: Leaf(addr): [0x00] [addr:32] @@ -1306,12 +1708,12 @@ body recursive: Size is shape-dependent: each `Leaf` is 33 bytes, each `Padding` is 1 byte, each `Node` is 1 byte plus its children, and the top-level -`Tag4` adds 1 byte. For example, `N = 1` ⇒ 34 bytes; `N = 2` ⇒ 68 +header `0xE2` adds 1 byte. For example, `N = 1` ⇒ 34 bytes; `N = 2` ⇒ 68 bytes; `N = 3` (padded to 4) ⇒ 104 bytes. ### Commitment Hashing -Commitments are serialized with Tag4(0xE, 1) and hashed with blake3: +Commitments are serialized with `N4(0xE, 1)` (byte `0xE1`) and hashed with blake3: ``` commitment_address = blake3(0xE1 + secret_address + payload_address) ``` @@ -1323,9 +1725,9 @@ Two commitments to the same constant share the same payload address. The Reveal claim allows selective revelation of constant metadata fields (kind, safety, idx, etc.) without opening the full commitment. -Serialization: `variant (1 byte) + field_mask (Tag0) + field values...` +Serialization: `variant (1 byte) + field_mask (N0) + field values...` -The field_mask uses Tag0 encoding (1 byte for masks < 128). Fields are +The field_mask is an `N0` integer (1 byte for masks < 128). Fields are serialized in mask bit order. Expression fields are revealed as `Address = blake3(serialized Expr bytes)`. @@ -1342,8 +1744,8 @@ pub struct Proof { **Eval claim** (0xE3, 2 addresses + opt assumptions byte): ``` -E3 -- Tag4 { flag: 0xE, size: 3 } (Eval) -03 01 -- object format 3, erased-lean-v1 +E3 -- N4(0xE, 3) (Eval) +04 01 -- object format 4, erased-lean-v1 [32 bytes] -- input address [32 bytes] -- output address 00 -- assumptions = None (or 01 + [32 bytes] for Some) @@ -1351,43 +1753,60 @@ E3 -- Tag4 { flag: 0xE, size: 3 } (Eval) **Eval proof** (0xF0, claim payload + opaque ZK bytes): ``` -F0 -- Tag4 { flag: 0xF, size: 0 } (Eval proof) -03 01 -- object format 3, erased-lean-v1 +F0 -- N4(0xF, 0) (Eval proof) +04 01 -- object format 4, erased-lean-v1 [32 bytes] -- input address [32 bytes] -- output address 00 -- assumptions = None -04 -- proof.len = 4 (Tag0) +04 -- proof.len = 4 (N0) 01 02 03 04 -- opaque ZK proof bytes ``` **Check claim** (0xE4, 1 address + opt assumptions byte): ``` -E4 -- Tag4 { flag: 0xE, size: 4 } (Check) -03 01 -- object format 3, erased-lean-v1 +E4 -- N4(0xE, 4) (Check) +04 01 -- object format 4, erased-lean-v1 [32 bytes] -- const address 00 -- assumptions = None ``` **Reveal claim** — reveal that a committed Definition has `safety = Safe`: ``` -E6 -- Tag4 { flag: 0xE, size: 6 } (Reveal) -03 00 -- object format 3, structural-v1 +E6 -- N4(0xE, 6) (Reveal) +04 00 -- object format 4, structural-v1 [32 bytes] -- comm_addr 00 -- variant: Definition -02 -- mask: bit 1 (safety) [Tag0] +02 -- mask: bit 1 (safety) [N0] 01 -- DefinitionSafety::Safe ``` Total: 38 bytes. **Contains claim** (0xE7, 2 addresses): ``` -E7 -- Tag4 { flag: 0xE, size: 7 } (Contains) -03 00 -- object format 3, structural-v1 +E7 -- N4(0xE, 7) (Contains) +04 00 -- object format 4, structural-v1 [32 bytes] -- tree (merkle root) [32 bytes] -- const address (asserted leaf) ``` Total: 67 bytes. +**Resource claim** (`0xE8 0x01`, 2 addresses): +``` +E8 01 -- N4(0xE, 9) (Resource): two-byte TagN rung +04 02 -- object format 4, resource-v1 +[32 bytes] -- complete env root +[32 bytes] -- resource profile address +``` +Total: 68 bytes. + +The claims fixture `Tests/Fixtures/ixon-v4/claims.tsv` holds the canonical +bytes and BLAKE3 digest of one claim of every variant; its headers and scope +bytes match the claim examples above. `lake exe ixon-v4-tests` compares the file +with the serializers' output, and `--export-fixtures` regenerates it under +`ixon-v4-fixtures/` in the scratch directory `$IX_IXON_V4_DIR` (default +`/tmp`). + + --- ## Compilation (Lean → Ixon) @@ -1414,8 +1833,8 @@ The `compile_expr` function transforms Lean expressions: | `Sort(level)` | `Sort(idx)` | Level added to univs table | | `Const(name, levels)` | `Ref(idx, univ_idxs)` | Name resolved to address | | `Const(name, levels)` in mutual | `Rec(ctx_idx, univ_idxs)` | Uses mutual context | -| `Lam(name, ty, body, info)` | `Lam(many_shared, ty, body)` | Ordinary v3 contract; name/info to metadata | -| `ForallE(name, ty, body, info)` | `All(many_shared, shared, ty, body)` | Ordinary v3 contracts; name/info to metadata | +| `Lam(name, ty, body, info)` | `Lam(many_shared, ty, body)` | Ordinary contract; name/info to metadata | +| `ForallE(name, ty, body, info)` | `All(many_shared, shared, ty, body)` | Ordinary contracts; name/info to metadata | | `LetE(name, ty, val, body, nd)` | `Let({nonDep: nd, kind: value, binder: many_shared}, ty, val, body)` | Name to metadata; ordinary let contract | | `Proj(type, idx, val)` | `Prj(type_idx, idx, val)` | Type name resolved | | `Lit(Nat n)` | `Nat(idx)` | Bytes stored in blobs | @@ -1443,6 +1862,16 @@ During compilation, metadata is extracted into `ExprMetas`: 3. **Create Muts block** with shared tables 4. **Create projections** for each named constant +### Sharing + +Every block, whether a single constant, a mutual block or an aux-gen +block, gets its `sharing` table from the canonical construction of the +[Sharing System](#sharing-system), applied to the block's roots after +`refs` and `univs` are allocated. The metadata arena follows the unshared +expression tree, and a `Share` is transparent to it. Re-sharing a constant +therefore leaves its metadata valid. A construction failure is a compile +error for that block. + --- ## Decompilation (Ixon → Lean) @@ -1456,7 +1885,7 @@ Decompilation reconstructs Lean constants from Ixon format. 3. **Load metadata** from `env.named` 4. **Reconstruct expressions** with committed contracts, and names/binder info from metadata 5. **Resolve references**: `Ref(idx, _)` → lookup `refs[idx]`, get name from `addr_to_name` -6. **Expand shares**: `Share(idx)` → inline `sharing[idx]` (or cache result) +6. **Expand shares**: `Share(idx)` → inline `sharing[idx]` (or cache result). Inside a `meta_sharing` entry, indices at or above the primary table size resolve into earlier `meta_sharing` entries (see [Sharing in metadata expressions](#sharing-in-metadata-expressions)) Nondefault contracts are reconstructed from semantic bytes even without names or optional metadata. Optional metadata cannot inject contracts or replay an @@ -1518,7 +1947,16 @@ Lam(many_shared, Ref(0, []), App(App(Ref(1, []), Var(0)), Var(0))) ``` Binary: `0x81 0x07` (Lam, 1 ordinary binder) + `0x20 0x00` (Ref 0) + `0x72` (App, 2 apps) + `0x20 0x01` (Ref 1) + `0x10` (Var 0) + `0x10` (Var 0) -**Sharing analysis**: `Var(0)` appears twice, but too small to benefit from sharing. +**Canonical sharing**: the two roots are the type and the value. +- `Ref(0, [])` is 2 bytes and occurs three times. Written inline that is + 6 bytes. Stored once (2 bytes) and referenced three times with a 1-byte + `Share(0)`, it is 5 bytes. The table count `N0(1)` is one byte, the same + as `N0(0)`. +- `Var(0)` occurs twice but is one byte, and a `Share` costs at least one + byte, so storing it never pays. + +The canonical table is therefore `[Ref(0, [])]`, and the constant is 84 +bytes instead of the 85 it would take unshared. **Build Constant**: ```rust @@ -1527,10 +1965,10 @@ Constant { kind: Definition, safety: Safe, lvls: 0, - typ: All(many_shared, shared, Ref(0, []), Ref(0, [])), - value: Lam(many_shared, Ref(0, []), App(App(Ref(1, []), Var(0)), Var(0))), + typ: All(many_shared, shared, Share(0), Share(0)), + value: Lam(many_shared, Share(0), App(App(Ref(1, []), Var(0)), Var(0))), }), - sharing: [], + sharing: [Ref(0, [])], refs: [addr_of_Nat, addr_of_Nat_add], univs: [], } @@ -1539,23 +1977,36 @@ Constant { ### Step 3: Serialization ``` -D0 -- Tag4 { flag: 0xD, size: 0 } (Constant, Defn variant) +D0 -- N4(0xD, 0) (Constant, Defn variant) 01 -- DefKind+Safety packed: (Definition=0 << 2) | Safe=1 -00 -- lvls = 0 (Tag0) -91 17 20 00 20 00 -- type: All(Ref(0,[]), Ref(0,[])) -81 07 20 00 72 20 01 -- value: Lam(Ref(0,[]), App(App(Ref(1,[])... +00 -- lvls = 0 (N0) +91 17 B0 B0 -- type: All(Share(0), Share(0)) +81 07 B0 72 20 01 -- value: Lam(Share(0), App(App(Ref(1,[])... 10 10 -- ...Var(0)), Var(0))) -00 -- sharing.len = 0 +01 -- sharing.len = 1 +20 00 -- sharing[0] = Ref(0, []) 02 -- refs.len = 2 [32 bytes] -- refs[0] = addr_of_Nat [32 bytes] -- refs[1] = addr_of_Nat_add 00 -- univs.len = 0 ``` -Total: 21 bytes for the scalar/expression data and table counts, plus -64 bytes for the two addresses: **85 bytes**. +Total: 20 bytes for the scalar/expression data, table counts and table +entry, plus 64 bytes for the two addresses: **84 bytes**. + +Note: The constant header is always 1 byte (0xD0) since every non-Muts +variant (0-7) is below TagN's first rung end of 8. + +`ix compile` writes exactly these bytes. For a file `Double.lean` that +contains only the definition above, `ix compile Double.lean --no-build +--consts double --out double.ixe` stores this 84-byte constant, in hex: -Note: The constant tag is always 1 byte (0xD0) since all non-Muts variants (0-7) fit in the 3-bit size field. +``` +d0 01 00 91 17 b0 b0 81 07 b0 72 20 01 10 10 01 20 00 02 +35e1cc809f6f076521a43f85068d5592220407c0532b6a08952f40d8523d04bc -- Nat +3e8aadcc611c4d8677cadf00c78506561d33738ee3d571f7a4196e260580c9b8 -- Nat.add +00 +``` ### Step 4: Content Address @@ -1563,7 +2014,10 @@ Note: The constant tag is always 1 byte (0xD0) since all non-Muts variants (0-7) address = blake3(serialized_constant) ``` -This address is how `double` is referenced by other constants. +This address is how `double` is referenced by other constants. For the +bytes above it is +`eefff4002f029ee49aa94e8e9127b0b1664c86fec956e62332fd3be1672d0cef` +(`ix addr-of double --ixe double.ixe`). ### Step 5: Metadata @@ -1603,9 +2057,10 @@ To reconstruct the Lean constant: 1. Load `Constant` from `consts[address]` 2. Load `Named` from `named["double"]` -3. Resolve `Ref(0, [])` → `refs[0]` → `Nat` (via `addr_to_name`) -4. Resolve `Ref(1, [])` → `refs[1]` → `Nat.add` -5. Attach names from metadata: the binder gets name "n" from `type_meta[0]` +3. Expand each `Share(0)` to `sharing[0]` = `Ref(0, [])` +4. Resolve `Ref(0, [])` → `refs[0]` → `Nat` (via `addr_to_name`) +5. Resolve `Ref(1, [])` → `refs[1]` → `Nat.add` +6. Attach names from metadata: the binder gets name "n" from `type_meta[0]` Result: Original Lean `ConstantInfo` reconstructed. @@ -1673,7 +2128,7 @@ Constructor { The mutual block uses flag 0xC with entry count in size field: ``` -C1 -- Tag4 { flag: 0xC, size: 1 } (Muts, 1 entry) +C1 -- N4(0xC, 1) (Muts, 1 entry) -- Entry 0: Inductive (Bool) 01 -- MutConst tag 1 = Indc @@ -1728,7 +2183,7 @@ pub struct Comm { The commitment address is computed as: ``` -commitment = blake3(Tag4(0xE, 1) + secret + payload) +commitment = blake3(N4(0xE, 1) + secret + payload) ``` The payload address is the content hash of the committed constant. Two commitments to the @@ -1749,8 +2204,8 @@ Ixon provides a sophisticated serialization format optimized for: | Feature | Mechanism | |---------|-----------| | Deterministic hashing | Alpha-invariance via de Bruijn indices | -| Compact storage | Variable-length tags, telescope compression | -| Deduplication | Merkle-tree sharing within constants | +| Compact storage | One variable-length integer code (TagN), telescope compression | +| Deduplication | Canonical sharing within constants (phase-1 minimality machine-checked) | | Roundtrip fidelity | Separate metadata layer | | Cryptographic proofs | Content-addressed storage, commitments | diff --git a/docs/compilatrix-ixon-v3.md b/docs/compilatrix-ixon-v3.md index 79edd0bf9..8b1d2b498 100644 --- a/docs/compilatrix-ixon-v3.md +++ b/docs/compilatrix-ixon-v3.md @@ -1,23 +1,40 @@ -# Compilatrix handoff: Ixon v3 +# Compilatrix handoff: Ixon v4 This package describes the Ix producer and its checked fragment. Compilatrix has not been changed or tested by this work. Consume the versioned data and validation interfaces below before enabling ownership or locality optimizations. +(The file name keeps the v3 suffix from the handoff that introduced the +contract model.) ## Breaking format -- Environment format: **3**, protocol identity **`ixon-v3`**. -- Twelve expression variants and the existing declaration headers remain. -- Lambda binder contracts use four bits; forall input/result contracts use six. -- Let Tag4 sizes encode `nonDep` in bit 0 and `borrowShared` in bit 1. A binder - byte precedes its type, initializer, and body. -- Catalog manifests use version **2**, with object-format byte `3` and validator - byte `1` after the flags. They describe erased-typing claims. -- Claim and proof payloads include format and validator bytes after Tag4. -- Primitive addresses have changed. Do not reuse v2 pins or infer an object's - version from raw constant bytes. +- **Environment format: 4.** The `.ixe` header byte is `0xE4`, and the + protocol identity is **`ixon-v4`**. Version-3 files and objects are + rejected. +- **One integer code, TagN.** TagN replaces Tag0, Tag2 and Tag4 everywhere + ([Ixon](Ixon.md#integer-encoding-tagn)). Values below 128, 32 or 8 (for + flag widths 0, 2 or 4) encode to the same single byte as in v3. Larger + values encode differently, for example `Share(8)` = `B8 00`. TagN is + bijective, so readers do not perform a non-minimal-integer check. +- **Canonical sharing.** The sharing table and every `Share` occurrence are + part of the canonical bytes, built by the two-phase construction + ([Ixon](Ixon.md#sharing-system)). A consumer that re-encodes a constant + must use the same construction to reproduce its address. +- **Contracts are unchanged from v3.** Twelve expression variants and the + existing declaration headers remain. Lambda binder contracts use four + bits, and forall input/result contracts use six. Let header values (flag + `0xA`) encode `nonDep` in bit 0 and `borrowShared` in bit 1. A binder byte + precedes its type, initializer, and body. +- **Catalogs.** Catalog manifests use version **2**, with object-format byte + `4` and validator byte `1` after the flags. They describe erased-typing + claims. +- **Claims and proofs.** Their payloads include format and validator bytes + after the header. The Catalog and Resource claim headers are `E8 00` and + `E8 01`. +- **Primitive addresses** have changed. Do not reuse v3 pins or infer an + object's version from raw constant bytes. -See the [schema](Ixon-v3.md), [wire format](Ixon.md), +See the [schema](Ixon-v4.md), [wire format](Ixon.md), [text syntax](ixon-text-v3.md), and [source frontend](source-contracts.md). ## Validation contract @@ -31,11 +48,11 @@ Optional metadata and cached materializations grant no semantic facts. | Interface | Status | | --- | --- | -| Lean/Rust codecs, equality, hashing, sharing, FFI, text | V3 | +| Lean/Rust codecs, equality, hashing, sharing, FFI, text | V4 (TagN, canonical sharing); text grammar version 3 | | Lean/Rust source compilation | Resource-checked annotated definitions and admitted interfaces | | Decompilation | Reconstructs committed contracts; unsupported metadata rewrites reject | | Native resource admission and Resource claims | Implemented with explicit profiles | -| IxVM codecs and structural revelation | Preserve every v3 contract field | +| IxVM codecs and structural revelation | Read and write v4 (TagN); preserve every contract field | | IxVM Check/CheckEnv | Erased-lean-v1; contracts do not strengthen that statement | | IxVM Resource proofs | Explicitly unsupported | | Compilatrix backend | External migration required; support not inferred from these fixtures | @@ -47,7 +64,7 @@ for higher-order capture, recursion, loan, and normalization limits. ## Fixture package -The [fixture directory](../Tests/Fixtures/ixon-v3/) contains: +The [fixture directory](../Tests/Fixtures/ixon-v4/) contains: | File | Purpose | | --- | --- | @@ -56,7 +73,7 @@ The [fixture directory](../Tests/Fixtures/ixon-v3/) contains: | `resource.tsv` | Accepted and rejected resource programs | | `addressed.tsv` | Addressed declarations and a canonical profile | | `claims.tsv` | Claim bytes and BLAKE3 digests for every variant | -| `primitives.tsv` | Regenerated v3 primitive identities | +| `primitives.tsv` | Regenerated v4 primitive identities | | `handoff/accepted.ixe` | Complete anonymous closure with a linear local identity | | `handoff/rejected-local-escape.ixe` | Type-correct closure whose local input escapes | | `handoff/profile.bin` | Canonical resource profile with no external assumptions | @@ -68,11 +85,18 @@ must accept the first and reject the second. Changing any committed contract, subject, or profile must invalidate the associated identity. Reading the claim is not validation, and its bytes are not an IxVM resource proof. -Run `lake exe ixon-v3-tests` from the repository root for codec, FFI, source, -resource, decompiler, catalog, and VM checks. `--primitives` additionally checks -the generated primitive closure at `/tmp/ixon-v3-primitives.ixe`. -`--export-handoff` writes the deterministic handoff files under -`/tmp/ixon-v3-handoff`; copy them into the fixture directory only after validation. +Run `lake exe ixon-v4-tests` from the repository root for codec, FFI, source, +resource, decompiler, catalog, and VM checks. The generated files (the handoff +set, `claims.tsv`, `addressed.tsv` and `resource.tsv`) must equal their +producers' output byte for byte. Scratch files live in `$IX_IXON_V4_DIR` +(default `/tmp`; set it when two checkouts run these executables at the same +time). `lake exe ixon-v4-primitives` writes the primitive closure there +(`ixon-v4-primitives.ixe`) and fails if `primitives.tsv` differs from the live +addresses; `ixon-v4-tests --primitives` then validates that closure. +`--export-handoff` writes the deterministic handoff files to `ixon-v4-handoff/` +in the scratch directory, and `--export-fixtures` writes `claims.tsv`, +`addressed.tsv` and `resource.tsv` to `ixon-v4-fixtures/`; copy them into the +fixture directory only after validation. The formal gates are `lake build IxCompileVerify IxTcVerify Ix.Resource.Audit`. Resource theorems cover the executed quantitative and state-transition diff --git a/docs/ix_canonicity.md b/docs/ix_canonicity.md index 0616e2197..4b5cf0486 100644 --- a/docs/ix_canonicity.md +++ b/docs/ix_canonicity.md @@ -39,6 +39,20 @@ If it does, canonicity is broken and the property fails — which in turn breaks the zk-PCC story, because two parties compiling the same library would produce different hashes and could not share proofs. +The address hashes the constant's serialized bytes, and those bytes include +its sharing table and every `Share` occurrence. Since format version 4, the +sharing representation is itself canonical: a function of the constant's +anonymous expressions (§6.7). So the property also holds modulo: + +- how the expression DAG happens to be shared in memory; +- the order in which the compiler built it; +- which compiler ran, Lean or Rust. + +These are properties of the definition. The construction's proofs start from +the canonical DAG of the expressions; independence from in-memory sharing and +the agreement of the Rust implementation with the Lean definition are tested +(§6.7). + ## 2. Why It Matters Ix is a **zero-knowledge proof-carrying code** platform. A proof that @@ -221,6 +235,7 @@ Everything that depends on source choices is stripped before hashing: | `_N` suffixes on aux names | internal `_nested.Ext_N` uses canonical `N` | | Hygiene info on `Name` | stripped by `compile_name` | | Non-canonical universe-level spellings (§10.6) | `canonUniv` at the compile univ-intern boundary (`CompileM.compileAndInternUnivCanon` / `compile.rs compile_univ_idx`) | +| In-memory DAG sharing, construction order, compiler choice | the canonical sharing construction rebuilds `sharing` and every `Share` from the expanded roots (§6.7) | ### 5.2 Preserved in the metadata sidecar @@ -763,6 +778,73 @@ Since the level canonicalization (§10.6), the recipe additionally presupposes canonical (`canonUniv`-fixed) `univs` tables — level spellings have left the hash input. +Since format version 4, the recipe also presupposes the canonical +`sharing` table of §6.7. The members array, `refs` and `univs` fix the +expressions. The sharing construction then fixes how they are written. + +### 6.7 Canonical sharing + +A block's `sharing` table, and the choice of each occurrence (inline or +`Share`), are part of the canonical definition. They are the output of +`Ix.Sharing.Exact.canonicalSharingTiered .tagN` (Rust +`canonical_sharing_tiered(ShareLayout::TagN, ..)`) on the block's roots, +with every existing `Share` expanded first. The roots are the +`ConstantInfo` expressions in their fixed order (`constantInfoRootExprs`). +The output depends only on those expanded expressions: + +- **Identity is structural.** Subterms are identified by structural IDs, + numbered by height and then by constructor, scalars and child IDs. + Hashes and the interner's pointer cache only speed up discovery; they + never decide identity. `canonicalize_det` proves that the numbering of + interned terms depends only on the terms the roots denote. The step that + interns the input (`expand`) is outside the proofs; that pointer layout + does not change the bytes is tested on generated inputs. +- **Metadata does not participate.** The arena, names, binder info and + call-site data play no part, so a metadata-only change never moves an + address. Conversely, re-sharing never invalidates metadata: arena nodes + follow the unshared tree and a `Share` is transparent to them + (`sharing-minimum-integration.md` §5.4). +- **Every tie is pinned.** The stored set is the `setPrec`-least minimum of + phase 1. The first tier, the Kahn order and the width selection all have + fixed tie-breaks. The result therefore does not depend on search order, + parallelism or hash-map iteration. The Rust implementation's + deterministic parallelism is checked by byte-identity tests. +- **Backward references.** Entry `i` references only entries below `i`. + Expanding the table left to right reproduces every root exactly. +- **Idempotent.** Normalizing a canonically shared constant reproduces its + bytes (tested; proved under the hypothesis that the output expands to the + input's canonical DAG, `canonicalSharingTieredTable_idem`). + +[Ixon](Ixon.md#sharing-system) describes the three phases and the width +selection. It also states which properties are machine-checked: phase-1 +minimality, the per-phase specifications of phases 2 and 3 and of the +selection, that the minimized length is the serialized length +(`canonicalSharingTiered_serialized`), and wire validity of the output +(`canonicalSharingTiered_format`), all for a run on the canonical DAG. Three +things are not claimed: that the result is a global byte minimum, that the +step building the DAG from the input expressions is correct, and that the +Rust implementation is proved. Rust is held to the Lean definition +by differential tests (`exact-sharing-ffi`, and the corpus differential on +Init and a Mathlib sample described in +[Ixon](Ixon.md#what-is-proved-and-what-is-not)). + +A failed construction, for example one that exceeds a resource limit, is a +compile error for that block. There is no fallback, because a fallback +would make the address depend on resource limits rather than on the +expressions. + +Both compilers route every block through this construction, including +aux-gen blocks, and in Rust also kernel egress and the decompiler's +recompile. The recompile invariant `Named.original` (§9.2) relies on +recompile using exactly this route. + +On the Init and Mathlib files compiled at this PR's head, Lean and Rust +produce identical bytes for all 56,622 Init constants and for a Mathlib +sample of 20,284 constants, and the merge-queue suite +`lake test -- --ignored compile` requires the Lean and Rust compilers to +write identical environments for its whole test environment (237,295 +constants). + ## 7. The Compile Pipeline ``` @@ -860,6 +942,14 @@ Five invariants hold at the pipeline seams: `ExprMetaData::Binder` entries that never contribute to `Constant::commit()`. +A sixth invariant governs the final step, where each block's bytes are +written: + +6. **Sharing is canonical (format v4).** Each block's `sharing` table and + `Share` occurrences are the output of the canonical construction (§6.7) + on its expanded roots. They do not depend on how the compiler built or + shared the expression DAG. + ## 8. Call-Site Surgery User code — and Lean-auto-generated constants like `_sizeOf_N`, @@ -1633,7 +1723,7 @@ univPatches : Array UnivPatch UnivPatch ::= { arenaIdx : UInt64, univIdxs : Array UInt64 } ``` -— empty (one `Tag0` zero byte) on the overwhelming majority of +— empty (one zero byte, the count `N0(0)`) on the overwhelming majority of constants. The arena key is exact because occurrence identity is spelling-injective: `Ix.Level.mk*` hash spelling trees per node and `Expr.mkSort`/`mkConst` fold those hashes into expression identity @@ -2209,6 +2299,22 @@ Landed with the §17.9 stages: - `univPatches`/`metaUnivs` serde vectors in the property-test generators and hand-written wire fixtures. +### 16.8 Canonical sharing (§6.7) + +- `lake test -- exact-sharing` covers the plan fixtures, with exact bytes + (`T2 → T2` in 17 bytes, from 20 unshared). It also covers the uniform + optimizer against the width-state reference, the tiered construction's + slot allocation, idempotence, and brute force for the first tier. +- `lake test -- exact-sharing-ffi` compares Lean and Rust bytes on fixtures + and on generated inputs. +- The Rust crate's `sharing_exact` tests cover: + - representation independence: every valid incoming encoding normalizes + to the same bytes; + - parallel against sequential byte identity. +- Roundtrip (§16.5) adds the end-to-end check: a recompiled block must + reproduce its address, so decompile's recompile and the compiler must + produce the same canonical sharing. + ## 17. Open Work ### 17.1 PermCtx Builder Consolidation @@ -2428,6 +2534,11 @@ is known to be partial. - [`docs/Ixon.md`](./Ixon.md) — binary format, Expr/Constant/Meta layout, serialization details. +- [`docs/Ixon.md` § Sharing System](./Ixon.md#sharing-system) and + [`docs/sharing-minimum.md`](./sharing-minimum.md) §12 — the canonical sharing + construction (§6.7): `Ix/Sharing/Exact/Tiered.lean`, + `crates/ixon/src/sharing_exact/tiered.rs`, proofs in + `Ix/Compile/Verify/{UniformOptimality,TieredTier,TieredPhase3,TieredSelect,TieredWire}.lean`. - `src/ix/compile.rs` — `sort_consts`, `Frame`, `compile_expr`. - `src/ix/kernel/canonical_check.rs` — kernel-side `sort_consts` port: `compare_kuniv`, `compare_kexpr`, `compare_kconst`, diff --git a/docs/ixon-text-v3.md b/docs/ixon-text-v3.md index 6d16090b1..6e0ece4e7 100644 --- a/docs/ixon-text-v3.md +++ b/docs/ixon-text-v3.md @@ -1,7 +1,12 @@ -# Ixon v3 text syntax +# Ixon text syntax (grammar version 3) The Lean and Rust parsers use grammar version **3**. Whole files start with `ixon 3`; missing headers and explicit older versions are rejected. +The text grammar has its own version, separate from the binary format +version (Lean `Ixon.Syntax.VERSION`, Rust `ixon::syntax::VERSION`). Binary +format v4 (TagN integers, canonical sharing) does not change the text +grammar. + Canonical printing includes the header, a blank line between sections, and a final newline. Standalone term parsing uses the current grammar without a file header. @@ -66,7 +71,7 @@ intermediate result explicitly: ``` The local interpretation and closure restrictions are specified in -[Ixon v3](Ixon-v3.md). +[Ixon v4](Ixon-v4.md) (§2; the contract model is unchanged from v3). ## Let and shared borrow @@ -99,7 +104,7 @@ In particular, the text grammar can represent every wire-level let combination; the resource checker is responsible for rejecting a borrow view whose contract is not shared and local. -The shared [contract fixtures](../Tests/Fixtures/ixon-v3/text.tsv) cover +The shared [contract fixtures](../Tests/Fixtures/ixon-v4/text.tsv) cover all 16 lambda inputs, 64 dependent arrow input/result pairs, four non-dependent arrow results, and 64 let flag/contract combinations. Both implementations check the parsed fields and canonical text. diff --git a/docs/ixon-v3-verification.md b/docs/ixon-v3-verification.md index ab31d951f..c32a26ceb 100644 --- a/docs/ixon-v3-verification.md +++ b/docs/ixon-v3-verification.md @@ -1,12 +1,23 @@ # Ixon v3 implementation and verification record +> **Historical record.** This file records the gates executed when the +> contract model (usage, ownership, relative locality) was introduced in +> format v3. The current format is **v4**, which keeps that contract model +> but replaces Tag0/Tag2/Tag4 with TagN and makes sharing canonical. See +> the [v4 specification](Ixon-v4.md) and [Ixon](Ixon.md). The figures below +> were measured on v3 and are not re-asserted for v4. In particular, the +> byte sizes, addresses and FFT-cost pins all change with the v4 bytes. + +The gates executed for v4 at the head of the v4 change are listed in the +[integration map](sharing-minimum-integration.md#gates-at-this-prs-head). + Ixon v3 carries independent usage, ownership, and relative-locality contracts through the Ix source frontend, Lean and Rust compilers, canonical bytes, sharing, text syntax, FFI, and decompilation. Scoped shared borrowing uses an explicit let kind. Native admission checks resources and erased typing before an annotated production artifact is emitted. -## Implemented boundary +## Implemented boundary (contract model) - Definitions, theorems, opaque bodies, and explicitly admitted interfaces are supported. Annotated inductive/constructor/recursor generation and nonidentity @@ -23,9 +34,9 @@ an annotated production artifact is emitted. The [resource-checker specification](resource-checking.md) records the bounded normalization, higher-order capture, recursion, and projection fragment. -## Executed gates +## Executed gates (v3) -Commands run from the repository root: +Commands run from the repository root at the v3 change: | Gate | Result | | --- | --- | @@ -64,12 +75,14 @@ reconstructs all 6,656 source constants with no errors or mismatches. The low-level diagnostic probes retain their existing mismatch baselines; the production-driver and fidelity gates require zero mismatches. -## Formal trust frontier +## Formal trust frontier (v3) -The compiler manifest audits 143 roots. The typechecker manifests audit 2,034 +At the v3 change the compiler manifest audited 143 roots. (For v4 the +manifest has 250 roots at the head of the v4 change, including the TagN and +sharing-construction theorems.) The typechecker manifests audited 2,034 completed roots, one conditional root, and seven statement roots. Their existing transitive assumptions remain explicit in the manifests. Both local -sorry-frontier checks pass. +sorry-frontier checks passed. The new resource audit covers 15 roots connected to executable quantitative, scope, ownership, loan-ending, and join checks. Contract-code inverses and @@ -80,13 +93,14 @@ These results establish the stated codec and state-transition properties. They do not establish a theorem for the entire resource checker against a machine operational semantics or verify a backend allocation strategy. -## Migration observations +## Migration observations (v3) -Environment format is 3, catalog-manifest format is 2, and claim/proof envelopes -bind format 3 plus a validator identity. Old typed objects, claims, and -primitive addresses require regeneration. The historical Mathlib proof fixture -retains its original hash and root bytes and now rejects at the v3 envelope -boundary. +At the v3 change the environment format was 3, the catalog-manifest format 2, +and claim/proof envelopes bound format 3 plus a validator identity (v4 moves +the format to 4; the catalog-manifest format stays 2). Old typed objects, +claims, and primitive addresses required regeneration. The historical Mathlib +proof fixture retains its original hash and root bytes and rejects at the +envelope boundary. The v3 VM's decoding and canonicality checks change its deterministic FFT-cost estimates. Across the 83 existing kernel pins the increase over the pre-v3 diff --git a/docs/resource-checking.md b/docs/resource-checking.md index a72824d39..0fd659e37 100644 --- a/docs/resource-checking.md +++ b/docs/resource-checking.md @@ -1,4 +1,4 @@ -# Ixon v3 resource checking +# Ixon resource checking (resource-v1) The Lean and Rust resource validators consume the same canonical addressed environment and an explicit profile. Both production compilers run this @@ -120,22 +120,22 @@ its resource result is never cached by expression identity alone. ## Profiles, claims, and consumers A canonical profile begins with the UTF-8 bytes -`ixon-v3/resource-v1/profile` and a zero byte, followed by: +`ixon-v4/resource-v1/profile` and a zero byte, followed by: 1. Assumptions, shareable type addresses, and selection primitive addresses: - each list has a minimal Tag0 count and strictly increasing 32-byte addresses. + each list has a TagN (`f = 0`) count and strictly increasing 32-byte addresses. 2. Optional Nat and String type addresses: a byte `0`, or `1` and an address. -3. Nonzero depth and step limits, each a minimal Tag0 unsigned integer. +3. Nonzero depth and step limits, each a TagN (`f = 0`) unsigned integer. Selection primitives must also be assumptions. Literal types, when selected, -must match the kernel's pinned v3 primitive identities. The profile address is +must match the kernel's pinned primitive identities. The profile address is BLAKE3 of these exact bytes. Changing limits or assumptions changes the claim. The default profile admits no external resource interfaces and only grants shareability to present canonical Nat, Bool, and String types. `makeClaim` validates before producing a `Resource` claim. `checkClaim` checks the complete subject root and profile address, then reruns combined validation. -The claim has format byte `3` and validator byte `2` (`resource-v1`). +The claim has format byte `4` and validator byte `2` (`resource-v1`). Assumptions describe admitted behavior; they do not remove constants from the required closure. Merely parsing a claim or proof wrapper validates no program. @@ -147,7 +147,7 @@ required closure. Merely parsing a claim or proof wrapper validates no program. | IxVM `Reveal` and `Contains` | Structural validation, validator byte `0` | | IxVM `Resource` | Explicitly unsupported; native success is not a circuit proof | -IxVM preserves all v3 fields in serialization and revelation. Its typing +IxVM preserves every contract field in serialization and revelation. Its typing conversion erases contracts and interprets a borrow let as an ordinary let. The committed validator identity prevents these typing proofs from claiming resource validity. Backends relying on ownership or locality must require @@ -171,7 +171,7 @@ These are executable-check and transition invariants. They do not replace the ordinary typechecking prerequisite or claim a proof of a machine backend's allocation behavior. -[Shared resource fixtures](../Tests/Fixtures/ixon-v3/resource.tsv) exercise +[Shared resource fixtures](../Tests/Fixtures/ixon-v4/resource.tsv) exercise accepted and rejected terms in both implementations. The suites also cover all 64 input/result combinations, imported-interface aliases, mutual groups, profile omissions, constructor captures, and bounded rejection of cyclic diff --git a/docs/sharing-minimum-arena.md b/docs/sharing-minimum-arena.md new file mode 100644 index 000000000..77e11c2b7 --- /dev/null +++ b/docs/sharing-minimum-arena.md @@ -0,0 +1,468 @@ +# ExprMeta arena encoding (Ixon v4) + +Question: can the ExprMeta arenas (43% of the Mathlib `.ixe`) be made substantially +smaller by a change small enough for the v4 PR? + +**Status.** The implicit post-order encoding (§4) is part of format v4 in both +implementations; `docs/Ixon.md`, "ExprMeta Arena", is its normative description. +Hash-consing (§5) is not implemented; it is designed here for a stacked PR. §1–§5 were +measured on v3 files (header `0xE3`, `Tag0` integers, heuristic sharing tables); §6 and §7 +on files with TagN integers everywhere but still the header `0xE3`, heuristic sharing and +no 4-byte TagN rung; §7 ends with the sizes of the final v4 files. + +**Answer.** Yes, for the encoding; no, for deduplication. + +- **This PR: implicit post-order children.** A serializer-only change in Lean and Rust. + Arenas shrink by 13.2% of the Mathlib file and 12.9% of the Init file, measured against + the v4 baseline (TagN, absolute indices). + - Re-serialized with the production writer and compared with v3 files, the file shrinks + by 19.95% on Mathlib (−667,051,250 bytes) and 19.11% on Init (−37,332,515). + - Lean and Rust are byte-identical (§4). +- **Stacked PR: hash-consing.** It saves a further 10.6% (Mathlib) and 10.3% (Init). It + changes the producers, both compilers and the metadata finalizer proofs. It is designed + in §5 and kept separable. + +All figures below are exact byte counts from the `arena_study` tool (§8). Its v3 pricing +equals the production writer on every node and every arena of both corpora. + +## 1. Where the arena bytes are (v3 files) + +| | Init (`init.ixe`) | Mathlib (`mathlib.ixe`) | +|---|---:|---:| +| file | 195,387,870 | 3,343,271,273 | +| arenas (of them in `original` metadata) | 67,995 (2,000) | 793,394 (22,265) | +| nodes | 16,335,501 | 272,299,746 | +| arena bytes, v3 (% of file) | 83,050,319 (42.51%) | 1,436,611,288 (42.97%) | +| App nodes, v3 bytes | 13,192,988, 66,872,939 | 221,528,194, 1,163,416,451 | +| structural child references (App, Binder, Let, Prj, Mdata) | 28,914,135 | 481,089,260 | +| call-site references | 0 | 14,763 | + +A v3 App node is a tag byte plus two `Tag0` absolute indices, 5.26 bytes on average. +The corpus study (`sharing-minimum-measurements.md`, "ExprMeta arena structure follow-up") has +the delta histograms and the duplication counts; this note uses its figures where they +agree and adds the encodings below. + +## 2. Distributions that decide the encoding + +The compilers allocate an arena bottom-up in **post-order**: + +- App spines: head, then per argument the argument's subtree and the App node; +- binders: type, body, node; let: type, value, body, node; +- prj and mdata: child, node. + +The only exceptions are **expression-cache hits**: a repeated source subexpression gets +the earlier node's index and allocates nothing. + +So, for most children, the child sits at the position a post-order reader would expect. +Δ below is `parent − child − 1`. + +| slot (Mathlib) | children | Δ = 0 (immediately preceding) | at the post-order position ("fresh") | not backward | +|---|---:|---:|---:|---:| +| App function | 221,528,194 | 125,476,650 | 182,898,348 (82.6%) | 0 | +| App argument | 221,528,194 | 62,949,362 | 62,949,362 (28.4%) | 0 | +| Binder type | 18,460,184 | 307,946 | 7,153,864 (38.8%) | 0 | +| Binder body | 18,460,184 | 16,933,583 | 16,933,583 (91.7%) | 0 | +| Let type / value / body | 314,160 each | 315 / 8,016 / 299,268 | 127,318 / 227,123 / 299,268 | 0 | +| Prj / Mdata child | 56,054 / 113,970 | 27,687 / 101,758 | 27,687 / 101,758 | 0 | +| **all structural slots** | 481,089,260 | 206,104,585 | **270,718,311 (56.3%)** | **0** | + +- **App argument.** Only 28% of App arguments are fresh. The rest are cache hits (bound + variables, repeated arguments) and point further back. +- **Δ = 0 is too narrow.** A plain "Δ = 0 is implicit" rule catches 206M children. The + post-order cursor (§3) also catches the App function after a fresh argument subtree: + Δ = size of that subtree, and 57M more children. +- **Init** is the same shape: 16,200,603 of 28,914,135 children are fresh (56.0%). +- **No child points forward or to itself** in either corpus. + +## 3. Encodings measured + +Every row prices the whole arena: length prefix, tags, name indices, mdata and call-site +payloads, and child references. + +- **abs:** TagN (`f = 0`) for every integer, absolute child indices. This is the v4 + baseline: what replacing `Tag0` by TagN gives with no arena change. +- **delta:** every child is TagN of `i − 1 − c` (candidate 1). +- **implicit:** this PR's encoding; it generalises candidate 2. +- **+ hash-consing:** dedup first, then encode (candidate 3; §5). + +| encoding | Init bytes | Init vs abs (% of file) | Mathlib bytes | Mathlib vs abs (% of file) | +|---|---:|---:|---:|---:| +| v3 (Tag0, absolute) | 83,050,319 | +11,465,426 (+5.87%) | 1,436,611,288 | +203,696,265 (+6.09%) | +| abs (v4 baseline) | 71,584,893 | 0 | 1,232,915,023 | 0 | +| delta | 62,827,011 | −8,757,882 (−4.48%) | 1,066,692,419 | −166,222,604 (−4.97%) | +| **implicit (this PR)** | **46,429,855** | **−25,155,038 (−12.87%)** | **791,670,984** | **−441,244,039 (−13.20%)** | +| delta + hash-consing | 35,244,093 | −36,340,800 (−18.60%) | 576,239,799 | −656,675,224 (−19.64%) | +| implicit + hash-consing | 26,313,130 | −45,271,763 (−23.17%) | 435,756,696 | −797,158,327 (−23.84%) | + +- **Against v3,** the implicit encoding with TagN removes 36,620,464 bytes on Init (18.74% + of the file) and 644,940,304 on Mathlib (19.29%). +- **The two effects are not additive,** as the corpus study noted. Measured together, + hash-consing adds −20,116,725 (Init) and −355,914,288 (Mathlib) on top of implicit. +- **Per-slot choice (suggested by the corpus study) is subsumed.** The one slot where plain deltas lose + (Binder type) is handled by the implicit/explicit choice, which is made per child. + +Implicit encoding by node kind (Mathlib): + +| kind | nodes | abs bytes | implicit bytes | implicit B/node | +|---|---:|---:|---:|---:| +| app | 221,528,194 | 950,015,204 | 543,385,811 | 2.45 | +| binder | 18,460,184 | 135,167,096 | 101,936,299 | 5.52 | +| ref | 23,362,646 | 132,917,222 | 132,917,222 | 5.69 | +| leaf | 8,464,218 | 8,464,218 | 8,464,218 | 1.00 | +| letBinder, prj, mdata, callSite | 484,504 | 5,162,691 | 3,778,842 | | + +**What remains after implicit** (Mathlib, 791.7 MB): + +- explicit child references: 343.0 MB, mostly cache-hit App arguments; +- tag bytes: 272.3 MB; +- name indices: 174.0 MB. + +## 4. The chosen encoding (implemented in v4) + +`docs/Ixon.md`, "ExprMeta Arena", is the normative text. In short: + +- **Arena.** `len`, then the nodes in index order. +- **Node tag.** Node `i` starts with the tag `kind << 3 | mask`: + - kinds are the v3 tag numbers 0–11 (binder info stays packed in kinds 2–5); + - `mask` has one bit per structural slot. +- **Implicit slot** (bit set). The slot is not written. A cursor `top` starts at `i` and + visits the slots last to first. An implicit slot is node `top − 1`, and `top` then + becomes `lo[top − 1]`. Afterwards `lo[i] = top`: the start of node `i`'s contiguous + post-order block. +- **Explicit reference.** Structural slots with the bit clear, and every call-site + reference, are TagN (`f = 0`) of `(i − 1 − c) mod 2^64`. +- **Bijective.** The writer sets a bit exactly when the child is `top − 1`. The reader + rejects: + - an explicit child equal to `top − 1`; + - an implicit child with `top = 0`; + - mask bits beyond the kind's slot count; + - kinds above 11. + + Wrapping makes every `u64` index representable, including forward and self references + (9 bytes). The encoder is therefore total (Lean's `PutM` cannot fail) and needs no new + producer invariant. The property tests' generated arenas, which can self-reference at + node 0, need no change. +- **Other integers** in the arena keep their helper encodings, which are TagN in v4 like + every other integer: the length, name indices, mdata, call-site counts and scalars. Only + the child deltas call `putTagN 0` / `TagN::put(0, …)` directly, so the arena encoding + and the Tag0 → TagN replacement are independent changes. + +### Constraints + +- **Determinism and parity.** The bytes are a pure function of the in-memory arena, with + the same algorithm in both languages. +- **Anonymous constant bytes and addresses** do not change. +- **The arena is unchanged.** It is still exactly what the compiler built: the encoding + is a function of it and decodes back to it. + +### Consumer impact + +**None.** The decoded `ExprMetaArena` / `ExprMeta` (absolute `u64` indices) is identical, +so none of these change: + +- the compilers (`Ix/CompileM.lean`, `crates/compile/src/compile.rs`); +- the decompilers (`Ix/DecompileM.lean`, `crates/compile/src/decompile.rs`); +- kernel meta ingress (`Ix/Tc/IngressMeta.lean`, `crates/kernel/src/ingress.rs`); +- the FFI marshalling (`crates/ffi/src/lean_ixon/meta.rs`); +- the proofs (`Ix/Compile/Verify/*`, which are about the in-memory arena); +- IxVM, which does not read metadata. + +**The one API change** is in the node-level (de)serializers: they now need the node's +position and the block starts. + +- Lean: `putExprMetaDataIndexed` / `getExprMetaDataIndexed` become `putExprMetaNode` / + `getExprMetaNode`. +- Rust: the public `ExprMetaData::put_with` / `get_with` become private + `put_node` / `get_node`. +- Only one outside caller existed: `Benchmarks/SharingStudy.lean`. Its + `getArenaBreak` now threads `lo` (4 lines). + +### Diff size (this PR's share) + +From `git diff --numstat` against the development branch before the arena change: + +| file | added | removed | what | +|---|---:|---:|---| +| `crates/ixon/src/metadata.rs` | 515 | 153 | serializer; tests: 3 byte vectors, rejections, 2,000 pseudo-random arenas | +| `Ix/Ixon.lean` | 220 | 115 | serializer | +| `Tests/Ix/Ixon.lean` | 67 | 0 | the same byte vectors and rejections | +| `Benchmarks/SharingStudy.lean` | 5 | 3 | harness call site | +| `docs/Ixon.md` | 51 | 16 | the wire format | + +- Separately: this note and the measurement example `crates/ixon/examples/arena_study.rs` + (934 lines). +- No consumer, producer, proof or FFI file changes. + +### Measured with the production writer (before TagN replaced Tag0) + +The v3 files were read with a temporary, uncommitted legacy arena reader (the v3 +`ExprMeta::get_with`, switched on only while the cursor parses the file). Each arena and +each §5 window was then re-serialized with the implicit encoding's production writer +(`ExprMeta::put_with`, `put_named_indexed`), and every arena was round-tripped through +the production reader. + +Integers other than the child references were still `Tag0` in this measurement: the +Tag0 → TagN replacement had not landed. + +| | Init | Mathlib | +|---|---:|---:| +| arenas re-serialized | 67,995 | 793,394 | +| size mismatches against the predicted pricing / round-trip mismatches | 0 / 0 | 0 / 0 | +| arena bytes, v3 → implicit | 83,050,319 → 45,731,058 | 1,436,611,288 → 769,664,251 | +| §5 windows + length prefixes, v3 | 84,921,487 + 161,358 | 1,469,007,694 + 2,063,780 | +| §5 windows + length prefixes, implicit | 47,602,226 + 148,104 | 802,060,657 + 1,959,567 | +| **file size change** | **−37,332,515 (−19.11%)** | **−667,051,250 (−19.95%)** | +| file size, v3 → implicit | 195,387,870 → 158,055,355 | 3,343,271,273 → 2,676,220,023 | + +- **The v3 baseline is independently confirmed.** The v3 window and prefix totals equal + the sum of the independent §5 breakdown in `sharing-minimum-measurements.md`, category + by category, on both files. +- **Larger than the §3 implicit row.** These savings exceed the "implicit" row because + name indices are still `Tag0` here. With TagN integers the arenas cost the §3 + "implicit" figures (46,429,855 and 791,670,984), and the name-index growth of §6 + applies. + +### Lean/Rust parity + +- **Lean `ixon` suite: 374 passed, 0 failed.** It includes: + - the byte vectors; + - "Surgery metadata env bytes Lean==Rust"; + - the generator-driven "Env serde roundtrips", "Env serialization Lean==Rust" and + "Env bytes Lean==Rust" over generated environments with full metadata (call sites, + extension tables, `original`). +- **The ignored `ixon-corpus` gate passed** (331 s). The Rust compiler writes the IxTests + binary's whole environment, a superset of Init, in the new format. Then: + - pure Lean `deEnv` parses it; + - `serEnv` reproduces the bytes exactly; + - the FFI parse agrees. +- **Rust:** `cargo test -p ixon`: 412 passed, 0 failed. +- **Related Lean suites:** `ffi meta-env catalog import-ixe decompile-unit tc-unit` (run + under `lake env`): 692 passed, exit 0. +- **Before TagN replaced Tag0.** The results above are from before that change. + +**After TagN became the only integer code** (on the development branch, once TagN became the only code): + +- **Lean `ixon` suite: 331 passed, 0 failed.** The share-codec tests were removed with the + TagN change. +- **The `ixon-corpus` gate passed** (242 s). +- **Rust:** `cargo test --release -p ixon --lib --tests`: 387 passed, 4 failed. The four + failures also occur on a clean checkout of that state (382 passed, the same 4 failed), so + they are not caused by the merge: + - `proof::tests::catalog_claim_wire_bytes_pinned`; + - `proof::tests::v3_claim_fixtures_and_strict_scope`; + - `resource::addressed::tests::canonical_cross_language_fixtures`; + - `sharing_exact::tests::parallel_tiered_matches_sequential`. +- **Lint:** clippy (`--lib --tests --example arena_study`, `-D warnings`) is clean. +- **Known breaks in that state itself** (both fixed later on `ix-sharing`): + - The `sharing_corpus` example did not compile: it imported the removed + `put_expr_with`. + - The `sharing-study` harness did not compile: it had 35 uses of `Ixon.getTag0` and + `getTag4`, including its own arena-length read. + + The arena change touches only the harness's node-reader call. + +## 5. Stacked PR: within-arena hash-consing + +**Measured effect.** Dedup first, then the implicit encoding: −355.9 MB on Mathlib +(10.65% of the file) and −20.1 MB on Init (10.30%), beyond §4. + +- **Surviving nodes.** 140,419,081 of 272,299,746 (51.6%); on Init, 8,991,706 of + 16,335,501. +- **Why this differs from the corpus study's count.** That study found 133,235,031 + duplicates on Mathlib. Here + nodes carrying a level-spelling patch are never merged (see the audit), so 1,354,366 + fewer nodes merge. +- **Redirection cost.** Roots and patch keys outside the arena get *cheaper*, because + indices shrink: + - Mathlib: 2,522,841 type/value/rule roots and patch keys; 2,588 point to a merged node + and are redirected; their TagN bytes go 3,681,438 → 3,391,478. + - Init: 139,483 indices, 177 redirected, 167,482 → 159,564 bytes. + - Call-site references redirected inside the arena: 2,253 on Mathlib, 0 on Init. They + are priced in the arena rows. + +**Consumer audit (tree assumptions).** + +- **No code mutates an arena node after allocation**, in Lean or Rust. The only + post-allocation read is `finishEtaCallSite`, which only reads. +- **Every expression-conversion cache is keyed by (expression, arena index)**, so a + shared node is safe: + - Rust decompile: `(Arc ptr, idx)`; + - Rust kernel ingress: `(expr ptr, arena_idx)`; + - Lean `DecompileM`: `(e, arenaIdx)`; + - Lean `IngressMeta`: `(shareIdx, arenaIdx)`. +- **No consumer does index arithmetic** on arena indices. The decompiler's `u64::MAX` + "no metadata" sentinel is in-memory only. +- **The one per-node side table is `univPatches`.** Level-spelling patches are keyed by + arena index, and all four consumers read them per node. Two occurrences with different + original spellings must not share a node, so patched nodes are never merged; the + measurement above already obeys this. The compiler also clones the head's patch onto + `callSite`/`etaCallSite` roots by index lookup during compilation, which is before any + post-pass, so it is unaffected. + +**Design.** + +- **A post-pass, not a change to `allocArenaNode`.** `ExprMetaArena.hashCons` runs where a + constant's metadata is finalized. It keeps the first occurrence of every class, keyed by + (node with renumbered children, patched?). It renumbers: + - children and call-site references; + - type/value/rule roots; + - `UnivPatch.arenaIdx`. +- **Order and acyclicity.** First-occurrence order keeps every reference backward and the + output deterministic. The result is the same as allocation-time dedup. +- **Proofs.** The post-pass keeps the `run_allocArenaNode` proof steps in + `Ix/Compile/Verify/CompileExpr.lean` (about 20 uses) intact. The proved drivers carry + the arena through the "metadata drain/finalizer" (`Statements.lean`), so the stacked PR + needs a lemma: `hashCons` preserves `ArenaRel` at the remapped roots. + +**Size estimate.** + +- the pass in Lean and Rust, about 120 lines each, plus Lean/Rust parity tests; +- one call at each metadata finalization site: Lean `takeArena` users in + `Ix/CompileM.lean` (defn, axio, quot, recr, ctor, inductive and mutual paths) and + `Ix/AuxGen/CompileAux.lean`, and the Rust equivalents in `compile.rs`, `mutual.rs` and + `kernel_egress.rs`; +- the finalizer lemma; +- fixture regeneration, which v4 needs anyway. + +That is too large for "serializer only", hence a stacked PR. It needs no format change: +the §4 encoding already handles DAG arenas. + +## 6. TagN and integers in [82,048, 2^24): census and the 4-byte rung + +Measured on the v4 files of §7 with `arena_study --int-census`. + +**The gap.** For values in [82,048, 2^24), TagN (`f = 0`) takes 5 bytes where `Tag0` +took 4. The census walks every `f = 0` integer outside constant bodies: + +- §1–§4 counts and lengths; +- §3 hints; +- every §5 integer: name keys, constant ranks, fused hints, window lengths, all + `ConstantMeta` fields, arena integers and table counts. + +It prices each integer three ways: `Tag0`, TagN as specified, and TagN with one more +rung. + +**Self-check.** For every §5 window (66,621 Init, 778,344 Mathlib; 0 mismatches), the +TagN-priced census integers plus the non-integer bytes equal the production writer's +window. + +**Constant bodies** cannot reach the gap for `f = 0`. The largest refs/univs tables are +1,350/129 entries (Mathlib) and 441/22 (Init), and indices are bounded by them. + +**Integers in [82,048, 2^24), each one byte longer than in `Tag0`:** + +| field class | Init | Mathlib | +|---|---:|---:| +| arena node name indices (binder, let, ref, prj, call-site, mdata keys, `OfName`) | 1,379,100 | 29,774,488 | +| `ConstantMetaInfo` name indices (name, levels, all, ctx, ctors, rules, induct) | 222,383 | 3,349,298 | +| §5 name keys | 59,222 | 773,149 | +| §5 constant ranks | 0 | 683,556 | +| arena explicit child deltas | 0 | 242,432 | +| everything else (lengths, counts, roots) | 24 | 366 | +| **total = bytes a 4-byte rung would save** | **1,660,729 (1.06% of the file)** | **34,823,289 (1.31%)** | + +- **Name-class growth over `Tag0`, net of the values that got shorter:** + - Mathlib: arena names +22,243,839, `ConstantMetaInfo` names +3,052,196, §5 keys + +771,058, §5 ranks +645,449. + - Init: arena names +712,195, `ConstantMetaInfo` names +209,601, §5 keys +56,370. +- **A 4-byte rung is free in code space for every flag width.** In the five-rung TagN + measured here, the last selector `c = 3` was invalid. Codes `c = 0, 1, 2, 3` can select + 2, 3, 4 and 8 following bytes (widths 1, 2, 3, 4, 5, 9). + - For `f = 0` the rung covers [82,048, 16,859,264). + - TagN is then never longer than `Tag0` below 2^32. + - The rung also covers `f = 4` Share indices in [66,568, …). The Mathlib compile + measured here (heuristic sharing) has one sharing table of 81,464 entries, so some + Share references there pay the same extra byte. Constant bodies are outside this + census, so they are not counted. + - The rung was adopted (`docs/sharing-minimum.md` §12.16) and is part of TagN in v4 + (`docs/Ixon.md`, "Integer Encoding (TagN)"). The figures above are its exact savings. +- **A per-arena local name table is no fix.** On the v3 files it saves 2.9 MB on Mathlib + and costs 0.4 MB on Init: there are 28.8M distinct names per arena out of 42.2M + references. + +## 7. File sizes with TagN-only integers and the implicit arenas + +Init and Mathlib were recompiled once TagN was the only integer code and the implicit +arena encoding was in place (`ix compile`, same inputs as the v3 corpora; heuristic +sharing, five-rung TagN, header `0xE3`): + +| | v3 file | v4 file | change | +|---|---:|---:|---:| +| Init (`Benchmarks/CompileInit.lean`) | 195,387,870 | 156,922,814 | −38,465,056 (−19.69%) | +| Mathlib (`Benchmarks/Compile/CompileMathlib.lean`, 771,129 constants requested) | 3,343,271,273 | 2,654,926,848 | −688,344,425 (−20.59%) | + +- **Writer check on the v4 files** (`--check-writer --other-tagn`): every arena equals its + predicted implicit TagN size, and every arena round-trips through the production + reader. 0 / 0 mismatches over 67,995 (Init) and 793,394 (Mathlib) arenas. + - Arena bytes: 46,429,863 (29.59% of the v4 Init file) and 791,674,724 (29.82% of + Mathlib). + - Priced with absolute TagN indices instead, the arenas would be 25,155,038 and + 441,243,705 bytes larger. That is this PR's share of the v4 reduction. +- **The rest of the file barely moves.** Outside the arenas it shrinks by 1.8 MB (Init) and + 43.4 MB (Mathlib). +- **Same metadata, fresh compile.** The arenas are the same as in the v3 corpora apart + from a fresh compile: Init 16,335,501 nodes in both; Mathlib 272,299,589 v4 vs + 272,299,746 v3. +- **Not yet the final v4 file.** These files still have the header byte `0xE3`, + heuristic sharing tables and no 4-byte rung. With the rung (still `0xE3` and heuristic + sharing, before the route switch) the same compiles write 155,259,078 and 2,620,063,965 bytes. + +The final format adds version 4 (header `0xE4`), canonical sharing and the rung of §6. +Compiled with it (`lake exe ix compile`, same inputs, at this PR's head; the same bytes were +written before and after the Rust optimizations): + +| | v3 file | final v4 file | change | +|---|---:|---:|---:| +| Init | 195,387,870 | 143,680,738 | −51,707,132 (−26.46%) | +| Mathlib | 3,343,271,273 | 2,318,833,546 | −1,024,437,727 (−30.64%) | + +- **Canonical sharing's share.** Against the heuristic-sharing files above (the same + environments), the final files are 11,578,340 bytes (−7.46%, Init) and + 301,230,419 bytes (−11.50%, Mathlib) smaller. +- **Identity.** sha256 `317d63bb…873363` (Init) and `a893a449…917bfc` (Mathlib). Every + canonical-route compile of these inputs that was measured, before and after the Rust + construction's optimizations, wrote the same bytes. + +## 8. Reproduction + +`$S` is any directory holding the corpora, and `arena_study` is +`target/release/examples/arena_study`. `init.ixe` and `mathlib.ixe` are compiled with +`lake exe ix compile Benchmarks/CompileInit.lean --out $S/init.ixe` and +`lake exe ix compile Benchmarks/Compile/CompileMathlib.lean --out $S/mathlib.ixe` (the +Mathlib setup is in `sharing-minimum-measurements-mathlib.md`, "Reproduction"). A reader +accepts only its own format version, so the v3 rows need v3 files and a v3 checkout +(the development branch before the arena change), and the §6–§7 rows need files written by the same checkout +that reads them. + +```text +nix develop --command bash -c 'cargo build --release -p ixon --example arena_study' +# Pricing of all encodings + v3 writer check: build against the v3 metadata.rs +# (the development branch before the arena change), then +arena_study $S/init.ixe --check-writer --writer v3 +# -> 0 size / 0 roundtrip / 0 node mismatches (67,995 arenas, 83,050,319 bytes) +arena_study $S/mathlib.ixe --check-writer --writer v3 +# -> 0 / 0 / 0 (793,394 arenas, 1,436,611,288 bytes); 127-398 s with machine load +# Production-writer measurement: this branch + the temporary legacy reader +# (pub static LEGACY_V3_ARENA, consulted at the top of ExprMeta::get_with; +# set by the tool around NamedMetaCursor parsing), then +arena_study $S/init.ixe --check-writer --writer implicit # 28 s +arena_study $S/mathlib.ixe --check-writer --writer implicit # 394 s +# Parity +nix develop --command bash -c 'cargo test --release -p ixon' +nix develop --command bash -c 'lake build IxTests sharing-study' +nix develop --command bash -c '.lake/build/bin/IxTests ixon' +nix develop --command bash -c 'lake env .lake/build/bin/IxTests --ignored ixon-corpus' +``` + +With TagN-only integers (§6, §7): + +```text +nix develop --command bash -c 'lake build ix' +lake exe ix compile Benchmarks/CompileInit.lean --out $S/init_v4.ixe # 27 s +lake exe ix compile Benchmarks/Compile/CompileMathlib.lean --out $S/mathlib_v4.ixe # 261 s +# (Benchmarks/Compile/.lake copied from a checkout with the Mathlib build) +arena_study $S/init_v4.ixe --check-writer --other-tagn # 0 / 0 mismatches +arena_study $S/mathlib_v4.ixe --check-writer --other-tagn # 0 / 0 mismatches, 231 s +arena_study $S/init_v4.ixe --int-census # 66,621 / 66,621 windows +arena_study $S/mathlib_v4.ixe --int-census # 778,344 / 778,344 windows +``` diff --git a/docs/sharing-minimum-integration.md b/docs/sharing-minimum-integration.md new file mode 100644 index 000000000..046aeefe1 --- /dev/null +++ b/docs/sharing-minimum-integration.md @@ -0,0 +1,548 @@ +# Canonical sharing and TagN: integration map + +This map says where Ixon v4's two changes, canonical sharing and TagN integers, live in the +code, together with what follows from them: format version 4, the new identifiers, the reader +rule for `Share` inside metadata, and the IxVM circuit codec. For each part it names the Lean, +Rust and IxVM code, the theorems that cover it and the fixtures that pin it. The normative +format is [Ixon](Ixon.md); the decisions behind it are in [`sharing-minimum.md`](sharing-minimum.md) +§12–§13. Code is referred to by file and symbol, not by line. + +Decisions in force (`sharing-minimum.md` §12.8, §12.11–§12.16, §13): + +- the canonical sharing of a constant is `Ix.Sharing.Exact.canonicalSharingTiered .tagN` (Rust + `canonical_sharing_tiered(ShareLayout::TagN, ..)`), the only sharing construction of both + compilers; the heuristic and its proofs are removed; +- TagN with flag widths 0, 2 and 4 replaces Tag0, Tag2 and Tag4 at every site of the grammar and + is the only integer code; there is one format, with no dual-format gate and no reader for the + old one; +- references stay backward. The format version is 4, together with the object-format byte (4), + the resource validator ID (`"ixon-v4/resource-v1"`) and `wireFormatId` (`"ixon-v4"`). The env + header is TagN(4, `0xE`, version), the byte `0xE4`, read by context; +- compiler limits are a safety net: metering and fail-closed errors stay, the defaults sit far + above every corpus maximum, and `ix compile --sharing-limits` overrides them; +- a `Share` inside a metadata expression is read in the extended index space of + `sharing-minimum.md` §13.1; there is no metadata construction; +- the IxVM circuit codec changes in the same PR. + +**Status at this PR's head:** + +| Item | State | +|---|---| +| TagN at every Lean, Rust and IxVM site; six rungs (widths 1, 2, 3, 4, 5, 9); old encoders, decoders and canonical-integer checks deleted | done | +| Exact-sharing pricing and tie-break bytes at TagN widths; count threshold θmax (finding 7); telescope-spine guard (finding 9) | done | +| Canonical construction as the only compiler route in Lean and Rust; heuristic removed | done (§3.2, §8) | +| Compiler limits as a safety net with a CLI override | done (§8) | +| Proofs: TagN codec, phase-1 minimality, per-phase specifications, serialized length and wire validity of the output, compiler endpoint theorems over it; fast twins attached by audited `@[csimp]` theorems | done; 250 audit roots (§4) | +| Version 4, object format 4, `ixon-v4` identifiers; readers reject other versions | done (§6) | +| Fixtures and pins regenerated through their producers | done, except the FLT benchmark artifact and a new dated aggregate fixture (§6) | +| `.ixe` caches keyed by the format version | done (§6) | +| Metadata `Share` reader rule in both decompilers | done; no metadata construction (§5.3) | +| IxVM: TagN codec, claim scope bytes, v4 primitive addresses, re-pinned FFT costs | done (§3.1, §6) | +| Lean/Rust differential at this PR's head (Init, Mathlib sample) | done: 56,622 and 20,284 constants, 0 disagreements (§7 risk 1) | +| `ix compile` time: Mathlib within 1.5× of the heuristic route | done: 1.13–1.26× in the final back-to-back runs (`sharing-minimum-performance.md`) | +| CI-equivalent gates at this PR's head | passed (§8, "Gates at this PR's head") | +| Lean construction within 2–4× of Rust | not met: 8–15× single-threaded (follow-up, `sharing-minimum.md` §12.18) | + +## 1. Key findings + +1. **TagN equals the old codes exactly on its first rung.** `Tag4` values 0–7, `Tag2` values + 0–31 and `Tag0` values 0–127 are written identically in both codes; every larger value + changes bytes. So every artifact with a count, index or size above those bounds changed, not + only those with large Share indices. +2. **"No integer gets longer" (§12.12) holds below the fifth rung end.** For values from `R5` + (4,311,811,080 for `f = 4`, 4,311,826,560 for `f = 0`) up to `2^56`, TagN takes 9 bytes where + the old code took 6–8. Below `R5`, TagN is never longer, and for `f = 0` it is one byte + shorter on `[2^24, R4)` and `[2^32, R5)`. +3. **The cost model prices the wire bytes.** `Ix/Sharing/Exact/Basic.lean` defines + `tag0Size := Ixon.tagNByteWidth 0` and `tag4Size := Ixon.tagNByteWidth 4`, and from them + `shareWidth`, `sizeInfo` and `exprSize`; Rust `sharing_exact/cost.rs` `tag0_len`/`tag4_len` + are `TagN::byte_width`. The tie-break header bytes are TagN encodings in both languages (Lean + `Dictionary.lean` `tag4Bytes` runs `putTagN 4`; Rust `cost.rs` `tag4_bytes_cmp` compares + `TagN::put` outputs). TagN is a prefix code, so distinct header values still differ inside + the shorter encoding. That the price of the tiered output is its serialized length is a + theorem (`canonicalSharingTiered_serialized`); Rust also serializes the returned candidate + and compares the lengths at run time (`tiered.rs`, check 9). +4. **There are three codecs.** Besides Lean (`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 + `lake exe ix codegen --check`. +5. **Metadata does not depend on the primary table's shape.** `CallSiteEntry.collapsed + sharingIdx` and `callSite.origHead` index `ConstantMeta.metaSharing` directly, arena roots + follow the unshared logical tree, and every consumer expands `Share` transparently. + Re-sharing a constant leaves its metadata valid (§5). +6. **The compiler endpoint theorems are stated over the tiered construction.** + `Ix.Compile.Verify.Tiered.canonicalSharingTiered_format` (`TieredWire.lean`) gives + `FormatOK sharing roots`: every entry and root `wireWF`, `sharing.size < UInt64.size`, entry + `k` references only `Share(i)` with `i < k`, roots only `i < sharing.size`. The builder can + fail, so the run endpoints conclude `SharingRunOK`: the run returns an exactly decodable + block, or fails with an error the builder returns on some payload (§4). +7. **The certain-stored threshold follows the TagN count growth.** The uniform optimizer + (`Uniform.lean`, Rust `uniform.rs`) once used θ = 2 because one more table entry grew the + `Tag0` count by at most a byte. The TagN (`f = 0`) count grows by 4 bytes at 4,311,826,560 + entries (5 → 9). The threshold is θmax = `tag0StepBound n + 1` with `n` the candidate count (2 + below that bound), in both languages, and `tag0BracketStart` returns the TagN rung start. +8. **Telescope headers are subadditive only below `R5`.** The certain-excluded rule assumes + `tag4Size (a + b) ≤ tag4Size a + tag4Size b`, which fails at `R5` = 4,311,811,080 (`f = 4`). + `optimizeUniformExpanded` fails closed (`formatBound "telescope spine length"`) on a spine of + `teleSubaddEnd = Ixon.tagNEnd5 4` nodes or more, and the optimality theorems take the bound + (`SpinesFit`) from that guard. Rust fails with `FormatBound::TelescopeSpine`. +9. **Claim tags past the first rung changed.** Catalog and Resource claims (flag `0xE`, values 8 + and 9) are written `E8 00` and `E8 01`; the old code wrote `E8 08` and `E8 09`. +10. **Version header aliasing (kept).** The env header and the claim tags share flag `0xE`: + version 4 (`0xE4`) is the Check-claim tag, as version 3 (`0xE3`) was the Eval-claim tag. + Readers interpret the byte by context; `docs/Ixon.md` states this next to the claim table. + +## 2. Where the plan and the code disagree + +| Plan statement (`sharing-minimum.md`) | Code | +|---|---| +| §8.3 "The expression byte grammar need not change." | True for the construction alone. False after §12.12: every integer past the first rung changes, including Share indices ≥ 8. | +| §8.2 "Metadata expressions may also contain Share references …" | The readers implement the extended index space (§5.3); no writer emits a `Share` into `metaSharing`. | +| §2 source map: Lean, Rust, FFI. | Also the IxVM circuit codec and its generated Rust (finding 4). | +| §8.1 "Derive roots from ConstantInfo … do not use out-of-range fallbacks." | Implemented: Lean `buildConstantWithSharing` takes the roots from `constantInfoRootExprs` and writes them back with `withRootExprs`, after checking that the construction returned one root per input root. Rust `apply_sharing_to_*` derive the roots from the payload. | + +## 3. Call sites and consumers + +### 3.1 The integer code: writers and readers + +**Lean** (`Ix/Ixon.lean`): `putTagN f flag value` / `getTagN f` (a `TagN` is `{flag, value}`; +`getTagN0Values` reads a run of `f = 0` values). Every site uses them: expressions (`putExpr`, +`getExprFuel`, `getExprFromTag`), universes (`putUniv`, `getUnivFromTag`), constants and +projections, metadata (`ConstantMeta`, `ExprMeta` arenas), names, environments (`putEnv`, +`getEnv`, `getEnvVerifiedLazy`) and commitments; also `Ix/Claim.lean`, `Ix/AssumptionTree.lean`, +`Ix/Resource/Addressed.lean` and the exact-sharing oracle. Hand-rolled readers and writers +use the same code: `Ixon.DeserCursor.tagN0?`, `Ix.DecompileM.BlobCursor.readTagN0` and the +syntax-blob writer `Ix.CompileM.tagN0Bytes`. + +**Rust**: `crates/ixon/src/tag.rs` defines only `TagN` (`put`, `get`, `byte_width`, +`end1`..`end5`). Every former `Tag0`/`Tag2`/`Tag4` site in `ixon`, `ix-compile` and `ix-kernel` +uses it: `serialize.rs` (`put_expr`, `get_expr`, constants, `Env::put`, `read_env_header`), +`metadata.rs` (with `deser_tagn0`), `proof.rs`, `comm.rs`, `assumption_tree.rs`, `lazy.rs`, +and `decompile.rs` (`read_tagn0`). `get_expr` is the only byte-level expression decoder in Rust; +the other readers (`lazy.rs`, `catalog.rs`, `proof.rs`, `diff.rs`, `resource.rs`) 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`; +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 +`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 +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 +`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 +header is a rung-1 TagN, one byte. + +### 3.2 The sharing construction and its callers + +The construction is `Ix.Sharing.Exact.canonicalSharingTiered` (`Ix/Sharing/Exact.lean` over +`Ix/Sharing/Exact/Tiered.lean`) and Rust `canonical_sharing_tiered` +(`crates/ixon/src/sharing_exact/tiered.rs`), with the deterministic parallel variant +`normalize_constant_sharing_tiered_par` (byte-identical to the sequential path). + +**Lean.** `Ix.CompileM.buildConstantWithSharing limits info refs univs : Except CompileError +Constant` takes the roots from `constantInfoRootExprs`, runs `canonicalSharingTiered .tagN` +under `limits` and writes the roots back with `withRootExprs`, which delegates to the checked +`Ix.Sharing.Exact.withRoots` (one root per input root, no positional fallback). Every block goes +through it: + +| Caller | Builds | +|---|---| +| `buildBlockConstant` (limits from `CompileEnv.sharingLimits`) via `finishConstantWithSharing` | definitions, theorems, opaques, axioms, quotients, recursors | +| `finishInductiveFamilyBlock` | standalone inductive families | +| `finishMutualCompilation` → `buildCompiledMutualBlock` | mutual blocks | +| `Ix/AuxGen/CompileAux.lean`, through `buildBlockConstant` | aux-gen standalone and mutual blocks | + +**Rust** (`crates/compile/src`). `share_roots` runs the construction on a block's ordered roots. +`apply_sharing_to_{definition,axiom,quotient,recursor,mutual_block}_with_limits` run it under +the limits they are given and return the shared `Constant`. The compiler passes the limits it +read once per run (`CompileState::sharing_limits`, from `compiler_sharing_limits`: the defaults +with the `IX_SHARING_LIMITS` override); the FFI parity hook `rs_compiler_sharing_build` passes +explicit limits. + +| Caller | Error handling | +|---|---| +| `compile.rs`: `compile_single_def`, `compile_const_inner`, `compile_mutual`, `compile_mutual_block` | `CompileError`, propagated with `?` | +| `compile/mutual.rs`: `compile_aux_block_with_rename` | `CompileError`, propagated | +| `kernel_egress.rs`: `egress_muts_block`, `egress_standalone` | mapped to the egress `String` errors, naming the constant (`egress '': …`) | +| `decompile.rs`: `roundtrip_block` | `AuxGenError::Recompile`, which keeps the compile error and its category and names the constant and step (`recompile of '' (sharing): …`); the recompiled address must equal `Named.original`, so the recompile uses exactly the compile route | + +Errors: resource exhaustion is `CompileError.resourceLimit` (it names the limit and the +override); every other construction failure is `CompileError.sharingConstruction`. There is no +fallback. + +### 3.3 Share consumers that are independent of the encoding + +These expand `Share(i)` against the decoded table and need no change for TagN: Lean +`Ix/DecompileM.lean` (`resolveShareIn`, `collectIxonTelescopeExpandingShares`), +`Ix/Tc/Ingress.lean`, `Ix/Tc/IngressMeta.lean` (fuel-bounded expansion that reports a cycle), +`Ix/SemanticContract.lean` (`containsIxon`), `Ix/Resource/Addressed.lean` (offsets Share into a +program-wide table); Rust `crates/compile/src/decompile.rs`, `crates/kernel/src/ingress.rs`, +`crates/compile/src/semantic_contract.rs`, `crates/ixon/src/resource.rs`, +`resource/addressed.rs` and `diff.rs`. The IxVM ingress and conversion modules also consume the +table logically. + +### 3.4 Pricing and tie-break bytes in the construction + +| Site | What it prices | +|---|---| +| `Ix/Sharing/Exact/Basic.lean`: `tag4Size`, `tag0Size`, `shareWidth`, `sizeInfo`, `exprSize`; Rust `sharing_exact/cost.rs`: `tag4_len`, `tag0_len` | headers, counts, refs/univs indices and Share widths at TagN widths | +| `Ix/Sharing/Exact/Uniform.lean`: `tag0BracketStart`, `tag0StepBound`, `teleSubaddEnd`; Rust `uniform.rs`: `tag0_bracket_start`, `tag0_step_bound` | count brackets at the TagN rung starts, θmax (finding 7), the spine guard (finding 8) | +| `Ix/Sharing/Exact/Tiered.lean`: `ShareLayout.widthAt` (`tagNWidth`), `layoutBytes`, `rematerialize`; Rust `tiered.rs`: `tagn_width` | the real Share width at each index; the price is the serialized length (a theorem in Lean, a run-time check in Rust) | +| `Ix/Sharing/Exact/Dictionary.lean`: `tag4Bytes` (cut, inline and Share option bytes); Rust `cost.rs`: `tag4_bytes_cmp` | tie-break bytes as TagN encodings; a Share option loses every tie, since inline and cut options start with a flag nibble below `0xB` | + +## 4. Verification theorems + +Everything below builds in `lake build IxCompileVerify`. Its trust audit +(`Ix/Compile/Verify/Audit/Statements.lean`, 250 roots at this PR's head) fixes each root's axioms +exactly; `Audit/SorryFrontier.lean` checks that no declaration of `Ix.Compile.Verify` or +`Ix.Sharing` uses `sorry`; and `Audit/CompiledCode.lean` checks the compiled code (below). +`lake lint` builds it as well. + +- **TagN** (`Ix/Compile/Verify/TagN.lean`): the byte specification `tagNBytes`, the writer and + reader laws `putTagN_writes` and `getTagN_reads`, canonicity and injectivity + (`runGetExact_getTagN_eq`, `runGetExact_getTagN_iff`, `runGetExact_getTagN_inj`, + `putTagN_inj`) and the two rejection laws (`getTagN_rejects_code`, + `getTagN_rejects_overflow`). The codec theorems of `Codec.lean`, `ExprCodec.lean`, + `ExprSpineCodec.lean` and the constant codecs (`ConstantCodec.lean`, + `ConstantTablesCodec.lean`, `NonrecursiveConstantCodec.lean`, `RecursorConstantCodec.lean`, + `MutualConstantCodec.lean`) are stated over these facts; TagN is bijective, so no + canonical-integer side conditions remain. +- **Size model**: `SharingExact.lean` proves `exprSize_eq_serExpr` (the TagN-priced size is the + serialized length of every `wireWF` expression) and `serConstant_size_decomposition`; + `UniformLength.lean` proves `optimizeUniform_variableBytes` (phase 1's serialized length is its + model length when every index has width `w`). +- **Construction**, for a successful run on the canonical DAG `ex.dag`/`ex.roots`: phase 1 in + `UniformOptimality.lean` (`optimizeUniform_minimum`, `optimizeUniform_least`, over the + `Uniform*` modules), phase 2 in `TieredTier.lean` (`allocate_spec`, `firstTier_spec`) and + `TieredGuard.lean` (`allocate_optimal`, `phase3_le_phase1`), phase 3 in `TieredPhase3.lean` + (`materializeTable_min`, `rematerialize_spec`, `materializeTableOnePass_eq`), the selection in + `TieredSelect.lean` (`canonicalTieredCore_select`), determinism and re-expansion against the + DAG in `TieredIdem.lean`, structural IDs in `SharingExactCanon.lean` (`canonicalize_det`), and + in `TieredWire.lean` the format facts (`FormatOK`, `canonicalSharingTiered_format`, + `canonicalSharingTieredTable_format`) and the serialized length + (`canonicalSharingTiered_serialized`, `canonicalSharingTieredTable_serialized`: + `variableBytes` is `tag0Size` of the table count plus the `serExpr` lengths of every entry and + root, and `modelBytes = variableBytes`). +- **Compiler endpoints** (`CompileSharingCodec.lean` and the `Compile*Codec.lean` modules): + `buildConstantWithSharing_wireWF` takes the entries' and roots' `wireWF` and the table + capacity from `FormatOK`. `SharingRunOK limits run` states the outcome of a run whose only + possible failure is the builder: either `run = .ok (result, state')` with + `BlockResultCodecWF result` (the block is `wireWF` and its bytes decode to it exactly), or + `run = .error err` where the builder returns `.error err` on some payload and tables. Under + `SharingSucceeds` only the first case remains. Every `*_codecWF` endpoint concludes + `SharingRunOK compileEnv.sharingLimits (run ..)`. `FormatOK`'s backwardness conjuncts can + discharge `DecodeCtx.SharingWF` (`Ix/Compile/Verify/Catalog.lean`); no endpoint states it. + +**Specification, fast twin, csimp theorem, audit root.** The theorems describe the +specification modules of `Ix/Sharing/Exact/` (`Basic`, `Dag`, `Dictionary`, `Search`, +`UniformSearch`, `Uniform`, `Tiered`). The compiler runs faster bodies: each fast twin (in +`Phase3`, `Reexpand`, `UniformSearchLocal`, `TierFast`, `PinnedDeps`, `PinnedFast`, +`KnapsackFast`, or inside a specification module) is attached by a `@[csimp]` theorem +`@f = @fFast`, an unconditional equality of the whole result (values, metered counts, errors), +so compiled code calls the twin. A csimp applies only to code compiled after it, so `TieredFast` +recompiles the callers (`allocate`, `tieredAtWidth`, `canonicalTieredCore`, +`canonicalTieredExpanded`, `optimizeUniformExpanded`; `*_eq_C`) to reach the twins. Each csimp +theorem is an audit root, and `Audit/CompiledCode.lean` fails the build if a csimp theorem of an +`Ix` module on `Ix.CompileM`'s import path is not (19 at this PR's head), or if `Ix.Sharing.*` +declares anything `unsafe`, `partial`, `@[implemented_by]` or `@[extern]` other than the +interner's pointer-cache key `exprPtr`. The module map in the docstring of +`Ix/Sharing/Exact.lean` lists every specification, twin and csimp theorem; the three widths run +as parallel tasks above 1,024 DAG terms (`tieredCandidates`, `tieredCandidates_eq`). + +Not machine-checked: phase-2 optimality for tables of more than 1,032 entries; any global +minimum; and the step from the input expressions to the canonical DAG (`expand`, whose interner +keys a cache by the `unsafe` address `exprPtr`): no theorem states that the DAG denotes the input +expressions, so the round trip is proved relative to the DAG and re-checked at run time through +the same interner, and independence from pointer layout is tested (`docs/Ixon.md`, "What is +proved, and what is not"). The run-time checks that remain in `rematerialize` are: layout length += evaluated length; at most phase 1's layout length; re-expansion to the stored terms and the +input's root IDs; every output expression in the wire domain. + +The Rust construction is not proved. Its phase-1 search evaluates a component's area under a +truncated cost model, where the Lean specification evaluates the component's whole closure; the +outputs are equal on every input tested. + +`IxTcVerify` mentions none of these names, but its `native_decide` serde fixtures +(`Ix/Tc/Verify/Ingress/SerializedBoolean.lean`, `Ingress/LiteralBlobs.lean`, +`Inductive/ConcreteFixture.lean`, `Inductive/EnumerationFixture.lean`) recompute bytes with the +current codec. + +## 5. Metadata + +### 5.1 Index spaces + +- **Separate namespaces.** `CallSiteEntry.collapsed sharingIdx` indexes + `ConstantMeta.metaSharing`. Both compilers start it at 0 per constant: Lean `buildCallSite` + numbers collapsed arguments from the current surgery table, which `takeSurgerySharing` drains + into `metaSharing` per constant; Rust `compile.rs` drains its `surgery_sharing` into + `meta.meta_sharing` the same way. `callSite.origHead.0` also indexes `metaSharing`. +- **No offset.** Collapsed and `origHead` indices are never offset by the primary table length. +- **Kernel ingress ignores it.** `Ix/Tc/IngressMeta.lean` and Rust `crates/kernel/src/ingress.rs` + do not read `metaSharing`. + +### 5.2 Metadata payloads contain no primary Share references + +`metaSharing` entries are raw compiled expressions (Lean `compileExprSurgical`, Rust +`compile_expr`). Share is produced only by the sharing construction, which runs on the roots +after metadata is built. Their Ref/univ indices point into the block's primary `refs`/`univs` +tables, which the construction does not change, so no remapping is needed when the primary table +changes. + +### 5.3 Metadata `Share`: the extended index space + +The rule is `sharing-minimum.md` §13.1. With `p` primary entries (for a projection, those of its +`Muts` block) and `q` metadata entries, a `Share(i)` inside `metaSharing[j]` denotes primary +entry `i` when `i < p` (shares nested in that entry stay primary) and `metaSharing[i − p]` when +`p ≤ i < p + j`; anything else is rejected. A `Share` in a primary expression always denotes a +primary entry. `CallSiteEntry.collapsed sharingIdx` and `origHead = some (sharingIdx, _)` index +`metaSharing` directly and read that entry in its own scope. + +| | Lean | Rust | +|---|---|---| +| scopes and resolution | `Ix.DecompileM.ShareScope` (`primary`, `metaEntry j`), `resolveShareIn` | `decompile::ShareScope` (`Primary`, `Meta { entry }`) | +| table check on load | `validateMetaSharing` (in `withFreshBlock`) | `validate_meta_sharing` (in `load_meta_extensions`, used by `decompile_const`, `decompile_projection` and `roundtrip_block`) | +| error | `DecompileError.invalidMetaShareIndex idx entry primaryLen metaLen constant` | `DecompileError::InvalidMetaShareIndex { idx, entry, primary_len, meta_len, constant }` | +| semantic-contract scan | `Ix.SemanticContract.containsIxon` with the decompiler's scopes | `semantic_contract::contains_ixon` | + +The error has tag 11 in both languages. The table check is iterative, does not expand shares and +reports the first violation in entry order, then left-to-right pre-order. A malformed primary +`Share` found by the semantic-contract scan is reported as `InvalidShareIndex`. The IxVM circuit, +kernel ingress and egress, `diff.rs` and the resource validators do not read `metaSharing` +contents, and no writer emits a metadata `Share`. The table check is linear in the DAG size of +the table: each shared node is visited once. Two pre-existing gaps remain: a call site nested inside +a metadata expression may reference any `metaSharing` entry, including its own, and neither the +decompilers nor kernel ingress check that primary entries reference only earlier entries, so a +malformed table of either kind can make them loop instead of failing. Hardening the readers +against malformed input is follow-up work. + +### 5.4 How per-occurrence arena roots survive + +Arena nodes mirror the **unshared** logical tree; a Share is transparent and keeps the same +arena index (`Ix/Tc/IngressMeta.lean`, `Ix/DecompileM.lean`, Rust `decompile.rs`, +`ingress.rs`). Call-site `canonMeta` is distributed over the canonical App telescope after +expanding Shares along the spine (Lean `collectIxonTelescopeExpandingShares`; the Rust +decompiler and kernel ingress do the same), and eta call sites strip `nSynth` lambdas, +expanding Shares at each step. Universe patches are keyed by arena index. Root indices +(`typeRoot`, `valueRoot`, `ruleRoots`) are arena indices. So any change of which subterms are +shared, or of where a Share cuts a telescope, leaves arena roots, binder data, call-site +surgery, universe patches and `Named.original` valid, and a metadata-only edit cannot change +anonymous bytes (metadata is not part of `Constant`). + +## 6. Version, identifiers, fixtures and caches + +Policy (`docs/Ixon.md`, "Environment Serialization"): any byte change bumps the version, +readers reject a mismatch, there is no back-compat reading, and `.ixe` files are regenerated. + +| Item | Lean | Rust | Value | +|---|---|---|---| +| format version | `Ixon.Env.VERSION` | `Env::VERSION` | 4; `.ixe` header `0xE4` | +| object-format byte (claims, proofs, catalog manifests) | `Ixon.Env.OBJECT_FORMAT` | `Env::OBJECT_FORMAT` | 4 | +| wire format ID | `Ixon.wireFormatId` | `WIRE_FORMAT_ID` | `"ixon-v4"` | +| resource validator ID (profile prefix `/profile\0`) | `Ix.Resource.validatorId` | `resource::addressed::VALIDATOR_ID` | `"ixon-v4/resource-v1"` | +| catalog manifest version | `Ix.Catalog.VERSION` | `CATALOG_VERSION` | 2 (unchanged) | +| text grammar version | `Ixon.Syntax.VERSION` | `syntax::VERSION` | 3 (unchanged; it covers no integer bytes) | + +The env readers (Lean `getEnv`, `getEnvVerifiedLazy`; Rust `read_env_header`, used by +`Env::get`, `get_anon`, `get_anon_mmap` and `parse_lazy_index`) reject any other version with +"expected .ixe format version 4, got N — recompile the artifact". Claim and catalog readers +reject another object format with "claim: unsupported object format N, expected 4 — regenerate +the claim" ("catalog: …" likewise). The in-circuit claim readers require object format 4 +(§3.1). The scratch files of the `ixon-v4-*` executables live under `$IX_IXON_V4_DIR` (default +`/tmp`; `Tests/Ix/IxonV4Paths.lean`). + +**Fixtures and pins.** Each is regenerated by its producer, never edited by hand: + +| Fixture or pin | Location | Checked by | Producer | +|---|---|---|---| +| handoff set | `Tests/Fixtures/ixon-v4/handoff/` (`accepted.ixe`, `rejected-local-escape.ixe`, `profile.bin`, `accepted.claim`, `manifest.json`) | `ixon-v4-tests` (byte equality); `ix-kernel` `resource::tests::cross_language_consumer_handoff` | `lake exe ixon-v4-tests --export-handoff` | +| claims, addressed resources, resource cases | `Tests/Fixtures/ixon-v4/{claims,addressed,resource}.tsv` | `ixon-v4-tests` (whole files); `ixon` `proof::tests::v4_claim_fixtures_and_strict_scope`, `resource::addressed::tests::canonical_cross_language_fixtures` | `lake exe ixon-v4-tests --export-fixtures` | +| canonical primitive addresses | `Tests/Fixtures/ixon-v4/primitives.tsv`, `crates/common/src/prim_addrs.rs` (`PrimAddrs::new`), `Ix/Tc/Primitive.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 | +| env-bytes hash | `crates/compile/src/graph.rs` | `ix-compile` `graph::tests::setup_scan_preserves_compiled_fixture_bytes` | rerun and pin | +| 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 | + +Not regenerated, because their inputs are not available in the development environment: + +- `Benchmarks/Kernel/AnthropicFLT/cases.json` pins a 30 GB v3 artifact + (`flt-after-source-hints-1.ixe`) by sha256. Its addresses must be re-derived from that + artifact recompiled at v4; until then the harness rejects the old artifact by hash, and a v4 + binary rejects its header, so it cannot be consumed silently. +- The aggregate-proof fixture `Tests/Fixtures/Aggregate/mathlib-2026-09-03` is kept as a + historical v3 fixture; `stage2FixturePinnedAndFenced` (`Tests/AggrSemantics.lean`) pins its + wrapper and requires its rejection with "claim: unsupported object format". A dated v4 fixture + is produced on a large machine (compile, profile, shard, prove, aggregate, verify). + +**Caches and on-disk artifacts.** The TruthMines piece-cache key includes `ixe=` +(`Benchmarks/TruthMinesSpec/Main.lean`); `tc-parity.ixe` is recompiled when its header +carries another version (`Tests/Ix/Tc/ParityEnv.lean`). `comppoly.ixe` and `tauceti.ixe` are +user-built and gitignored; a stale one fails with the version error. CI caches `.ixe` files by +commit. To regenerate an `.ixe`: `lake exe ix compile .lean --out .ixe`. + +## 7. Risks + +1. **Lean/Rust disagreement of tiered outputs** would fork the address space. Fixtures, + generated inputs and the compiler route agree byte for byte (`exact-sharing-ffi`). On corpora + compiled at this PR's head, with Rust in its checked mode, all 56,622 Init constants and a + Mathlib sample of 20,284 constants give identical bytes, with no resource exhaustion on + either side, and the merge-queue suite `lake test -- --ignored compile` requires the Lean and + Rust compilers to write identical environments (237,295 constants) + (`sharing-minimum-performance.md`). +2. **Resource exhaustion in the compiler.** The construction fails closed; a constant over the + limits is a compile error for every caller (compile, aux-gen, kernel egress, decompile + recompile). The defaults sit far above every corpus maximum (Mathlib: largest MSS table + 21,461 entries; 81,833 candidates; largest table-count knapsack 9,959,424 cells against a + `knapsack_cells` default of 2^28), and `--sharing-limits` raises them. Neither language limits + the candidate count on this path. Lean and Rust count work differently (Rust's `work` charges + the evaluations actually done: one evaluation of the whole table in one pass, one per prefix + otherwise), so equal limits can succeed in one language and fail in the other; every observed + case was a Lean-only exhaustion that matched Rust once raised. +3. **The expansion step is outside the proofs** (§4): the canonical DAG is built by an interner + with a pointer cache. The round trip is re-checked at run time and pointer-layout + independence is tested. +4. **Width jumps.** TagN grows by one byte per rung end except by four at `R5`. The count + threshold (finding 7) and the telescope-spine guard (finding 8) cover the two arguments that + needed it; any new argument that assumes a header grows by at most one byte per boundary is + unsound from `R5` on. +5. **Recompile invariant.** Rust `roundtrip_block` requires recompiled addresses to equal + `Named.original`; the recompile calls the compile path's `apply_sharing_*` functions under + the compiler's limits, so it follows the route. +6. **Header aliasing** (finding 10), kept by decision. +7. **Stale artifacts.** Caches are keyed by the format version (§6). Artifacts pinned by hash + from outside the repository (the FLT benchmark) must be regenerated by their owners. +8. **Reader gaps** (§5.3): cyclic sharing tables, metadata or call-site references can make the + decompilers and kernel ingress loop. They predate this work and affect only malformed input; + reader hardening is follow-up work. +9. **Length range.** Rust's phase 1 uses 128-bit lengths and fails closed (`format bound: + LengthOverflow`) where Lean's `Nat` succeeds, for example on the chain + `e(i+1) = App(e(i), e(i))` at depth 127 or more. No Init or Mathlib constant is near it; the + divergence is documented, not removed. +10. **Rust's default mode checks built expressions for the returned candidate only.** A wrong + length of another candidate would change the selection without an error. The checked mode + (`ExactSharingLimits::full_check`) builds and checks all three; over all of Init and Mathlib + it gives the default mode's output. + +## 8. Implementation notes + +**Integer code.** One header byte, then 0, 1, 2, 3, 4 or 8 bytes; rung ends `tagNEnd1..tagNEnd5` +(Lean) / `TagN::end1..end5` (Rust); the 8-byte rung rejects values reaching `2^64`. For +`f = 4` every code is valid; for `f = 0, 2`, codes `c ≥ 4` are rejected. Deleted: the +`Tag0`/`Tag2`/`Tag4` structures and their `put`/`get`, `Serialize Tag4`, the three "noncanonical +… integer" checks, the Share-codec threading (`ShareCodec`, `putShare`, `getExprHeader`), and +the Rust `*_with` codec variants with their FFI hooks, and the Lean little-endian helpers +`putU64TrimmedLE`/`getU64TrimmedLE`/`u64ByteCount` (the TagN code uses `putU64TrimmedLEAux` +and `getU64TrimmedLEAux`; Rust keeps `u64_put_trimmed_le`/`u64_get_trimmed_le`). + +**Construction and route.** `ShareLayout` has the single constructor `tagN` +(`ShareLayout.wire = .tagN`). Phase 1 runs at each width `w ∈ {1, 2, 3}` and the cheapest +candidate in real bytes wins (ties to the lower width); the per-width candidate in the theorems +is `tieredAtWidth`. Removed with the heuristic: `Ix/Sharing.lean`, `crates/ixon/src/sharing.rs`, +`Ix/Compile/Verify/Sharing.lean` and its two audit roots (`rewriteWithSharing_wireWF`, +`applySharing_wireWF`), the heuristic seeds of the exact optimizers (the unshared length is the +initial bound), the `sharing` suite and the heuristic FFI hooks. Experiment hooks used during +development (forced phase-1 width, a fourth phase-1 candidate, the MSS inspector, the +`sharing_corpus` modes `--layout`, `--width-experiment` and `--mss-*`) are removed; the +forced-width entry point survives only as a crate-private test helper. Also removed: the Rust +`apply_sharing_with_stats` and `apply_sharing_to_*_with_stats` wrappers, +`SingletonSharingResult`, `MutualBlockSharingResult`, `block_stats`/`BlockSizeStats`, +`optimize_dag`, `optimize_dag_uniform`, `optimize_sharing_uniform_reference` and `tier2_end`. +Renamed: `check_canonical_sharing` → `check_exact_minimum` (Lean `checkCanonicalSharing` → +`checkExactMinimum`, `CanonicalCheck` → `ExactMinimumCheck`). + +**Rust checks and metering.** The module documentation of `crates/ixon/src/sharing_exact/tiered.rs` +("Checks") lists every check. In the default mode every limit and every phase-1 to phase-3 length +check applies to all three candidates, and the checks on built expressions run for the returned +candidate; the checked mode (`ExactSharingLimits::full_check`: unit tests, the FFI parity hooks, +`sharing_corpus --full-check`) runs them for all three. Phase 1 is a dry run that builds no +expressions; phase 3 evaluates the whole table once when the order is closed under stored +descendants and per prefix otherwise (an App spine of 1,288 nodes ending in a stored term reaches +the per-prefix path; it is a fixture in both languages, 7,105 bytes). The cargo feature +`ixon/sharing-profile` (off by default, compiled in CI) adds phase timers. + +**Limits.** Lean `Ix.Sharing.Exact.Limits` and Rust `ExactSharingLimits` hold the defaults +(`docs/Ixon.md`, "Canonical construction"). `Limits.withOverrides` (`parseLimitValue`) and +`ExactSharingLimits::with_overrides` (`parse_limit_value`) parse one grammar: values are ASCII +digits, `2^k` or `max`; items and keys are trimmed of spaces, tabs, line feeds and carriage +returns only; keys of the other language are accepted and ignored. One list of 35 +specifications pins both (`LIMIT_SPEC_PARITY` in `crates/ixon/src/sharing_exact/tests.rs`, +`limitSpecParity` in `Tests/Ix/SharingExact.lean`). `ix compile --sharing-limits` and +`ix compile-lean --sharing-limits` validate the override and publish it through +`IX_SHARING_LIMITS`. It is read once per run: by the Lean drivers `compileEnvParallelAux` and +`decompileEnvFullParallel` (`compilerSharingLimitsFromEnv`, carried in +`CompileEnv.sharingLimits`) and by each Rust compile or decompile entry point +(`CompileState::sharing_limits`); an invalid value fails the run once, before any block is +shared. + +**Test oracles.** The width-state search (`Ix.Sharing.Exact.Search`, `search.rs`, the `exact` +corpus mode), the tiny exhaustive oracle (`Exact.Oracle`, `oracle.rs`), the subset-enumeration +reference of phase 1 (`uniformSubsetSearch`, `uniform_subset_search`) and the MSS reference +encoding (`mss.rs`, test-only) are labelled as test oracles; the compiler path never calls them. + +**Tests.** + +- `exact-sharing` (`Tests/Ix/Sharing{Exact,Uniform,Tiered}.lean`): the plan's fixtures with + exact bytes, the uniform optimizer against the width-state reference, first-tier brute force, + idempotence, pointer-layout independence, the tiered path at scale (tables above 1,032 + entries, the 1,288-node spine, the parallel widths) and under each production limit, and the + limit grammar (`limitSpecParity`). +- `exact-sharing-ffi` (`Tests/Ix/SharingExactFFI.lean`): Lean and Rust bytes on fixtures, + generated inputs, Share-bearing constants with tables up to 66,600 entries (Shares in the 4-, + 5- and 9-byte rungs), the re-normalization of 119 table-carrying inputs, malformed tables, and + the compiler route. With `IX_SHARING_CORPUS=` it runs over + every constant of an `.ixe` (modes `tiered-tagN`, `uniform-w`, `exact`; + `IX_SHARING_CORPUS_MODES`, `IX_SHARING_CORPUS_SELECT`, `IX_SHARING_CORPUS_LIMIT`). +- `ixon` (`tagNUnits`: expected encodings, rejection vectors, rung-end vectors, boundary + round trips), with the same vectors in Rust `tag.rs`; `ixvm-tagn` for the circuit. +- `ixon-v4-tests` and `ixon-v4-primitives` (§6); the Rust `sharing_exact` tests, including + parallel against sequential byte identity. +- Benchmarks and studies: `sharing-study` (`Benchmarks/SharingStudy.lean`: the rebuild check, + round trip, unshared size and the MSS baseline), `lean-sharing-prof full|split|hash + [select-file]` (`Benchmarks/LeanSharingProf.lean`, the Lean construction's phase profile), + `uniform-hard` (`Benchmarks/UniformHard.lean`), and the Rust example `sharing_corpus` + (`crates/ixon/examples/sharing_corpus.rs`; `--full-check`, `--sharing-limits SPEC`, and + `--check-sequential`, which compares the parallel and sequential paths under the run's + limits). + +### Gates at this PR's head + +All passed: + +- Lean: `lake build --wfail -v`; `lake test --wfail` (primary tier, 3,957 checks); `lake lint -- + --wfail -v`; `lake build IxTcVerify` (audits of 2,034, 1 and 7 roots, sorry frontier clean); + `lake build IxCompileVerify --wfail` (250 roots; sorry frontier clean for `Ix.Compile.Verify` + and `Ix.Sharing`; all 19 `@[csimp]` theorems are roots); `lake exe ix codegen --check`; `diff + lean-toolchain Benchmarks/Compile/lean-toolchain`; `lake test --wfail -- cli`; `lake test + --wfail -- ffi`; `lake exe ixon-v4-primitives` then `lake exe ixon-v4-tests --primitives` + (2,052 golden checks, 4,054 VM checks, 3,540 addressed interfaces validated). +- Rust: `cargo fmt --all --check`; `cargo clippy --release --workspace --all-targets --features + ix-ffi/parallel,ix-ffi/net,ix-ffi/test-ffi,ixon/sharing-profile -- -D warnings`; `cargo check` + with the same features; `cargo test --release --workspace` (1,716 passed, 20 ignored); `cargo + deny check`. +- Merge-queue partitions run locally: `tc-unit`; the compile-pipeline partition + (`--ignored rust-canon-roundtrip serial-canon-roundtrip parallel-canon-roundtrip graph-cross + condense-cross rust-serialize ixon-corpus rust-decompile validate-aux aux-gen-diff + decompile-diff`); and `--ignored compile` (Lean and Rust compile all 237,295 constants of the + test environment; constants, metadata and serialized environments are identical), run on the + tree just before the final cleanup and documentation commits. The other ignored partitions + (`--ignored decompile`, the misc partition with the `ixvm` runner, the Tc ignored suites) are + run by the merge queue. + +## 9. Owner decisions on the questions of this map + +1. Scope of TagN: all three families, every header including claim, proof, comm and + assumption-tree headers (§12.12). Applied. +2. Object-format byte, validator ID, `wireFormatId`: bumped with the version to `4`, + `"ixon-v4/resource-v1"`, `"ixon-v4"` (§6). Applied. +3. Endpoint theorem: the real `wireWF` + capacity + backwardness theorem + (`canonicalSharingTiered_format`), with the endpoints stated over it (§4). Applied. +4. Compiler limits: a safety net with a CLI override (§7 risk 2). Applied. +5. `metaSharing`: the extended index space of `sharing-minimum.md` §13 (§5.3). Readers applied; + no construction. +6. IxVM: updated in this PR (§3.1). Applied. +7. Header aliasing: kept; the env header is TagN(4, `0xE`, version), `0xE4` for v4 + (finding 10). +8. Cost-model repricing: TagN widths in both languages (finding 3, §3.4). Applied. diff --git a/docs/sharing-minimum-measurements-mathlib.md b/docs/sharing-minimum-measurements-mathlib.md new file mode 100644 index 000000000..69c78f7a3 --- /dev/null +++ b/docs/sharing-minimum-measurements-mathlib.md @@ -0,0 +1,963 @@ +# Sharing corpus measurements on Mathlib + +This document reruns the corpus harness of [`sharing-minimum.md`](sharing-minimum.md), +`Benchmarks/SharingStudy.lean` (`lake exe sharing-study`), on a Mathlib corpus instead of `Init`. The harness is a +development version from before the heuristic was removed. The Init numbers quoted for comparison come from +[`sharing-minimum-measurements.md`](sharing-minimum-measurements.md) (its eighth run). Like that document, +this one reports measurements and does not choose a design. + +**Status.** The corpus is a format-v3 file (`Tag0`/`Tag2`/`Tag4` integers) whose sharing tables were built by the +heuristic sharing pass, the compiler route at the time; "stored", "current" and "heuristic" below refer to those +tables. Format v4 replaces the integer codes by TagN and the heuristic by the canonical construction +([`Ixon.md`, "Sharing System"](Ixon.md#sharing-system)); canonical-construction results on Mathlib are in +[`sharing-minimum-performance.md`](sharing-minimum-performance.md). The harness was trimmed twice afterwards: when +the heuristic was removed, and again before this PR, after which it keeps only the production rebuild check, the +decode/encode roundtrip, the unshared size and the MSS baseline (`--occ-check-max`, the candidate statistics and +`--meta` are gone), and its rebuild check now runs the canonical construction. Reproducing this document therefore +needs the development version of the harness used for the Mathlib run and the v3 corpus, +neither of which is in this PR. + +The harness used for the Mathlib run has six measurements: + +- P1.5 statistics; +- the production rebuild check; +- MSS (maximal structural sharing); +- the uniform-width classification and its components; +- the reference widths of the stored encoding; +- the Share-width schemes A–G. + +It does **not** call the exact uniform or tiered optimizers (`optimizeSharingUniform`, `canonicalSharingTiered`). +Their results are therefore not measured here. + +## Corpus + +- **Command:** `lake exe ix compile Benchmarks/Compile/CompileMathlib.lean --out /mathlib.ixe`, run + from the repository root (exact invocation under Reproduction). It exited 0. The dependencies went into the + untracked `Benchmarks/Compile/.lake`, and `git status` afterwards showed no tracked or unignored changes. + - `CompileMathlib.lean` is `import Mathlib`. It is a classic (non-`module`) file, so the compiled scope is the + whole import environment (`Ix.EnvScope.defaultConstList`). That is the Lean core libraries, Mathlib and Mathlib's + dependencies. + - The other packages pinned in `Benchmarks/Compile/lakefile.toml` (FLT, TorchLean, TauCeti, …) were cloned during + dependency resolution but are not imported by this file. +- **Output:** `mathlib.ixe`, **3,343,271,273 bytes** (Ixon format version 3). + - `ix compile` printed `Total constants: 771129`. That is the number of Lean constants requested. + - The compile report gives 778,344 named entries, 679,499 unique anonymous constants and **0 ungrounded**. The + consts Merkle root is `0d7113f779cebbeda85886afe548433263db8ec51e9e5eb8e726055918ef5d23`. + - The harness loads 679,499 stored constants (distinct addresses) and 778,344 names. +- **Wall time:** 7 min 29 s end to end, from GNU `time -v`. + - That includes resolving and cloning the dependencies, building and running `lake exe cache get`, the + `lake build CompileMathlib` replay and elaboration of the import environment. + - The compile itself (source preparation, Rust compile and write) printed **152.42 s**. + - The Mathlib cache needed no download: `Decompressing 8689 already-cached file(s)`, `No files to download`. +- **Peak memory:** GNU `time` maximum resident set size 19,107,692 kB. The `--json` tree-RSS sampler reported + 19,565,625,344 bytes, the same 18.2 GiB. +- **Relation to Init:** the corpus contains the Init corpus. + - Matching rows on the 16-hex-digit address prefix in the two CSVs, 56,621 of the 56,622 `init.ixe` rows are rows + of `mathlib.ixe`. + - The missing row is `main`, the one-line program that `Benchmarks/CompileInit.lean` defines itself. + - On the 55,385 shared rooted constants, the Mathlib run reproduces the Init MSS results: 50,173 smaller, 4,993 + equal (Init's 4,994 include `main`) and 219 larger. + - So every Mathlib total below includes Init. Where useful, the 607,869 rooted constants that are **not** in + `init.ixe` are reported separately. + +## Headline: P1.5 distributions + +All 679,499 stored constants were processed. None was skipped. 663,254 have at least one expression root (Init: +55,386 of 56,622). Values are over rooted constants. Each cell gives Init / Mathlib. + +| | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| distinct subterms `N` | 1 / 1 | 86 / **147** | 470 / **692** | 2,015 / **3,052** | 27,628 / **95,110** | 215.50 / **329.91** | +| candidates after R1+R2 (`occ ≥ 2`, size > 1) | 0 / 0 | 34 / **69** | 232 / **432** | 1,187 / **2,029** | 22,458 / **81,833** | 109.96 / **196.76** | +| candidates with size > 3 | 0 / 0 | 25 / **56** | 193 / **390** | 1,113 / **1,941** | 22,224 / **81,726** | 94.42 / **177.67** | +| current heuristic table size | 0 / 0 | 26 / **58** | 203 / **376** | 1,096 / **1,901** | 22,088 / **81,565** | 96.21 / **177.14** | +| stored bytes (`rawBytes.size`) | 9 / 9 | 693 / **1,112** | 3,081 / **4,510** | 11,329 / **18,597** | 170,285 / **608,188** | 1,447.33 / **2,213.75** | +| MSS table size (`deg ≥ 2`, size > 1) | 0 / 0 | 12 / **20** | 102 / **122** | 437 / **541** | 5,146 / **21,461** | 42.35 / **54.57** | +| max telescope length | 0 / 0 | 6 / **8** | 10 / **15** | 17 / **27** | 95 / **112** | 6.59 / **8.82** | + +**Candidate counts (R1+R2, `occ`-based), constants with at least one root:** + +| candidates | Init | share | Mathlib | share | +|---|---:|---:|---:|---:| +| = 0 | 554 | 1.0% | 4,886 | 0.7% | +| ≤ 8 | 9,532 | 17.2% | 67,177 | **10.1%** | +| ≤ 16 | 16,600 | 30.0% | 121,321 | 18.3% | +| ≤ 32 | 26,799 | 48.4% | 206,933 | 31.2% | +| ≤ 64 | 37,298 | 67.3% | 318,883 | 48.1% | +| ≤ 128 | 45,372 | 81.9% | 439,602 | 66.3% | +| ≤ 256 | 50,438 | 91.1% | 542,987 | 81.9% | +| ≤ 1,024 | 54,673 | 98.7% | 642,850 | 96.9% | +| > 1,024 | 713 | 1.3% | 20,404 | 3.1% | +| > 4,096 | 80 | | 1,689 | | +| > 16,384 | 6 | | 66 | | +| > 65,536 | 0 | | 1 | | + +- The rows "= 0", "≤ 256", "≤ 1,024" and "> 1,024" and the rows below them come from the CSVs. The rest are in the + harness output. +- With the size > 3 cutoff instead: 15.1% of Mathlib's rooted constants are ≤ 8 and 29.8% (197,576) are above 128. +- **Two candidate notions.** The `occ`-based P1.5 count is far larger than the compact-indegree set (`deg ≥ 2`, + the MSS stored set and the candidates of the uniform classification). + - For the constant with the most `occ`-based candidates (81,833), the `deg`-based set has 21,461 members. + - Over all rooted Mathlib constants the `deg`-based set totals 36,191,166 against 130,502,728 `occ`-based + candidates. +- **Totals:** + - Stored bytes are 1,468,890,902 over all rows. Of these, `defn`s hold 1,457,076,542 and 1,468,281,356 belong to + rooted constants. + - The heuristic's stored bytes exceed the unshared encoding for **20,237** rooted constants (Init: 600). + - The aggregate unshared size (214,351,802,561,585 bytes) is dominated by a few compositional sizes and is not + meaningful as a total (see "Limits and coverage"). +- **Longest telescopes:** + - App 106 (`Lean.Meta.Grind.Arith.Cutsat.EqCnstr._sizeOf_6`); + - Lam 112 and All 106 (the `muts` row `Ix.54eed55d….Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.rec`, a block of 21 + recursors). + +### Ten constants with the most candidates + +| # | constant | kind | `N` | candidates (`occ`) | heuristic table | stored B | MSS table (`deg`) | MSS B | unshared B | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` | defn | 95,110 | 81,833 | 81,565 | 608,188 | 21,461 | 349,429 | 1,406,312,108 | +| 2 | `_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.«0».RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1` | defn | 70,414 | 61,641 | 61,496 | 447,246 | 11,700 | 273,355 | 87,682,564 | +| 3 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` | defn | 78,913 | 59,202 | 58,798 | 471,381 | 13,054 | 298,739 | 41,940,708 | +| 4 | `AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective` | defn | 66,025 | 52,066 | 51,767 | 398,085 | 10,555 | 239,810 | 82,279,088 | +| 5 | `AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq` | defn | 53,511 | 44,632 | 44,492 | 336,490 | 12,056 | 206,097 | 5,917,704,097 | +| 6 | `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux` | defn | 64,047 | 41,872 | 41,529 | 350,617 | 8,745 | 213,303 | 80,464,470 | +| 7 | `CategoryTheory.Limits.colimitLimitToLimitColimit_surjective` | defn | 43,441 | 38,789 | 38,598 | 269,209 | 8,957 | 153,471 | 7,349,541,595,358 | +| 8 | `_private.Mathlib.RingTheory.Etale.QuasiFinite.«0».Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq'` | defn | 53,222 | 38,483 | 38,220 | 307,182 | 7,317 | 179,803 | 61,675,147 | +| 9 | `WeierstrassCurve.addSubMapCoeff_condition` | defn | 42,875 | 35,702 | 35,499 | 272,192 | 8,048 | 169,951 | 73,921,037 | +| 10 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_decl_eq._mutual` | defn | 44,737 | 35,231 | 34,940 | 270,991 | 6,866 | 168,437 | 27,374,524 | + +All ten are `defn`s. Init's ten had 9,614–22,458 candidates. Mathlib's have 35,231–81,833 candidates and stored +sizes of 271–608 KB. The MSS columns come from the CSV. + +## Verification (rebuild mismatches and other checks) + +- **Production rebuild:** **0 mismatches out of 679,499** (Init: 0 of 56,622). + - For every constant the harness expanded the stored table and recovered the roots with + `Ix.CompileM.constantInfoRootExprs`. + - It then rebuilt the constant with `Ix.CompileM.buildConstantWithSharing` (Lean's heuristic) and compared + `serConstant` byte for byte with `rawBytes`. + - The corpus was written by the Rust compiler, so this also shows that Lean's heuristic reproduces Rust's bytes on + the whole Mathlib import environment. +- **Decode/encode roundtrip:** 0 differences. +- **Unshared size:** + - Compositional vs serialized: 678,880 equal, **0** different. + - 619 not serialized, because their unshared roots exceed `--validate-max` = 16 MiB. +- **`occ` vs brute-force tree walk:** + - 648,450 equal, **0** different. + - 31,049 not walked, because their unshared roots exceed `--occ-check-max` = 64 KiB. +- **MSS:** + - Built for all 679,499 constants. Each was decoded, re-encoded byte-identically and expanded, and its roots + compared for exact structural equality with the original expanded roots: 679,499 ok, **0** failed. + - The plan §2 witnesses gave 17 / 46 / 25 bytes as expected. + - The three negative controls behaved as expected. +- **Uniform-width classification:** + - 0 classification errors; no candidate met both certain conditions and none had `payloadMin > payloadMax`, for any + `w`. + - The fast component computation agrees with the literal brute force on all 623,572 rooted constants with + ≤ 1,000 DAG nodes, with 0 differences for each `w`. 39,682 were not checked (more than 1,000 nodes). +- **Share counts:** + - The Share nodes in the MSS encoding equal `Σ deg` over the MSS entries for all 663,254 rooted constants. + - The scheme E, F and G index buckets sum to the scheme A count for all of them. +- **Exit status:** the harness exited 0. Its exit status is nonzero if any of the checks above fails or any constant + is skipped. + +## MSS vs heuristic vs unshared + +Over rooted constants. Byte counts are exact serialized lengths. + +| encoding | Init total bytes | Init vs heuristic | Mathlib total bytes | Mathlib vs heuristic | +|---|---:|---:|---:|---:| +| heuristic (stored `rawBytes`) | 80,161,846 | | 1,468,281,356 | | +| MSS | 68,547,873 | −11,613,973 (−14.5%) | 1,148,195,956 | **−320,085,400 (−21.8%)** | +| unshared | 1,069,954,757 | | 214,351,801,952,039 | | + +**Per constant (MSS − heuristic):** + +| outcome | Init | Mathlib | Mathlib bytes | +|---|---:|---:|---:| +| MSS smaller | 50,173 (90.6%) | **625,250 (94.3%)** | −320,096,419 | +| equal | 4,994 (9.0%) | 35,859 (5.4%) | 0 | +| MSS larger | 219 (0.4%) | **2,145 (0.3%)** | +11,019 | + +- **Losses (Mathlib):** p50 3, p90 10, p99 33, max **112**, mean 5.14 bytes. Init: max 50, total 933. +- **Savings:** p50 132, p90 1,080, p99 6,352, max 258,759 bytes. +- **Signed Δ = MSS − heuristic:** min −258,759, p1 −6,139, p10 −1,006, p50 −117, p90 −4, p99 0, max +112. +- **Rooted constants not in `init.ixe`** (607,869; from the CSVs): + - heuristic 1,388,119,806 bytes, MSS 1,079,648,379 bytes, **−22.2%**; + - smaller 575,077, equal 30,866, larger 1,926. +- **MSS/heuristic by kind:** + + | kind | Init | Mathlib | + |---|---:|---:| + | defn | 85.5% | 78.2% | + | recr | 83.2% | 76.7% | + | muts | 96.6% | 89.1% | + | axio | 99.4% | 99.4% | + | quot | 100.0% | 100.0% | + +- **Table sizes:** + - MSS: median 20, p90 122, p99 541, max 21,461, 36,191,166 entries in total. + - Heuristic: median 58, p90 376, p99 1,901, max 81,565, 117,489,057 entries in total. +- **Largest losses** are `Std.Http.Status` eliminators: `casesOn` +112 (61 heuristic entries vs 125 MSS entries), + `rec` +110 and `recOn` +110. They are followed by `Std.Http.Status.toCode` +105, `.ctorElim` +103 and the + `Std.Http.Method` eliminators (+64, +66). +- **Largest wins** are the largest constants: `isIso_ranCounit_app_of_isDenseSubsite` −258,759 (608,188 → + 349,429). + +### Where MSS loses + +These facts come from the CSV. They are correlations, not a measured decomposition, as on Init. + +- **All 2,145** constants where MSS is larger have more than 8 MSS entries, so some of their Share references are + 2 bytes wide. + - 2,134 of them have more MSS entries than heuristic entries. + - 1,240 have at most 8 heuristic entries but more than 8 MSS entries. On Init those counts were 219 of 219, 217 + and 116. +- Over all rooted Mathlib constants, MSS has more entries than the heuristic for 31,946 constants (Init: 4,484). + +### MSS larger than unshared: 26 constants (Init: 0) + +The §12.2 observation that MSS was "never larger than unshared" does **not** hold on Mathlib. **26** rooted +constants have MSS bytes above their unshared bytes, by 188 bytes in total and at most 38. All 26 have more than 8 +MSS entries, and none of them is in `init.ixe`. The full list, from the CSV: + +| constant | heuristic B | MSS B | unshared B | MSS − unshared | heuristic table | MSS table | MSS refs < 8 / 8–255 | +|---|---:|---:|---:|---:|---:|---:|---| +| `Std.Http.Status.casesOn` | 3,005 | 3,117 | 3,079 | +38 | 61 | 125 | 18 / 234 | +| `Std.Http.Status.recOn` | 2,999 | 3,109 | 3,073 | +36 | 61 | 124 | 18 / 232 | +| `Std.Http.Method.recOn` | 1,879 | 1,943 | 1,925 | +18 | 36 | 76 | 18 / 136 | +| `contMDiffWithinAt_finset_prod` | 1,199 | 1,231 | 1,220 | +11 | 8 | 26 | 28 / 40 | +| `contMDiffWithinAt_finset_sum` | 1,199 | 1,231 | 1,220 | +11 | 8 | 26 | 28 / 40 | +| `ContMDiff.along_snd` | 1,218 | 1,254 | 1,247 | +7 | 8 | 27 | 42 / 56 | +| `contMDiffWithinAt_finset_prod'` | 1,244 | 1,274 | 1,268 | +6 | 8 | 25 | 31 / 38 | +| `contMDiffWithinAt_finset_sum'` | 1,244 | 1,274 | 1,268 | +6 | 8 | 25 | 31 / 38 | +| `ContMDiff.along_fst` | 1,218 | 1,251 | 1,246 | +5 | 8 | 26 | 42 / 54 | +| `contMDiff_finset_prod` | 1,151 | 1,177 | 1,172 | +5 | 8 | 23 | 28 / 35 | +| `contMDiff_finset_sum` | 1,151 | 1,177 | 1,172 | +5 | 8 | 23 | 28 / 35 | +| `ContMDiffAt.along_fst` | 1,264 | 1,300 | 1,296 | +4 | 8 | 27 | 45 / 57 | +| `Lean.Lsp.SymbolKind.casesOn` | 1,249 | 1,285 | 1,281 | +4 | 22 | 48 | 18 / 80 | +| `contMDiffAt_finset_prod` | 1,155 | 1,181 | 1,178 | +3 | 8 | 23 | 30 / 34 | +| `contMDiffAt_finset_sum` | 1,155 | 1,181 | 1,178 | +3 | 8 | 23 | 30 / 34 | +| `contMDiffOn_finset_prod` | 1,191 | 1,217 | 1,214 | +3 | 8 | 23 | 30 / 34 | +| `contMDiffOn_finset_sum` | 1,191 | 1,217 | 1,214 | +3 | 8 | 23 | 30 / 34 | +| `Lean.Lsp.CompletionItemKind.recOn` | 1,204 | 1,238 | 1,235 | +3 | 21 | 46 | 18 / 76 | +| `_private.Lean.Parser.Types.«0».Lean.Parser.withStackDrop` | 598 | 607 | 604 | +3 | 6 | 13 | 18 / 10 | +| `_private.Mathlib.Order.Notation.«0».Mathlib.Meta.linearOrderToMax` | 978 | 999 | 996 | +3 | 8 | 19 | 19 / 22 | +| `_private.Mathlib.Order.Notation.«0».Mathlib.Meta.linearOrderToMin` | 978 | 999 | 996 | +3 | 8 | 19 | 19 / 22 | +| `ContMDiffAt.along_snd` | 1,263 | 1,298 | 1,296 | +2 | 8 | 27 | 47 / 55 | +| `Lean.Lsp.SemanticTokenType.casesOn` | 1,159 | 1,191 | 1,189 | +2 | 20 | 44 | 18 / 72 | +| `Lean.Server.Completion.idCompletion` | 539 | 541 | 539 | +2 | 0 | 9 | 16 / 2 | +| `Lean.Parser.withResetCacheFn` | 997 | 1,007 | 1,006 | +1 | 8 | 17 | 17 / 18 | +| `_private.Lean.Meta.Basic.«0».Lean.Meta.mkFreshExprMVarAtCore` | 1,007 | 1,015 | 1,014 | +1 | 2 | 12 | 23 / 8 | + +None of them has a Share index ≥ 256. + +## Uniform-reference-width classification and components + +The candidates are the `deg ≥ 2`, size > 1 terms: 36,191,166 of them, equal to the MSS entry total. The +definitions are unchanged from the Init document. Init's percentages are in parentheses. + +| w | certain-stored | certain-excluded | uncertain | +|---:|---:|---:|---:| +| 1 | 31,975,849 (**88.4%**; Init 80.5%) | 0 (0%; Init 0%) | 4,215,317 (11.6%; Init 19.5%) | +| 2 | 25,708,230 (**71.0%**; Init 64.1%) | 3,712,253 (10.3%; Init 14.9%) | 6,770,683 (18.7%; Init 21.0%) | +| 3 | 20,941,150 (**57.9%**; Init 54.4%) | 8,690,905 (24.0%; Init 24.3%) | 6,559,111 (18.1%; Init 21.3%) | + +**Uncertain nodes per constant and largest uncertain component (Mathlib; Init in parentheses):** + +| w | uncertain nodes: median / p90 / p99 / max | > 1,024 | largest component: median / p90 / p99 / max | ≤ 8 | > 32 | +|---:|---|---:|---|---:|---:| +| 1 | 1 / 15 / 82 / 3,480 (Init 2 / 21 / 95 / 970) | 38 (Init 0) | 1 / 2 / 4 / **45** (Init 1 / 2 / 4 / 45) | 662,872 = 99.9% (Init 99.9%) | 4 (Init 2) | +| 2 | 4 / 24 / 90 / 2,670 (Init 3 / 22 / 84 / 736) | 20 (Init 0) | 1 / 3 / 5 / **44** (Init 1 / 3 / 5 / 44) | 662,851 = 99.9% (Init 99.9%) | 3 (Init 1) | +| 3 | 3 / 24 / 102 / 3,077 (Init 2 / 22 / 98 / 978) | 35 (Init 0) | 1 / 3 / 5 / **44** (Init 1 / 3 / 6 / 44) | 662,118 = 99.8% (Init 99.7%) | 3 (Init 1) | + +- **Constants keep many uncertain nodes but small components.** Some constants have thousands of uncertain nodes, + yet the largest component does not grow with the corpus. + - The largest components are the same as Init's: 45 at w = 1 and 44 at w = 2 and 3, in `Lean.Grind.Config.mk.injEq` + (which is in `Init`). + - Next come `Lean.Meta.Grind.Arith.Linear.Struct.mk.injEq` (42 / 41 / 41) and + `_private.Std.Time.Format.Basic.«0».Std.Time.GenericFormat.DateBuilder.mk.injEq` (36 / 35 / 35). + - At w = 1, excluding the six Lean, Std and Init constants that lead the list, the largest component is 28, in + `CategoryTheory.Bicategory.rightZigzag_idempotent_of_left_triangle`. +- **The constant with the most candidates** (`isIso_ranCounit_app_of_isDenseSubsite`, 21,461 `deg`-based + candidates) has 3,077 uncertain nodes at w = 3, and its largest component has 3 nodes (CSV). +- **Literal `headdeg` reading:** reading `headdeg` as "not the function child of an App" for any `t` changes the + class of 1,511, 2,371 and 4,068 candidates for w = 1, 2 and 3, out of 36,191,166. + +## Share-width schemes on the MSS encoding (tier-scheme comparison) + +There are 159,110,515 Share references in the MSS encodings. Constant bytes under a scheme are +`MSS bytes − refbytes(A) + refbytes(scheme)`. + +| scheme | reference bytes | MSS constant bytes | Δ vs A | Mathlib Δ / MSS total | Init Δ / MSS total | MSS below heuristic (Mathlib, derived) | +|---|---:|---:|---:|---:|---:|---:| +| A (Tag4 index tiers) | 298,286,517 | 1,148,195,956 | 0 | | | 21.80% | +| B (2 or 3 per constant) | 325,217,289 | 1,175,126,728 | +26,930,772 | +2.35% | +2.07% | 19.97% | +| C (1, 2 or 3 per constant) | 323,081,186 | 1,172,990,625 | +24,794,669 | +2.16% | +1.69% | 20.11% | +| D (fixed per constant, nibble index) | 314,797,020 | 1,164,706,459 | +16,510,503 | +1.44% | +0.93% | 20.68% | +| E (< 15 / < 4,111; not realizable) | 260,743,267 | 1,110,652,706 | −37,543,250 | −3.27% | −3.10% | 24.36% | +| F (< 8 / < 1,032 / beyond) | 280,471,878 | 1,130,381,317 | **−17,814,639** | **−1.55%** | −1.45% | 23.01% | +| G (< 14 / < 270 / beyond) | 283,411,489 | 1,133,320,928 | −14,875,028 | −1.30% | −1.21% | 22.81% | + +The last column is `1 − scheme bytes / 1,468,281,356`. + +**Per constant (better / equal / worse vs A):** + +| comparison | Init | Mathlib | +|---|---|---| +| B vs A | 829 / 555 / 54,002 | 12,165 / 4,900 / 646,189 | +| C vs A | 829 / 22,271 / 32,286 | 12,165 / 181,451 / 469,638 | +| D vs A | 9,773 / 22,271 / 23,342 | 127,316 / 181,451 / **354,487** | +| E vs A | 33,116 / 22,270 / 0 | 481,817 / 181,437 / 0 | +| F vs A | 1,352 / 54,034 / 0 | 23,301 / 639,953 / **0** | +| G vs A | 33,116 / 22,270 / 0 | 481,817 / 181,437 / **0** | + +- **Width classes under D:** 296,310 constants at 1 byte, 366,880 at 2 bytes and 64 at 3 bytes (Init: 31,200 / + 24,180 / 6). 342 constants have more than 2,048 MSS entries (width 3 under B and C; Init 20). +- **Restricted to the 111,351 constants whose heuristic table exceeds 255 entries:** D − A = +4,213,286 bytes + (+0.70% of their MSS bytes). On Init the same restriction gave −299,355 (−1.18%), so on Mathlib D is worse than + the index tiers even on large tables. B − A is +8,646,111 (+1.44%), against −84,068 on Init. +- **TagN:** + - `tagNWidth` (`Ix/Sharing/Exact/Tiered.lean`) is 1 byte below index 8, 2 below 1,032 and 3 below 66,568. + - The largest MSS table in Mathlib has 21,461 entries. So scheme F's column is exactly the TagN price of the MSS + table in MSS priority order, for every constant. + - That is not the output of `canonicalSharingTiered tagN`, which chooses its own table and order; the harness + does not run it. +- **Largest scheme losses and gains:** + - The ten largest losses are the same ten constants under B and D, with 5,768–21,461 MSS entries. They are + led by `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux` +32,968 and + `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` +32,894. + - The ten largest gains under D come from constants with 3,009–4,011 MSS entries, led by + `WeierstrassCurve.ofJNe0Or1728_Δ` −23,273. + - The largest gain under F is `WeierstrassCurve.variableChange_Δ` −25,496. + - The ten of each are in the harness output below. + +### Reference widths in the current stored (heuristic) encoding + +| stored table entries | constants | refs to 0–7 | refs to 8–255 | refs to ≥ 256 | loss under a uniform width | +|---|---:|---:|---:|---:|---| +| 1–8 | 77,332 | 834,671 | 0 | 0 | (not requested) | +| 9–255 | 456,938 | 8,413,579 | 46,923,657 | 0 | w = 2: 8,413,579 B (0.57% of stored bytes; Init 0.97%) | +| > 255 | 111,351 | 4,535,443 | 55,312,965 | 81,989,876 | w = 3: 64,383,851 B (4.38%; Init 3.99%) | + +Total Share references are 198,010,191, over 1,468,890,902 stored bytes. + +The harness labels references at index ≥ 256 as 3 bytes. That is not exact on Mathlib (see the next section). + +## Limits and coverage + +No constant was skipped and no step failed or timed out. The harness has no per-constant time or resource limit. The +slowest constant took 2.71 s +(`_private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.«0».WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three`), +and 5 constants took more than 2 s. The harness's deliberate verification limits left these constants unchecked: + +- **Unshared size not validated by serialization: 619 constants** (Init: 7). + - Their unshared roots exceed 16 MiB, so their unshared sizes rely on the compositional function only. 37 of them are + at least 2^30 bytes. + - The largest is `_private.Mathlib.Condensed.Light.Sequence.«0».InternalProjectivityProof.aux`: + 206,476,428,890,489 unshared bytes (about 2.1·10^14), stored in 54,261 bytes. + - The next are `CategoryTheory.Limits.colimitLimitToLimitColimit_surjective` (7.3·10^12) and + `IsEvenlyCovered.toTrivialization_apply` (1.4·10^11). + - The twenty largest are named in the harness output below. All 619 are the rows of the per-constant CSV + (`--csv`) whose `unshared_validated` column is empty. + - Because of these constants the aggregate unshared total and the "stored/unshared" ratio (printed as 0.0%) are + meaningless. +- **`occ` not checked by the brute-force tree walk: 31,049 constants** (unshared roots > 64 KiB; Init 1,232). +- **Component brute force not run: 39,682 rooted constants** (more than 1,000 DAG nodes; Init 1,734). +- **One stored table exceeds the 3-byte Tag4 index range.** + - `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` stores 81,565 heuristic entries. + `putTag4` writes `1 + byteCount(n)` bytes for `n ≥ 8`, so a Share index ≥ 65,536 costs 4 bytes. + - The harness's syntactic reference-width table counts all 146,926 of this constant's references to indices ≥ 256 + in the "3 B" column. The number at indices ≥ 65,536 was not measured. + - So the w = 3 loss figure above omits a 1-byte difference for each such reference: at most 146,926 bytes, + 0.23% of that figure. + - Its stored bytes are exact, as the rebuild check confirms. + - No MSS table reaches 65,536 entries (max 21,461), so the MSS scheme pricing (A–G) is exact. +- **Not measured at all:** + - the exact uniform and tiered optimizers (not in the merged harness); + - the width-state DP oracle; + - the 9 other `Benchmarks/Compile` targets. + +## Reproduction + +The commands ran with that harness version, from the repository root, detached with `setsid nohup … > log 2>&1 &`. `$S` is +any output directory. The `time` command is GNU time 1.9. + +```text +nix develop --command bash -c 'lake build ix sharing-study' +# -> Build completed successfully (843 jobs). + +nix develop --command bash -c "time -v lake exe ix compile Benchmarks/Compile/CompileMathlib.lean \ + --out $S/mathlib.ixe --verbose --json $S/mathlib-compile.json --report $S/mathlib-report.json" +# -> exit 0, 7:29.18 wall, max RSS 19,107,692 kB; "Total constants: 771129"; +# "Compiled and wrote 3.1 GB env to …/mathlib.ixe in 152.42s"; report: 0 ungrounded. + +nix develop --command bash -c "time -v lake exe sharing-study $S/mathlib.ixe \ + --md $S/mathlib-results.md --csv $S/mathlib-sharing.csv --progress 20000" +# -> exit 0, 1:33:50 wall (5,572 s user), max RSS 4,709,872 kB; +# "processed 679499 constants, skipped 0, mismatches 0 in 4101800 ms (total 4106730 ms)" +``` + +- **Compile flags:** `--verbose`, `--json` and `--report` only add progress logging and the two JSON files. The + required command is the one in the first bullet of "Corpus". +- **Compile process tree:** it used 435% CPU, 1,781 s user. +- **Harness timing:** + - The harness is single-threaded. Its internal timer gives 4.9 s to load the 3.3 GB file and 4,101.8 s to + measure. Init's eighth run took 295.0 s for 12× fewer constants. + - The remaining ~25 minutes of process wall time are lake startup plus the work after the measurement loop + (summary tables over 679,499 rows and the CSV). They were not broken down further. +- **Machine load:** another `sharing-study` run on `init.ixe` was running on the same machine at the same time. +- **CSV:** the per-constant CSV is 139,383,903 bytes, with 679,499 rows plus a header and the same 55 columns as the + Init CSV. It is too large to track; the `--csv` option above regenerates it. +- **Other untracked outputs** of this run: + - the compile and harness logs; + - `mathlib-report.json` and `mathlib-compile.json` (from `--report` and `--json`); + - the list of the 619 unvalidated constants and of the 26 constants whose MSS encoding exceeds the unshared one, + both filtered from the CSV; + - two gawk scripts over the CSVs behind the CSV-derived numbers (the overlap with Init and the counts checked + against the Init document; the check script reproduces that document's CSV-derived counts on the Init CSV). + +--- + +The rest of this document is the harness's `--md` output from this run, unedited apart from the corpus path. + +## Results + +- Corpus: `$S/mathlib.ixe` (3343271273 bytes), 679499 stored constants (distinct addresses), 778344 names. +- Constants processed: 679499; skipped: 0; with at least one expression root: 663254. +- Harness wall time: load 4930 ms, measurement 4101800 ms, total 4106730 ms. +- Production rebuild (`buildConstantWithSharing` on expanded roots, then `serConstant`) differs from `rawBytes`: **0** constants. +- Decode/encode roundtrip (`serConstant ∘ get`) differs from `rawBytes`: 0 constants. +- Compositional unshared size checked against `serConstant` of the real unshared Constant: 678880 equal, 0 different, 619 not checked (unshared roots > 16777216 bytes). +- `usageCount` (occ) checked against a brute-force walk of the fully expanded roots: 648450 equal, 0 different, 31049 not checked (unshared roots > 65536 bytes). +- Constants whose stored (heuristic) bytes exceed their unshared bytes: 20237. +- Total `rawBytes.size`: 1468890902; total unshared Constant bytes: 214351802561585. + +### Constants whose unshared size was not validated by serialization + +| constant | kind | unshared bytes | stored bytes | +|---|---|---:|---:| +| `_private.Mathlib.Condensed.Light.Sequence.«0».InternalProjectivityProof.aux` | defn | 206476428890489 | 54261 | +| `CategoryTheory.Limits.colimitLimitToLimitColimit_surjective` | defn | 7349541595358 | 269209 | +| `IsEvenlyCovered.toTrivialization_apply` | defn | 139464075123 | 44235 | +| `_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.«0».CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_19` | defn | 133910934629 | 85056 | +| `groupCohomology.H1InfRes_exact` | defn | 34706856435 | 150010 | +| `Rep.instMonoidalCategory._proof_14` | defn | 21664521473 | 55700 | +| `AlgebraicGeometry.isIso_fromTildeΓ_of_presentation` | defn | 17730160456 | 36910 | +| `LieModule.Cohomology.d₂₃._proof_12` | defn | 8161802819 | 41764 | +| `_private.Mathlib.Condensed.Light.Sequence.«0».InternalProjectivityProof.cocone._proof_1` | defn | 7065129700 | 47350 | +| `AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq` | defn | 5917704097 | 336490 | +| `CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.associator._proof_19` | defn | 5065316295 | 36721 | +| `CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.pentagon` | defn | 5050666179 | 80968 | +| `LieModule.Cohomology.d₂₃._proof_11` | defn | 4899565702 | 34946 | +| `RootPairing.GeckConstruction.equivRootSystem._proof_2` | defn | 4194198945 | 29707 | +| `AlgebraicGeometry.Scheme.Hom.instIsIsoNormalizationPullbackOfSmooth` | defn | 4106683646 | 149885 | +| `retractionKerCotangentToTensorEquivSection._proof_20` | defn | 3562698142 | 191668 | +| `CategoryTheory.PreOneHypercover.sieve₁_inter` | defn | 3396754573 | 116317 | +| `_private.Mathlib.RingTheory.Extension.Cotangent.Basis.«0».Algebra.Generators.PresentationOfFreeCotangent.Aux.tensorCotangentHom_tmul` | defn | 3043638137 | 28730 | +| `Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.denote_blastDivSubtractShift_q` | defn | 3026502579 | 39708 | +| `AlgebraicGeometry.Scheme.Hom.toNormalization_app_preimage` | defn | 2989993634 | 42047 | + +### Distributions over constants with at least one root (663254) + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| `N` (distinct subterms) | 1 | 147 | 692 | 3052 | 95110 | 329.91 | +| `occ ≥ 2` (R1 only) | 0 | 78 | 443 | 2041 | 81846 | 204.48 | +| candidates (R1+R2: occ ≥ 2, size > 1) | 0 | 69 | 432 | 2029 | 81833 | 196.76 | +| candidates with size > 2 | 0 | 65 | 417 | 1998 | 81779 | 189.88 | +| candidates with size > 3 | 0 | 56 | 390 | 1941 | 81726 | 177.67 | +| current table size | 0 | 58 | 376 | 1901 | 81565 | 177.14 | +| `rawBytes.size` | 9 | 1112 | 4510 | 18597 | 608188 | 2213.75 | +| unshared Constant bytes | 9 | 1344 | 19354 | 695929 | 206476428890489 | 323182071.95 | +| max telescope length | 0 | 8 | 15 | 27 | 112 | 8.82 | +| roots | 1 | 2 | 2 | 2 | 105 | 2.01 | + +### Distributions over all processed constants (679499, projections included) + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| `N` (distinct subterms) | 0 | 142 | 679 | 3011 | 95110 | 322.03 | +| `occ ≥ 2` (R1 only) | 0 | 74 | 435 | 2015 | 81846 | 199.59 | +| candidates (R1+R2: occ ≥ 2, size > 1) | 0 | 66 | 424 | 2004 | 81833 | 192.06 | +| candidates with size > 2 | 0 | 62 | 409 | 1974 | 81779 | 185.34 | +| candidates with size > 3 | 0 | 53 | 382 | 1915 | 81726 | 173.43 | +| current table size | 0 | 55 | 369 | 1874 | 81565 | 172.91 | +| `rawBytes.size` | 9 | 1076 | 4433 | 18368 | 608188 | 2161.73 | +| unshared Constant bytes | 9 | 1285 | 18604 | 675228 | 206476428890489 | 315455655.65 | +| max telescope length | 0 | 8 | 15 | 26 | 112 | 8.61 | +| roots | 0 | 2 | 2 | 2 | 105 | 1.96 | + +### Candidate-count buckets (R1+R2), constants with at least one root (663254), cumulative + +| candidates | constants | share | +|---|---:|---:| +| ≤ 8 | 67177 | 10.1% | +| ≤ 16 | 121321 | 18.3% | +| ≤ 24 | 167737 | 25.3% | +| ≤ 32 | 206933 | 31.2% | +| ≤ 64 | 318883 | 48.1% | +| ≤ 128 | 439602 | 66.3% | +| > 128 | 223652 | 33.7% | + +### Candidates with size > 3, constants with at least one root, cumulative + +| candidates | constants | share | +|---|---:|---:| +| ≤ 8 | 100264 | 15.1% | +| ≤ 16 | 159579 | 24.1% | +| ≤ 24 | 208288 | 31.4% | +| ≤ 32 | 247956 | 37.4% | +| ≤ 64 | 354426 | 53.4% | +| ≤ 128 | 465678 | 70.2% | +| > 128 | 197576 | 29.8% | + +### Ten constants with the most candidates + +| # | constant | kind | `N` | `occ≥2` | candidates | size>2 | size>3 | table | stored B | unshared B | max telescope | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| 1 | `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` | defn | 95110 | 81846 | 81833 | 81779 | 81726 | 81565 | 608188 | 1406312108 | 14 | +| 2 | `_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.«0».RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1` | defn | 70414 | 61651 | 61641 | 61512 | 61497 | 61496 | 447246 | 87682564 | 27 | +| 3 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` | defn | 78913 | 59211 | 59202 | 59037 | 58936 | 58798 | 471381 | 41940708 | 25 | +| 4 | `AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective` | defn | 66025 | 52077 | 52066 | 51977 | 51873 | 51767 | 398085 | 82279088 | 21 | +| 5 | `AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq` | defn | 53511 | 44642 | 44632 | 44569 | 44517 | 44492 | 336490 | 5917704097 | 23 | +| 6 | `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux` | defn | 64047 | 41883 | 41872 | 41767 | 41664 | 41529 | 350617 | 80464470 | 23 | +| 7 | `CategoryTheory.Limits.colimitLimitToLimitColimit_surjective` | defn | 43441 | 38801 | 38789 | 38728 | 38645 | 38598 | 269209 | 7349541595358 | 14 | +| 8 | `_private.Mathlib.RingTheory.Etale.QuasiFinite.«0».Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq'` | defn | 53222 | 38494 | 38483 | 38369 | 38302 | 38220 | 307182 | 61675147 | 42 | +| 9 | `WeierstrassCurve.addSubMapCoeff_condition` | defn | 42875 | 35713 | 35702 | 35640 | 35564 | 35499 | 272192 | 73921037 | 10 | +| 10 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_decl_eq._mutual` | defn | 44737 | 35240 | 35231 | 35079 | 34981 | 34940 | 270991 | 27374524 | 24 | + +### Totals by ConstantInfo kind + +| kind | constants | `rawBytes.size` | unshared bytes | stored/unshared | table entries | candidates | stored > unshared | +|---|---:|---:|---:|---:|---:|---:|---:| +| defn | 650712 | 1457076542 | 214351766595551 | 0.0% | 116718903 | 129616997 | 19579 | +| recr | 6007 | 5897999 | 22276690 | 26.5% | 528580 | 596911 | 571 | +| axio | 13 | 784 | 787 | 99.6% | 9 | 9 | 1 | +| quot | 4 | 311 | 312 | 99.7% | 1 | 1 | 0 | +| muts | 6518 | 5305720 | 13078699 | 40.6% | 241564 | 288810 | 86 | +| iPrj | 6093 | 225441 | 225441 | 100.0% | 0 | 0 | 0 | +| cPrj | 8481 | 322278 | 322278 | 100.0% | 0 | 0 | 0 | +| rPrj | 209 | 7733 | 7733 | 100.0% | 0 | 0 | 0 | +| dPrj | 1462 | 54094 | 54094 | 100.0% | 0 | 0 | 0 | +| **all** | 679499 | 1468890902 | 214351802561585 | 0.0% | 117489057 | 130502728 | 20237 | + +### Longest telescopes + +- App spine: 106 (`Lean.Meta.Grind.Arith.Cutsat.EqCnstr._sizeOf_6`) +- Lam telescope: 112 (`Ix.54eed55de1373a2e13e71412efee3d619b0412a27feb0098a1d4caaabc828770.Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.rec`) +- All telescope: 106 (`Ix.54eed55de1373a2e13e71412efee3d619b0412a27feb0098a1d4caaabc828770.Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.rec`) + +### Slowest constants in this harness (all steps above, per constant) + +| constant | kind | ms | `N` | stored B | +|---|---|---:|---:|---:| +| `_private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.«0».WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three` | defn | 2711 | 50027 | 264421 | +| `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` | defn | 2375 | 78913 | 471381 | +| `Algebra.FormallySmooth.of_surjective_of_ker_eq_map_of_flat` | defn | 2274 | 23888 | 141541 | +| `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` | defn | 2144 | 95110 | 608188 | +| `AlgebraicGeometry.Scheme.exists_π_app_comp_eq_of_locallyOfFinitePresentation` | defn | 2127 | 37207 | 227587 | + +## Maximal structural sharing (MSS) + +Rule: store exactly the subterms with compact-DAG indegree `deg ≥ 2` (edges with multiplicity plus root occurrences) and unshared size > 1; every occurrence of a stored term is a Share; order by priority topological order (largest `deg`, then smaller blake3 hash bytes). Built with `Ix.Sharing.buildSharingEntries`/`rewriteExprs`, placed with the production root cursor helpers, serialized with `serConstant`. + +### Witnesses from the plan (§2) + +| fixture | unshared B | heuristic B | MSS B | expected MSS | MSS decode/expand check | MSS bytes | heuristic bytes | +|---|---:|---:|---:|---|---|---|---| +| `T2 → T2` | 20 | 19 | 17 | 17 (plan: exact minimum `d200009117b0b001921700170000000100`) | ok | `d200009117b0b001921700170000000100` | `d200009117b1b10291170000911700b0000100` | +| `T16 → T16` | 78 | 81 | 46 | 46 (plan: feasible improvement) | ok | `d200009117b0b0019810170017001700170017001700170017001700170017001700170017001700170000000100` | `d200009117b80eb80e0f921700170000911700b0911700b1911700b2911700b3911700b4911700b5911700b6911700b7911700b808911700b809911700b80a911700b80b911700b80c911700b80d000100` | +| `A → A → B → B`, `A = Prop → Prop`, `B = Prop → Type` | 28 | 25 | 25 | 25 (plan: minimum, two tied orders) | ok | `d200009317b117b117b0b00291170001911700000002000100` | `d200009317b117b117b0b00291170001911700000002000100` | + +Negative controls for the MSS decode/expand/equality check: + +- `T2 → T2` MSS bytes vs roots `T2 → T2'` (one leaf `Sort 0` replaced by `Sort 1`): behaves as expected +- `T2 → T2` MSS bytes vs roots `T16 → T16`: behaves as expected +- `T2 → T2` MSS bytes vs its own roots (must be accepted): behaves as expected + +### Corpus verification + +- MSS built for 679499 constants; decode, re-encode (byte-identical), table expansion and exact pointer-memoized structural equality of the expanded roots with the original expanded roots: 679499 ok, **0** failed. + +### Totals over the 663254 constants with at least one root + +| encoding | total bytes | vs heuristic | +|---|---:|---:| +| heuristic (stored `rawBytes`) | 1468281356 | | +| MSS | 1148195956 | -320085400 (−21.8%) | +| unshared | 214351801952039 | 214350333670683 | + +### MSS − heuristic per constant + +| outcome | constants | share | bytes | +|---|---:|---:|---:| +| MSS smaller | 625250 | 94.3% | −320096419 | +| equal | 35859 | 5.4% | 0 | +| MSS larger | 2145 | 0.3% | +11019 | + +- Losses (MSS − heuristic) over the 2145 larger constants: p50 3, p90 10, p99 33, max 112, mean 5.14. +- Savings (heuristic − MSS) over the 625250 smaller constants: p50 132, p90 1080, p99 6352, max 258759, mean 511.95. +- Signed Δ = MSS − heuristic over all 663254 rooted constants: min -258759, p1 -6139, p10 -1006, p50 -117, p90 -4, p99 0, max 112. +- MSS larger than unshared: 26 constants, total excess 188 bytes, max 38. (Heuristic larger than unshared: 20237.) + +### Table sizes (rooted constants) + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| MSS table size | 0 | 20 | 122 | 541 | 21461 | 54.57 | +| heuristic table size | 0 | 58 | 376 | 1901 | 81565 | 177.14 | +| MSS continuation-only entries | 0 | 1 | 23 | 143 | 7348 | 10.28 | +| … with MSS entry payload ≤ 2 | 0 | 0 | 0 | 4 | 32 | 0.20 | +| … with unshared payload ≤ 2 | 0 | 0 | 0 | 0 | 10 | 0.01 | + +- Total MSS entries 36191166; heuristic entries 117489057. +- Continuation-only entries (never a root; every occurrence is the function child of an App for an App term, or the body of a Lam/All for a Lam/All term): 6817060 in total; with MSS entry payload ≤ 2: 132031; with unshared payload ≤ 2: 5144. +- Constants with at least one continuation-only entry of MSS payload ≤ 2: 64527; of these, MSS larger than heuristic: 191, equal: 160, smaller: 64176. +- Of the 2145 constants where MSS is larger, 191 have such an entry; of the 625250 where MSS is smaller, 64176. + +### MSS by ConstantInfo kind (rooted constants) + +| kind | constants | heuristic B | MSS B | unshared B | MSS/heuristic | MSS smaller | equal | MSS larger | +|---|---:|---:|---:|---:|---:|---:|---:|---:| +| defn | 650712 | 1457076542 | 1138945739 | 214351766595551 | 78.2% | 614858 | 33769 | 2085 | +| recr | 6007 | 5897999 | 4522578 | 22276690 | 76.7% | 5989 | 6 | 12 | +| axio | 13 | 784 | 779 | 787 | 99.4% | 3 | 10 | 0 | +| quot | 4 | 311 | 311 | 312 | 100.0% | 0 | 4 | 0 | +| muts | 6518 | 5305720 | 4726549 | 13078699 | 89.1% | 4400 | 2070 | 48 | + +### Ten largest MSS losses (MSS − heuristic) + +| # | constant | kind | heuristic B | MSS B | Δ | unshared B | heuristic table | MSS table | cont. p≤2 | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `Std.Http.Status.casesOn` | defn | 3005 | 3117 | 112 | 3079 | 61 | 125 | 0 | +| 2 | `Std.Http.Status.rec` | recr | 14932 | 15042 | 110 | 27670 | 67 | 122 | 0 | +| 3 | `Std.Http.Status.recOn` | defn | 2999 | 3109 | 110 | 3073 | 61 | 124 | 0 | +| 4 | `Std.Http.Status.toCode` | defn | 2999 | 3104 | 105 | 3368 | 6 | 61 | 0 | +| 5 | `Std.Http.Status.ctorElim` | defn | 5689 | 5792 | 103 | 6935 | 18 | 75 | 2 | +| 6 | `Std.Http.Method.rec` | recr | 6437 | 6503 | 66 | 11283 | 41 | 74 | 0 | +| 7 | `Std.Http.Method.recOn` | defn | 1879 | 1943 | 64 | 1925 | 36 | 76 | 0 | +| 8 | `Lean.Lsp.instToJsonSymbolKind` | defn | 1408 | 1465 | 57 | 1555 | 6 | 25 | 0 | +| 9 | `_private.Mathlib.Tactic.Linter.DirectoryDependency.«0».Mathlib.Linter.DirectoryDependency.allowedImportDirs` | defn | 3996 | 4048 | 52 | 6356 | 75 | 78 | 0 | +| 10 | `Std.Packages.LinearPreorderOfOrdArgs.noConfusionType` | defn | 2469 | 2519 | 50 | 2836 | 57 | 95 | 0 | + +### Ten largest MSS wins (heuristic − MSS) + +| # | constant | kind | heuristic B | MSS B | Δ | unshared B | heuristic table | MSS table | cont. p≤2 | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` | defn | 608188 | 349429 | -258759 | 1406312108 | 81565 | 21461 | 0 | +| 2 | `_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.«0».RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1` | defn | 447246 | 273355 | -173891 | 87682564 | 61496 | 11700 | 0 | +| 3 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` | defn | 471381 | 298739 | -172642 | 41940708 | 58798 | 13054 | 0 | +| 4 | `AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective` | defn | 398085 | 239810 | -158275 | 82279088 | 51767 | 10555 | 0 | +| 5 | `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux` | defn | 350617 | 213303 | -137314 | 80464470 | 41529 | 8745 | 0 | +| 6 | `AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq` | defn | 336490 | 206097 | -130393 | 5917704097 | 44492 | 12056 | 0 | +| 7 | `_private.Mathlib.RingTheory.Etale.QuasiFinite.«0».Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq'` | defn | 307182 | 179803 | -127379 | 61675147 | 38220 | 7317 | 0 | +| 8 | `CategoryTheory.Limits.colimitLimitToLimitColimit_surjective` | defn | 269209 | 153471 | -115738 | 7349541595358 | 38598 | 8957 | 2 | +| 9 | `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq` | defn | 249369 | 141129 | -108240 | 5810447 | 31536 | 5768 | 0 | +| 10 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_decl_eq._mutual` | defn | 270991 | 168437 | -102554 | 27374524 | 34940 | 6866 | 0 | + +## Uniform-reference-width classification + +Candidates are the subterms with compact `deg ≥ 2` and unshared size > 1 (the MSS stored set). For `w ∈ {1, 2, 3}` each candidate is CERTAIN-STORED if `g(deg, headdeg, payloadMin) > 0`, CERTAIN-EXCLUDED if `g(occ, occ, payloadMax) < 0` or it is a leaf with `(occ−1)·size < occ·w`, and UNCERTAIN otherwise, where `g(n, H, b) = (n−1)·b + (H−1)·hdr − n·w`. `payloadMin` is the width-aware recursive lower bound (a candidate child costs at most `w`, a non-candidate child its own recursive minimum; continuation children without their header). `headdeg` treats only an App in App-function position and a Lam/All in same-kind body position as continuations. Uncertain nodes are in one component when a directed DAG path whose intermediate nodes are not certain-stored joins them (transitively). Arithmetic is exact; `occ` is not capped. + +- Classification errors: 0. +- Witnesses (cs/ce/unc/largest component for w = 1 | 2 | 3): + - `T2 → T2`: 1/0/0/0 | 1/0/0/0 | 0/0/1/1 (candidates 1) + - `T16 → T16`: 1/0/0/0 | 1/0/0/0 | 1/0/0/0 (candidates 1) + - `A → A → B → B`: 2/0/0/0 | 0/0/2/1 | 0/2/0/0 (candidates 2) +- Candidates over the 663254 rooted constants: 36191166 (MSS table entries: 36191166). + +### w = 1 + +- Totals: certain-stored 31975849 (88.4% of candidates), certain-excluded 0 (0.0%), uncertain 4215317 (11.6%); nodes meeting both certain conditions 0; candidates with `payloadMin > payloadMax` 0; candidates whose class changes when every function-child occurrence counts as a non-head 1511. +- Largest component recomputed by the literal brute force (DAGs with ≤ 1000 nodes): 623572 equal, **0** different, 39682 not checked. + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| certain-stored | 0 | 18 | 108 | 466 | 17981 | 48.21 | +| certain-excluded | 0 | 0 | 0 | 0 | 0 | 0.00 | +| uncertain | 0 | 1 | 15 | 82 | 3480 | 6.36 | +| largest uncertain component | 0 | 1 | 2 | 4 | 45 | 0.84 | + +| bucket | constants by `uncertain` | share | constants by largest component | share | +|---|---:|---:|---:|---:| +| = 0 | 261942 | 39.5% | 261942 | 39.5% | +| ≤ 8 | 556250 | 83.9% | 662872 | 99.9% | +| ≤ 16 | 605069 | 91.2% | 663190 | 100.0% | +| ≤ 32 | 637224 | 96.1% | 663250 | 100.0% | +| > 32 | 26030 | 3.9% | 4 | 0.0% | +| > 128 | 3053 | 0.5% | 0 | 0.0% | +| > 1024 | 38 | 0.0% | 0 | 0.0% | + +Ten constants with the largest uncertain component (w = 1): + +| # | constant | kind | `N` | candidates | certain-stored | certain-excluded | uncertain | largest component | +|---:|---|---|---:|---:|---:|---:|---:|---:| +| 1 | `Lean.Grind.Config.mk.injEq` | defn | 3512 | 360 | 236 | 0 | 124 | 45 | +| 2 | `Lean.Meta.Grind.Arith.Linear.Struct.mk.injEq` | defn | 3259 | 359 | 239 | 0 | 120 | 42 | +| 3 | `_private.Std.Time.Format.Basic.«0».Std.Time.GenericFormat.DateBuilder.mk.injEq` | defn | 2657 | 331 | 217 | 0 | 114 | 36 | +| 4 | `_private.Init.Data.String.Decode.«0».UInt8.utf8ByteSize_eq_utf8ByteSize_parseFirstByte` | defn | 1056 | 296 | 192 | 0 | 104 | 35 | +| 5 | `Lean.Meta.Simp.Config.mk.injEq` | defn | 1994 | 256 | 164 | 0 | 92 | 31 | +| 6 | `_private.Lean.Meta.Tactic.Grind.EMatch.«0».Lean.Meta.Grind.EMatch.processUnassigned.congr_simp` | defn | 1293 | 144 | 88 | 0 | 56 | 29 | +| 7 | `CategoryTheory.Bicategory.rightZigzag_idempotent_of_left_triangle` | defn | 9677 | 1897 | 1303 | 0 | 594 | 28 | +| 8 | `_private.Std.Time.Format.Basic.«0».Std.Time.GenericFormat.DateBuilder.insert` | defn | 1250 | 151 | 73 | 0 | 78 | 27 | +| 9 | `CategoryTheory.Bicategory.Adjunction.comp_right_triangle_aux` | defn | 11168 | 2145 | 1491 | 0 | 654 | 26 | +| 10 | `Lean.Meta.Grind.Arith.Cutsat.State.mk.injEq` | defn | 1648 | 237 | 163 | 0 | 74 | 25 | + +### w = 2 + +- Totals: certain-stored 25708230 (71.0% of candidates), certain-excluded 3712253 (10.3%), uncertain 6770683 (18.7%); nodes meeting both certain conditions 0; candidates with `payloadMin > payloadMax` 0; candidates whose class changes when every function-child occurrence counts as a non-head 2371. +- Largest component recomputed by the literal brute force (DAGs with ≤ 1000 nodes): 623572 equal, **0** different, 39682 not checked. + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| certain-stored | 0 | 12 | 86 | 430 | 18738 | 38.76 | +| certain-excluded | 0 | 3 | 15 | 41 | 279 | 5.60 | +| uncertain | 0 | 4 | 24 | 90 | 2670 | 10.21 | +| largest uncertain component | 0 | 1 | 3 | 5 | 44 | 1.38 | + +| bucket | constants by `uncertain` | share | constants by largest component | share | +|---|---:|---:|---:|---:| +| = 0 | 122093 | 18.4% | 122093 | 18.4% | +| ≤ 8 | 450454 | 67.9% | 662851 | 99.9% | +| ≤ 16 | 551626 | 83.2% | 663228 | 100.0% | +| ≤ 32 | 620707 | 93.6% | 663251 | 100.0% | +| > 32 | 42547 | 6.4% | 3 | 0.0% | +| > 128 | 3074 | 0.5% | 0 | 0.0% | +| > 1024 | 20 | 0.0% | 0 | 0.0% | + +Ten constants with the largest uncertain component (w = 2): + +| # | constant | kind | `N` | candidates | certain-stored | certain-excluded | uncertain | largest component | +|---:|---|---|---:|---:|---:|---:|---:|---:| +| 1 | `Lean.Grind.Config.mk.injEq` | defn | 3512 | 360 | 148 | 91 | 121 | 44 | +| 2 | `Lean.Meta.Grind.Arith.Linear.Struct.mk.injEq` | defn | 3259 | 359 | 155 | 88 | 116 | 41 | +| 3 | `_private.Std.Time.Format.Basic.«0».Std.Time.GenericFormat.DateBuilder.mk.injEq` | defn | 2657 | 331 | 153 | 78 | 100 | 35 | +| 4 | `Lean.Meta.Simp.Config.mk.injEq` | defn | 1994 | 256 | 103 | 64 | 89 | 30 | +| 5 | `_private.Std.Time.Format.Basic.«0».Std.Time.GenericFormat.DateBuilder.insert` | defn | 1250 | 151 | 60 | 59 | 32 | 28 | +| 6 | `CategoryTheory.Bicategory.rightZigzag_idempotent_of_left_triangle` | defn | 9677 | 1897 | 1432 | 2 | 463 | 26 | +| 7 | `Lean.Meta.Grind.Arith.Cutsat.State.mk.injEq` | defn | 1648 | 237 | 112 | 56 | 69 | 24 | +| 8 | `Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.mk.injEq` | defn | 1500 | 210 | 92 | 53 | 65 | 24 | +| 9 | `Std.Http.Config.mk.injEq` | defn | 1501 | 208 | 88 | 52 | 68 | 24 | +| 10 | `PEquiv.toMatrix_swap` | defn | 6523 | 1782 | 1160 | 16 | 606 | 23 | + +### w = 3 + +- Totals: certain-stored 20941150 (57.9% of candidates), certain-excluded 8690905 (24.0%), uncertain 6559111 (18.1%); nodes meeting both certain conditions 0; candidates with `payloadMin > payloadMax` 0; candidates whose class changes when every function-child occurrence counts as a non-head 4068. +- Largest component recomputed by the literal brute force (DAGs with ≤ 1000 nodes): 623572 equal, **0** different, 39682 not checked. + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| certain-stored | 0 | 8 | 69 | 378 | 18281 | 31.57 | +| certain-excluded | 0 | 7 | 32 | 79 | 799 | 13.10 | +| uncertain | 0 | 3 | 24 | 102 | 3077 | 9.89 | +| largest uncertain component | 0 | 1 | 3 | 5 | 44 | 1.32 | + +| bucket | constants by `uncertain` | share | constants by largest component | share | +|---|---:|---:|---:|---:| +| = 0 | 140469 | 21.2% | 140469 | 21.2% | +| ≤ 8 | 478592 | 72.2% | 662118 | 99.8% | +| ≤ 16 | 562292 | 84.8% | 663194 | 100.0% | +| ≤ 32 | 620176 | 93.5% | 663251 | 100.0% | +| > 32 | 43078 | 6.5% | 3 | 0.0% | +| > 128 | 4257 | 0.6% | 0 | 0.0% | +| > 1024 | 35 | 0.0% | 0 | 0.0% | + +Ten constants with the largest uncertain component (w = 3): + +| # | constant | kind | `N` | candidates | certain-stored | certain-excluded | uncertain | largest component | +|---:|---|---|---:|---:|---:|---:|---:|---:| +| 1 | `Lean.Grind.Config.mk.injEq` | defn | 3512 | 360 | 145 | 92 | 123 | 44 | +| 2 | `Lean.Meta.Grind.Arith.Linear.Struct.mk.injEq` | defn | 3259 | 359 | 151 | 91 | 117 | 41 | +| 3 | `_private.Std.Time.Format.Basic.«0».Std.Time.GenericFormat.DateBuilder.mk.injEq` | defn | 2657 | 331 | 150 | 80 | 101 | 35 | +| 4 | `_private.Init.Data.String.Decode.«0».UInt8.utf8ByteSize_eq_utf8ByteSize_parseFirstByte` | defn | 1056 | 296 | 154 | 42 | 100 | 31 | +| 5 | `_private.Std.Time.Format.Basic.«0».Std.Time.GenericFormat.DateBuilder.insert` | defn | 1250 | 151 | 48 | 61 | 42 | 31 | +| 6 | `Lean.Meta.Simp.Config.mk.injEq` | defn | 1994 | 256 | 100 | 65 | 91 | 30 | +| 7 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_decl_eq._mutual` | defn | 44737 | 6866 | 5487 | 165 | 1214 | 28 | +| 8 | `Batteries.UnionFind.link._proof_6` | defn | 2188 | 595 | 333 | 54 | 208 | 26 | +| 9 | `CategoryTheory.Bicategory.rightZigzag_idempotent_of_left_triangle` | defn | 9677 | 1897 | 1389 | 8 | 500 | 26 | +| 10 | `CategoryTheory.Bicategory.Adjunction.comp_left_triangle_aux` | defn | 11254 | 2168 | 1565 | 10 | 593 | 25 | + +### Reference-width loss in the current stored encoding + +Share references counted syntactically in the stored roots and stored table entries of every constant (current heuristic encoding). The largest stored table has 81565 entries, so every index ≥ 256 is 3 bytes. + +| stored table entries | constants | refs to 0–7 (1 B) | refs to 8–255 (2 B) | refs to ≥ 256 (3 B) | loss under the uniform width | +|---|---:|---:|---:|---:|---| +| 1–8 | 77332 | 834671 | 0 | 0 | (not requested; 834671 if these cost 2 B) | +| 9–255 | 456938 | 8413579 | 46923657 | 0 | w = 2: **8413579** bytes | +| > 255 | 111351 | 4535443 | 55312965 | 81989876 | w = 3: 2·4535443 + 55312965 = **64383851** bytes | + +- Total stored bytes over all constants: 1468890902; total Share references: 198010191. + +## Share-width schemes on the MSS encoding + +Every occurrence of an MSS entry is a Share. Scheme A: the current tiers by index in MSS order (1 byte below index 8, 2 below 256, 3 below 65536). Scheme B: one width per constant, 2 bytes if the MSS entry count (= candidate count) is ≤ 2048, else 3. Scheme C: as B, but 1 byte if the count is ≤ 8. Scheme D: one width per constant using the tag byte's whole low nibble: 1 byte if the count is ≤ 16, 2 if ≤ 4096, else 3. Scheme E: position tiers with a nibble escape, by index in MSS order: 1 byte below index 15, 2 below 15 + 4096, else 3 (as specified; not realizable with a 4-bit Share flag). Scheme F: realizable position tiers with two marker bits: 1 byte below index 8, 2 below 8 + 1024, else 3. Scheme G: realizable position tiers with nibble values 14 and 15 as escapes: 1 byte below index 14, 2 below 14 + 256, else 3. Constant bytes under a scheme are MSS bytes − refbytes(A) + refbytes(scheme). Share nodes are counted on the materialized MSS encoding. + +- Share nodes in the MSS encoding vs `Σ deg` over MSS entries: 663254 equal, **0** different. +- Share nodes counted in the scheme-F and scheme-G index buckets vs the scheme-A buckets: 663254 equal totals, **0** different. +- Share nodes counted in the scheme-E index buckets vs the scheme-A buckets: 663254 equal totals, **0** different. +- Rooted constants: 663254; Share references in their MSS encodings: 159110515; constants with more than 2048 MSS entries (width 3 under B and C): 342; with at most 8 entries (width 1 under C): 181437. + +| scheme | reference bytes | MSS constant bytes | Δ vs A | Δ / MSS total (A) | Δ / heuristic total | +|---|---:|---:|---:|---:|---:| +| A (index tiers) | 298286517 | 1148195956 | 0 | +0.00% | +0.00% | +| B (2 or 3 per constant) | 325217289 | 1175126728 | 26930772 | +2.35% | +1.83% | +| C (1, 2 or 3 per constant) | 323081186 | 1172990625 | 24794669 | +2.16% | +1.69% | +| D (nibble: ≤ 16 / ≤ 4096 / more) | 314797020 | 1164706459 | 16510503 | +1.44% | +1.12% | +| E (index tiers < 15 / < 4111 / more) | 260743267 | 1110652706 | -37543250 | −3.27% | −2.56% | +| F (index tiers < 8 / < 1032 / more) | 280471878 | 1130381317 | -17814639 | −1.55% | −1.21% | +| G (index tiers < 14 / < 270 / more) | 283411489 | 1133320928 | -14875028 | −1.30% | −1.01% | + +Totals for reference: MSS bytes (scheme A, the real encoding) 1148195956; heuristic stored bytes 1468281356. + +| comparison | better (fewer bytes) | equal | worse | +|---|---:|---:|---:| +| B vs A | 12165 | 4900 | 646189 | +| C vs A | 12165 | 181451 | 469638 | +| D vs A | 127316 | 181451 | 354487 | +| E vs A | 481817 | 181437 | 0 | +| F vs A | 23301 | 639953 | 0 | +| G vs A | 481817 | 181437 | 0 | + +Width classes under D: 1 byte (≤ 16 entries) 296310 constants, 2 bytes (17–4096) 366880, 3 bytes (> 4096) 64. + +### Ten largest losses under B (B − A) + +| # | constant | kind | MSS entries | Share refs | refs < 8 / 8–255 / ≥ 256 | A ref bytes | B ref bytes | Δ (B − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux` | defn | 8745 | 68717 | 4149 / 24670 / 39898 | 173183 | 206151 | 32968 | 213303 | +| 2 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` | defn | 13054 | 80694 | 5330 / 22234 / 53130 | 209188 | 242082 | 32894 | 298739 | +| 3 | `_private.Mathlib.RingTheory.Etale.QuasiFinite.«0».Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq'` | defn | 7317 | 57191 | 4182 / 21260 / 31749 | 141949 | 171573 | 29624 | 179803 | +| 4 | `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` | defn | 21461 | 107147 | 3579 / 21725 / 81843 | 292558 | 321441 | 28883 | 349429 | +| 5 | `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq` | defn | 5768 | 47121 | 2777 / 20109 / 24235 | 115700 | 141363 | 25663 | 141129 | +| 6 | `AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective` | defn | 10555 | 72590 | 3442 / 16268 / 52880 | 194618 | 217770 | 23152 | 239810 | +| 7 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_decl_eq._mutual` | defn | 6866 | 45784 | 3225 / 15909 / 26650 | 114993 | 137352 | 22359 | 168437 | +| 8 | `sum_eight_sq_mul_sum_eight_sq` | defn | 7281 | 55565 | 2359 / 16346 / 36860 | 145631 | 166695 | 21064 | 167951 | +| 9 | `AlgebraicGeometry.exists_appTop_π_eq_of_isLimit` | defn | 9848 | 50271 | 3841 / 13063 / 33367 | 130068 | 150813 | 20745 | 168683 | +| 10 | `CategoryTheory.Limits.colimitLimitToLimitColimit_surjective` | defn | 8957 | 45764 | 4469 / 11700 / 29595 | 116654 | 137292 | 20638 | 153471 | + +### Ten largest gains under B (A − B) + +| # | constant | kind | MSS entries | Share refs | refs < 8 / 8–255 / ≥ 256 | A ref bytes | B ref bytes | Δ (B − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `WeierstrassCurve.twoTorsionPolynomial_discr` | defn | 1857 | 12676 | 409 / 2416 / 9851 | 34794 | 25352 | -9442 | 45260 | +| 2 | `WeierstrassCurve.Jacobian.addX_eq'` | defn | 1824 | 11970 | 256 / 2304 / 9410 | 33094 | 23940 | -9154 | 42502 | +| 3 | `Real.Wallis.W_eq_factorial_ratio` | defn | 1934 | 12333 | 543 / 2227 / 9563 | 33686 | 24666 | -9020 | 48150 | +| 4 | `CategoryTheory.Bicategory.rightZigzag_idempotent_of_left_triangle` | defn | 1897 | 10236 | 145 / 1104 / 8987 | 29314 | 20472 | -8842 | 36578 | +| 5 | `CartanMatrix.E₈_off_diag_nonpos` | defn | 1672 | 14559 | 845 / 4260 / 9454 | 37727 | 29118 | -8609 | 53536 | +| 6 | `CategoryTheory.ExactPairing.tensor._proof_1` | defn | 2011 | 12191 | 605 / 2465 / 9121 | 32898 | 24382 | -8516 | 40062 | +| 7 | `_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.«0».WeierstrassCurve.expCoeff_rec` | defn | 2038 | 13602 | 1231 / 2875 / 9496 | 35469 | 27204 | -8265 | 48306 | +| 8 | `WeierstrassCurve.Affine.cyclic_sum_Y_mul_X_sub_X` | defn | 1742 | 10924 | 591 / 2101 / 8232 | 29489 | 21848 | -7641 | 40804 | +| 9 | `WeierstrassCurve.Projective.negAddY_smul` | defn | 1859 | 11980 | 226 / 3908 / 7846 | 31580 | 23960 | -7620 | 40125 | +| 10 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_reverse._proof_1` | defn | 1908 | 10516 | 314 / 2309 / 7893 | 28611 | 21032 | -7579 | 36602 | + +### B − A restricted to constants whose current heuristic table exceeds 255 entries + +- Constants: 111351; their MSS bytes 599562304, heuristic bytes 846898448; MSS entries: min 14, max 21461; with more than 2048 MSS entries: 342. +- Reference bytes: A 233802244, B 242448355; Δ (B − A) 8646111 (+1.44% of their MSS bytes, +1.02% of their heuristic bytes). +- B vs A: better 12165, equal 14, worse 99172. + +### Ten largest losses under D (D − A) + +| # | constant | kind | MSS entries | Share refs | refs < 8 / 8–255 / ≥ 256 | A ref bytes | D ref bytes | Δ (D − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux` | defn | 8745 | 68717 | 4149 / 24670 / 39898 | 173183 | 206151 | 32968 | 213303 | +| 2 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` | defn | 13054 | 80694 | 5330 / 22234 / 53130 | 209188 | 242082 | 32894 | 298739 | +| 3 | `_private.Mathlib.RingTheory.Etale.QuasiFinite.«0».Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq'` | defn | 7317 | 57191 | 4182 / 21260 / 31749 | 141949 | 171573 | 29624 | 179803 | +| 4 | `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` | defn | 21461 | 107147 | 3579 / 21725 / 81843 | 292558 | 321441 | 28883 | 349429 | +| 5 | `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq` | defn | 5768 | 47121 | 2777 / 20109 / 24235 | 115700 | 141363 | 25663 | 141129 | +| 6 | `AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective` | defn | 10555 | 72590 | 3442 / 16268 / 52880 | 194618 | 217770 | 23152 | 239810 | +| 7 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_decl_eq._mutual` | defn | 6866 | 45784 | 3225 / 15909 / 26650 | 114993 | 137352 | 22359 | 168437 | +| 8 | `sum_eight_sq_mul_sum_eight_sq` | defn | 7281 | 55565 | 2359 / 16346 / 36860 | 145631 | 166695 | 21064 | 167951 | +| 9 | `AlgebraicGeometry.exists_appTop_π_eq_of_isLimit` | defn | 9848 | 50271 | 3841 / 13063 / 33367 | 130068 | 150813 | 20745 | 168683 | +| 10 | `CategoryTheory.Limits.colimitLimitToLimitColimit_surjective` | defn | 8957 | 45764 | 4469 / 11700 / 29595 | 116654 | 137292 | 20638 | 153471 | + +### Ten largest gains under D (A − D) + +| # | constant | kind | MSS entries | Share refs | refs < 8 / 8–255 / ≥ 256 | A ref bytes | D ref bytes | Δ (D − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `WeierstrassCurve.ofJNe0Or1728_Δ` | defn | 3543 | 28414 | 1162 / 2817 / 24435 | 80101 | 56828 | -23273 | 108259 | +| 2 | `ModularForm.discriminant_T_invariant` | defn | 4011 | 28243 | 746 / 3973 / 23524 | 79264 | 56486 | -22778 | 104503 | +| 3 | `_private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1` | defn | 3640 | 22811 | 497 / 4776 / 17538 | 62663 | 45622 | -17041 | 76309 | +| 4 | `WeierstrassCurve.variableChange_b₈` | defn | 3306 | 25347 | 408 / 7876 / 17063 | 67349 | 50694 | -16655 | 80704 | +| 5 | `WeierstrassCurve.Affine.CoordinateRing.XYIdeal_neg_mul` | defn | 3694 | 20163 | 641 / 2722 / 16800 | 56485 | 40326 | -16159 | 75612 | +| 6 | `WeierstrassCurve.Jacobian.negAddY_neg` | defn | 3109 | 21886 | 525 / 4921 / 16440 | 59687 | 43772 | -15915 | 72842 | +| 7 | `Cubic.discr_eq_prod_three_roots` | defn | 3009 | 20253 | 530 / 3412 / 16311 | 56287 | 40506 | -15781 | 70534 | +| 8 | `_private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1` | defn | 3236 | 21512 | 1001 / 4190 / 16321 | 58344 | 43024 | -15320 | 72208 | +| 9 | `Real.log_five_near_10` | defn | 3523 | 25534 | 2316 / 5909 / 17309 | 66061 | 51068 | -14993 | 122313 | +| 10 | `_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.«0».PeriodPair.analyticAt_relation_zero` | defn | 3721 | 20483 | 1194 / 3288 / 16001 | 55773 | 40966 | -14807 | 80992 | + +### Ten largest losses under E (E − A) + +| # | constant | kind | MSS entries | Share refs | refs < 15 / 15–4110 / ≥ 4111 | A ref bytes | E ref bytes | Δ (E − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `ADEInequality.A` | defn | 1 | 4 | 4 / 0 / 0 | 4 | 4 | 0 | 260 | +| 2 | `ADEInequality.A'` | defn | 3 | 15 | 15 / 0 / 0 | 15 | 15 | 0 | 387 | +| 3 | `ADEInequality.A'.eq_1` | defn | 4 | 18 | 18 / 0 / 0 | 18 | 18 | 0 | 501 | +| 4 | `ADEInequality.D'` | defn | 3 | 13 | 13 / 0 / 0 | 13 | 13 | 0 | 382 | +| 5 | `ADEInequality.D'.eq_1` | defn | 4 | 16 | 16 / 0 / 0 | 16 | 16 | 0 | 495 | +| 6 | `ADEInequality.E'` | defn | 6 | 19 | 19 / 0 / 0 | 19 | 19 | 0 | 459 | +| 7 | `ADEInequality.E'.eq_1` | defn | 7 | 22 | 22 / 0 / 0 | 22 | 22 | 0 | 572 | +| 8 | `ADEInequality.E6` | defn | 1 | 2 | 2 / 0 / 0 | 2 | 2 | 0 | 253 | +| 9 | `ADEInequality.E7` | defn | 1 | 2 | 2 / 0 / 0 | 2 | 2 | 0 | 253 | +| 10 | `ADEInequality.E8` | defn | 1 | 2 | 2 / 0 / 0 | 2 | 2 | 0 | 253 | + +### Ten largest gains under E (A − E) + +| # | constant | kind | MSS entries | Share refs | refs < 15 / 15–4110 / ≥ 4111 | A ref bytes | E ref bytes | Δ (E − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `WeierstrassCurve.variableChange_Δ` | defn | 9233 | 72021 | 1295 / 49848 / 20878 | 209949 | 163625 | -46324 | 239709 | +| 2 | `WeierstrassCurve.Projective.negDblY_eq'` | defn | 7073 | 52123 | 992 / 41198 / 9933 | 150943 | 113187 | -37756 | 174025 | +| 3 | `CategoryTheory.Bicategory.mateEquiv_vcomp` | defn | 8940 | 57952 | 3439 / 36485 / 18028 | 163709 | 130493 | -33216 | 185171 | +| 4 | `WeierstrassCurve.isHomogeneous_addSubMapCoeff` | defn | 10150 | 68764 | 2224 / 43483 / 23057 | 190766 | 158361 | -32405 | 230946 | +| 5 | `_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.«0».RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1` | defn | 11700 | 80765 | 2566 / 39116 / 39083 | 228613 | 198047 | -30566 | 273355 | +| 6 | `AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective` | defn | 10555 | 72590 | 5039 / 42663 / 24888 | 194618 | 165029 | -29589 | 239810 | +| 7 | `WeierstrassCurve.Projective.dblX_eq'` | defn | 5478 | 39250 | 766 / 34336 / 4148 | 111434 | 81882 | -29552 | 130353 | +| 8 | `WeierstrassCurve.addSubMapCoeff_condition` | defn | 8048 | 49738 | 1556 / 35793 / 12389 | 139044 | 110309 | -28735 | 169951 | +| 9 | `WeierstrassCurve.c_relation` | defn | 4531 | 34835 | 1078 / 32246 / 1511 | 98375 | 70103 | -28272 | 117505 | +| 10 | `WeierstrassCurve.instMulActionVariableChange._proof_1` | defn | 4831 | 34728 | 638 / 31535 / 2555 | 99272 | 71373 | -27899 | 116499 | + +### Scheme F vs A + +- Constants worse than A under F: **0**; largest per-constant Δ (F − A): 0. + +Ten largest gains under F (A − F): + +| # | constant | kind | MSS entries | Share refs | refs < 8 / 8–1031 / ≥ 1032 | A ref bytes | F ref bytes | Δ (F − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `WeierstrassCurve.variableChange_Δ` | defn | 9233 | 72021 | 938 / 29734 / 41349 | 209949 | 184453 | -25496 | 239709 | +| 2 | `CartanMatrix.E₈_det` | defn | 6878 | 47812 | 1833 / 18142 / 27837 | 136215 | 121628 | -14587 | 160092 | +| 3 | `WeierstrassCurve.Projective.dblX_eq'` | defn | 5478 | 39250 | 539 / 19585 / 19126 | 111434 | 97087 | -14347 | 130353 | +| 4 | `WeierstrassCurve.Projective.negDblY_eq'` | defn | 7073 | 52123 | 695 / 17793 / 33635 | 150943 | 137186 | -13757 | 174025 | +| 5 | `_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.«0».RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1` | defn | 11700 | 80765 | 1849 / 22928 / 55988 | 228613 | 215669 | -12944 | 273355 | +| 6 | `WeierstrassCurve.instMulActionVariableChange._proof_1` | defn | 4831 | 34728 | 451 / 15917 / 18360 | 99272 | 87365 | -11907 | 116499 | +| 7 | `WeierstrassCurve.isHomogeneous_addSubMapCoeff` | defn | 10150 | 68764 | 1300 / 24557 / 42907 | 190766 | 179135 | -11631 | 230946 | +| 8 | `WeierstrassCurve.c_relation` | defn | 4531 | 34835 | 827 / 15583 / 18425 | 98375 | 87268 | -11107 | 117505 | +| 9 | `CartanMatrix.E₇_det` | defn | 4377 | 29903 | 1216 / 13722 / 14965 | 83876 | 73555 | -10321 | 101188 | +| 10 | `Cubic.discr_eq_prod_three_roots` | defn | 3009 | 20253 | 530 / 12466 / 7257 | 56287 | 47233 | -9054 | 70534 | + +### Scheme G vs A + +- Constants worse than A under G: **0**; largest per-constant Δ (G − A): 0. + +Ten largest gains under G (A − G): + +| # | constant | kind | MSS entries | Share refs | refs < 14 / 14–269 / ≥ 270 | A ref bytes | G ref bytes | Δ (G − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `String.firstDiffPos_loop_eq._unary` | defn | 3458 | 22509 | 4968 / 5013 / 12528 | 55587 | 52578 | -3009 | 83347 | +| 2 | `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` | defn | 21461 | 107147 | 5927 / 19688 / 81532 | 292558 | 289899 | -2659 | 349429 | +| 3 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` | defn | 13054 | 80694 | 7357 / 20515 / 52822 | 209188 | 206853 | -2335 | 298739 | +| 4 | `_private.Mathlib.RingTheory.Etale.QuasiFinite.«0».Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq'` | defn | 7317 | 57191 | 6135 / 19677 / 31379 | 141949 | 139626 | -2323 | 179803 | +| 5 | `AlgebraicGeometry.exists_appTop_π_eq_of_isLimit` | defn | 9848 | 50271 | 6047 / 10955 / 33269 | 130068 | 127764 | -2304 | 168683 | +| 6 | `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux` | defn | 8745 | 68717 | 5925 / 23341 / 39451 | 173183 | 170960 | -2223 | 213303 | +| 7 | `Function.Exact.splitSurjectiveEquiv._proof_12` | defn | 3012 | 21723 | 5648 / 7003 / 9072 | 49064 | 46870 | -2194 | 63079 | +| 8 | `Coalgebra.TensorProduct.assoc._proof_3` | defn | 2174 | 20269 | 5700 / 5938 / 8631 | 45584 | 43469 | -2115 | 54699 | +| 9 | `Function.Exact.splitInjectiveEquiv._proof_10` | defn | 3146 | 22977 | 5165 / 7632 / 10180 | 53072 | 50969 | -2103 | 68162 | +| 10 | `_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.«0».VectorField.mpullbackWithin_mlieBracketWithin_aux` | defn | 2598 | 24507 | 4964 / 11409 / 8134 | 54205 | 52184 | -2021 | 74857 | + +### D − A restricted to constants whose current heuristic table exceeds 255 entries + +- Constants: 111351; width classes under D: 1 byte 7, 2 bytes 111280, 3 bytes 64. +- Reference bytes: A 233802244, D 238015530; Δ (D − A) 4213286 (+0.70% of their MSS bytes, +0.50% of their heuristic bytes). +- D vs A: better 12450, equal 14, worse 98887. diff --git a/docs/sharing-minimum-measurements.md b/docs/sharing-minimum-measurements.md new file mode 100644 index 000000000..869a54d34 --- /dev/null +++ b/docs/sharing-minimum-measurements.md @@ -0,0 +1,2093 @@ +# Sharing corpus measurements (plan gate P1.5) + +Measurements for gate P1.5 of [`sharing-minimum.md`](sharing-minimum.md), taken on the +`Init` corpus with the harness `Benchmarks/SharingStudy.lean` (`lake exe sharing-study`). +The plan says these numbers decide P3's design. This document reports them and does not +choose a design. + +**Status.** The corpus `init.ixe` is a format-v3 file (`Tag0`/`Tag2`/`Tag4` integers) +written by the Rust compiler with the heuristic sharing pass, the compiler route at the +time; "stored", "current" and "heuristic" below refer to those tables and codes. Format v4 +replaces the integer codes by TagN and the heuristic by the canonical construction +([`Ixon.md`, "Sharing System"](Ixon.md#sharing-system)); canonical-construction results +are in [`sharing-minimum-performance.md`](sharing-minimum-performance.md). When the +heuristic was removed, the harness was trimmed to the stored, canonical, unshared and MSS +measurements and the `--meta` study. It was later trimmed again, before this PR, to the +production rebuild check, the decode/encode roundtrip, the unshared size and the MSS +baseline: `--meta`, `--meta-crosscheck`, `--occ-check-max` and the candidate statistics +were removed. Every other section needs the harness at the commits listed under +Reproduction. + +## Headline + +Over the 55,386 stored constants that have at least one expression root (all 56,622 +stored constants of `init.ixe` were processed and none were skipped): + +| | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| distinct subterms `N` | 1 | 86 | 470 | 2,015 | 27,628 | 215.50 | +| candidates after R1+R2 (`occ ≥ 2`, size > 1) | 0 | 34 | 232 | 1,187 | 22,458 | 109.96 | +| candidates with size > 3 | 0 | 25 | 193 | 1,113 | 22,224 | 94.42 | +| current heuristic table size | 0 | 26 | 203 | 1,096 | 22,088 | 96.21 | +| stored bytes (`rawBytes.size`) | 9 | 693 | 3,081 | 11,329 | 170,285 | 1,447.33 | + +- Cumulative candidate counts (R1+R2): 17.2% of rooted constants have ≤ 8, 30.0% ≤ 16, + 48.4% ≤ 32, 67.3% ≤ 64 and 81.9% ≤ 128. 10,014 constants (18.1%) have more than 128. + From the CSV: 554 have zero candidates, 50,438 have ≤ 256, 54,673 have ≤ 1,024, 713 have + more than 1,024 and 80 have more than 4,096. +- With the size > 3 cutoff instead: 25.5% are ≤ 8, 84.8% are ≤ 128 and 15.2% + (8,405) are above 128. +- The ten constants with the most candidates are all `defn`s, mostly private `_proof_` terms + from `Init.Data.{Vector,Array}.Extract` and string-pattern lemmas. They have 9,614 to + 22,458 candidates, stored sizes of 77 to 170 KB and unshared sizes of 3.5 to 45.7 MB. +- Totals: stored bytes 80,208,288 and unshared complete-Constant bytes 1,070,001,199. + The stored bytes are 7.5% of the unshared bytes. `defn`s hold 79,781,914 of the stored + bytes. +- For 600 rooted constants (567 defn, 29 recr, 3 muts, 1 axio), the current heuristic's stored + bytes are larger than the unshared encoding. The excess totals 4,649 bytes and is at most + 70 bytes per constant: `String.Slice.Pattern.Model.IsLongestRevMatchAtChain.below.casesOn` + stores 1,005 bytes with a 101-entry table but is 935 bytes unshared. All 600 unshared sizes + were confirmed by serializing the real unshared Constant. +- Longest telescopes: 95 for App, Lam and All (`Lean.Grind.Config.mk.inj` / + `.mk.noConfusion`). For rooted constants the p99 of the per-constant maximum is 17. + +For comparison with the P1.5 criterion: candidate counts are small (≤ 8, where a subset state +space is at most 256) for about one constant in six. They are in the hundreds or more for +about one in five, and in the tens of thousands at the top. + +## Maximal structural sharing (MSS) follow-up + +This is a candidate linear-time canonical rule, measured on the same corpus through the +same harness (`mssBuild` in `Benchmarks/SharingStudy.lean`). The rule is: + +1. `deg(t)` is the number of incoming edges of `t` in the compact hash-consed DAG, counted + with multiplicity (`App(x,x)` contributes 2), plus the number of roots equal to `t`. + This is the compact indegree, not the expanded `occ` used in P1.5. +2. MSS stores exactly the terms with `deg ≥ 2` and unshared standalone size > 1. Every + occurrence of a stored term, in roots and in other entries, becomes a Share. +3. The table is in priority topological order. Among stored terms whose stored body + dependencies (stored terms reachable through unstored nodes) have been emitted, MSS emits + the one with the largest `deg`, breaking ties by the smaller blake3 hash bytes. The + emitted set is always closed under stored proper subterms (by induction on emission), so + this is the same order as the "all stored proper subterms first" formulation. +4. Entries and roots are built with the production helpers + `Ix.Sharing.buildSharingEntries` and `Ix.Sharing.rewriteExprs`, driven by the MSS order. + The roots are put back into the ConstantInfo with the production cursor helpers + (`updateRecursorRules`, `updateMutConsts`), and the constant is serialized with + `serConstant`. All MSS byte counts below are exact serialized lengths. + +### Checks + +- **Plan §2 witnesses:** + - `T2 → T2`: MSS gives **17 bytes**, exactly the plan's minimum + `d200009117b0b001921700170000000100`. The heuristic gives 19 bytes, which are the + plan's `d200009117b1b10291170000911700b0000100`, and unshared is 20. + - `T16 → T16`: MSS gives **46**, the heuristic 81 and unshared 78. These are the three + numbers in the plan's table. + - The plan's closed `A → A → B → B` fixture: MSS gives 25, the plan's stated minimum, the + same as the heuristic. Unshared is 28. +- **Every MSS constant (56,622) was checked:** decoded, re-encoded byte-for-byte, its table + expanded, and its roots compared with the original expanded roots by exact structural + equality (memoized on pointer pairs, not on hashes). There were **0 failures**. +- **Negative controls:** the check rejects the `T2 → T2` bytes against roots that differ in + one leaf, and against the `T16 → T16` roots. + +### Results over the 55,386 constants with at least one root + +| encoding | total bytes | vs heuristic | +|---|---:|---:| +| heuristic (stored `rawBytes`) | 80,161,846 | | +| MSS | 68,547,873 | −11,613,973 (−14.5%) | +| unshared | 1,069,954,757 | +989,792,911 | + +- **Per constant:** + - MSS is smaller than the heuristic for 50,173 constants (90.6%), equal for 4,994 + (9.0%) and larger for 219 (0.4%). + - Savings total 11,614,906 bytes; losses total 933 bytes. + - The 219 losses have p50 3, p90 8, p99 27, max 50 and mean 4.26 bytes. + - The savings have p50 53, p90 384, p99 3,083 and max 65,763 bytes. +- **Signed Δ = MSS − heuristic per constant:** min −65,763, p10 −348, p50 −45, p90 −1, + p99 0, max +50. +- **MSS vs unshared:** MSS is larger than unshared for **0** constants. For comparison, the + heuristic is larger than unshared for 600. +- **By kind (MSS as a share of heuristic bytes):** defn 85.5%, recr 83.2%, muts 96.6%, + axio 99.4%, quot 100.0%. +- **Table sizes:** + + | table size | median | p90 | p99 | max | mean | total entries | + |---|---:|---:|---:|---:|---:|---:| + | MSS | 12 | 102 | 437 | 5,146 | 42.35 | 2,345,582 | + | heuristic | 26 | 203 | 1,096 | 22,088 | 96.21 | 5,328,504 | + +### Where MSS loses + +These are derived from the CSV and describe correlations on this corpus. They are not a +measured decomposition of the losses. + +- **Every** one of the 219 constants where MSS is larger has more than 8 MSS entries, so + some of its Share references are 2 bytes wide. None of the losers has 8 or fewer MSS + entries. + - 217 of the 219 have more MSS entries than heuristic entries. + - 116 have at most 8 heuristic entries but more than 8 MSS entries. +- Over all rooted constants, MSS has more entries than the heuristic for 4,484 constants. +- **Largest losses** (the ten are listed in the harness output below): + - `noConfusionType` definitions of structure-like types, led by + `Std.Packages.LinearPreorderOfOrdArgs.noConfusionType` (+50 bytes: 2,469 → 2,519, with + 57 heuristic entries vs 95 MSS entries); + - `Float.exactlyRepresentablePowersOfTen` and its `eq_1` (+27 and +31); + - `Lean.Grind.CommRing.Mon.revlex*` functions (+13 to +15). +- **Continuation-only MSS entries:** + - *Definition used here:* a stored term that is never a root and whose every DAG + occurrence is a same-family telescope continuation. That means the function child of + an App for an App term, or the body of a Lam (All) for a Lam (All) term. + - *Interpretation:* "function child of an App" is read as applying only when the stored + term is itself an App, since only then does the Share cut a telescope. A non-App head + under an App is not counted. + - *Counts:* there are 567,668 continuation-only entries. Of these, 22,588 have an MSS + entry body of ≤ 2 bytes after the Tag4 header, and 781 have an unshared payload of + ≤ 2 bytes. + - *Spread:* 11,192 rooted constants have at least one entry of the first kind (MSS + payload ≤ 2). Only 41 of them are among the 219 losers; 11,112 are MSS wins and 39 + are ties. + +### Caveats for MSS + +- Ties in `deg` are broken by blake3 hash bytes, a stand-in for the structural IDs of §3.2. + A different ID assignment can change the table order, and so which Shares are 2 bytes + wide. It cannot change the stored set. +- MSS is not claimed to be optimal. It attains the plan's certified minimum on `T2 → T2` and + the stated 25-byte minimum on `A → A → B → B`, and matches the 46-byte feasible + improvement on `T16 → T16` (for which no minimum is certified). It was never larger than + unshared on this corpus. Beyond that, these are plain byte counts compared with the + heuristic and with unshared. + +## Uniform-reference-width classification follow-up + +This measurement tests whether an exact algorithm for the uniform-reference-width cost +model could be tractable. The model fixes a Share width `w ∈ {1, 2, 3}`, charges `w` +bytes for every Share and ignores the table-count prefix. It is implemented in +`classify`, in `Benchmarks/SharingStudy.lean`. + +**Candidates.** The candidates are the subterms with compact `deg ≥ 2` and unshared size +> 1. This is exactly the MSS stored set: 2,345,582 candidates over the rooted constants, +the same total the MSS builder produced, computed independently. + +**Classification.** Each candidate is classified with the gain +`g(n, H, b) = (n−1)·b + (H−1)·hdr − n·w`: + +| class | condition | +|---|---| +| CERTAIN-STORED | `g(deg, headdeg, payloadMin) > 0` | +| CERTAIN-EXCLUDED | `g(occ, occ, payloadMax) < 0`, or a leaf with `(occ−1)·size < occ·w` | +| UNCERTAIN | neither | + +**Components.** Two uncertain nodes are in one component if a directed DAG path joins +them whose intermediate nodes are not certain-stored; components are the transitive +closure of that relation. + +### Change note: corrected `payloadMin` + +The first run of this section used a first specification of +`payloadMin`: scalar bytes plus 1 byte per child. At `w ≥ 2` that bound is too weak, +because a stored child costs `w` bytes as a reference, not 1. The numbers below use the +corrected specification, a width-aware recursive lower bound computed bottom-up on the +compact DAG for each `w`: + +| node | `payloadMin` | `inlineMin` | `cmin` (head use) | `cminCont` (continuation use) | +|---|---|---|---|---| +| leaf | — | its size | `min(w, size)` if a candidate, else `size` | — | +| internal | `scalar + Σ childCost` | `hdr + payloadMin` | `min(w, inlineMin)` if a candidate, else `inlineMin` | `min(w, payloadMin)` if a candidate, else `payloadMin` | + +- `childCost` is `cmin` for a head-position child and `cminCont` for a + continuation-position child: the function child of an App when that child is an App, + or the body of a Lam (All) when that body is a Lam (All). +- The certain-excluded test, the component definition and everything else are unchanged. +- The previous numbers, reported in an earlier revision of this document: + + | w | certain-stored (previous) | uncertain (previous) | largest component, median / p90 / p99 / max (previous) | + |---:|---:|---:|---| + | 1 | 1,698,177 | 647,405 | 1 / 4 / 8 / 87 | + | 2 | 408,749 | 1,586,970 | 5 / 46 / 253 / 3,585 | + | 3 | 23,501 | 1,751,949 | 4 / 65 / 361 / 5,059 | + + The certain-excluded counts are unchanged: 0, 349,863 and 570,132. + +### Implementation notes and interpretations + +- **`headdeg`.** The harness keeps a non-literal reading. An occurrence is a non-head only when `t` + is an App in the function position of an App, or a Lam (All) in the body position of a + Lam (All). Roots are heads. + - The same rule decides continuation positions in `payloadMin`. + - The literal reading ("NOT (function child of an App)" for any `t`) changes the class of + 100, 100 and 92 candidates for w = 1, 2 and 3 respectively, out of 2,345,582. +- **`scalar`:** App 0; Lam, All and Let 1 (the contract byte; the Let flags, ≤ 3, sit in + its one-byte Tag4 header); Prj `Tag0(type index)`. +- **`payloadMax`** is the unshared size minus the node's own Tag4 header. For App, Lam and + All that is the header of the maximal telescope it heads. +- **Header approximation.** `hdr = 1` for every internal node, although a Prj with field + index ≥ 8, or a telescope of 8 or more nodes, has a 2-byte header. As a lower bound this + is on the safe side. +- **Arithmetic** is exact (`Nat`/`Int`). `occ` is not capped. +- **Sanity checks:** no candidate has `payloadMin > payloadMax`, and none met both certain + conditions, for any `w`. +- **Component check.** The fast union-find computation agrees with a literal brute force + (a walk from every uncertain node through all non-certain-stored nodes) on every rooted + constant with at most 1,000 DAG nodes (53,652 of 55,386), with 0 differences for each + `w`. The first version of the fast computation merged components through a shared leaf; + the `A → A → B → B` witness and the brute force exposed it, and it was fixed before any + numbers were reported. +- **Witnesses**, checked by hand (certain-stored / certain-excluded / uncertain / largest + component, for w = 1 | 2 | 3). The harness output matches. + - **`T2 → T2`: 1/0/0/0 | 1/0/0/0 | 0/0/1/1.** The one candidate is `T2 = All(P, T1)`, with + `deg 2`, `headdeg 1` (its body occurrence continues the root's All telescope). + - `T1` is not a candidate and is a continuation child, so it costs its payload 3. + - So `payloadMin(T2) = 1 + 1 + 3 = 5` and `g = 5 − 2w`, which is 3 and 1 for w = 1 and + 2 (stored) and −1 for w = 3. + - The upper bound at w = 3 is `g(2, 2, 5) = 0`, which is not negative, so `T2` is + uncertain. + - **`T16 → T16`: stored for every w.** `payloadMin(T16) = 33` and `g = 33 − 2w > 0`. + - **`A → A → B → B`: 2/0/0/0 | 0/0/2/1 | 0/2/0/0.** + - `A` has `headdeg 2` and `payloadMin 3`, so `g = 4 − 2w`. + - `B` has `headdeg 1` and `payloadMin 3`, so `g = 3 − 2w`. + - The upper bounds `g(2, 2, 3) = 4 − 2w` are 0 at w = 2 (uncertain) and −2 at w = 3 + (excluded). + - `A` and `B` are not joined by a DAG path, so the largest component at w = 2 is 1. + +### Results over the 55,386 constants with at least one root + +**Class totals and counts of uncertain nodes per constant:** + +| w | certain-stored | certain-excluded | uncertain | uncertain per constant: median / p90 / p99 / max | +|---:|---:|---:|---:|---| +| 1 | 1,887,527 (80.5%) | 0 | 458,055 (19.5%) | 2 / 21 / 95 / 970 | +| 2 | 1,504,278 (**64.1%**) | 349,863 (14.9%) | 491,441 (21.0%) | 3 / 22 / 84 / 736 | +| 3 | 1,276,154 (**54.4%**) | 570,132 (24.3%) | 499,296 (21.3%) | 2 / 22 / 98 / 978 | + +Percentages are of the 2,345,582 candidates. + +**Largest uncertain component per constant:** + +| w | median / p90 / p99 / max | ≤ 8 | ≤ 16 | ≤ 32 | > 32 | +|---:|---|---:|---:|---:|---:| +| 1 | 1 / 2 / 4 / 45 | 55,332 (99.9%) | 55,382 | 55,384 | 2 | +| 2 | 1 / 3 / 5 / 44 | 55,328 (99.9%) | 55,384 | 55,385 | 1 | +| 3 | 1 / 3 / 6 / 44 | 55,228 (99.7%) | 55,378 | 55,385 | 1 | + +**Constants by number of uncertain nodes (cumulative except the first and last columns):** + +| w | = 0 | ≤ 8 | ≤ 16 | ≤ 32 | > 32 | +|---:|---:|---:|---:|---:|---:| +| 1 | 13,486 | 43,174 | 48,357 | 52,353 | 3,033 | +| 2 | 11,593 | 39,615 | 47,353 | 52,492 | 2,894 | +| 3 | 14,878 | 40,386 | 47,612 | 52,174 | 3,212 | + +- **Why w = 1 has no certain-excluded candidates.** At w = 1 the maximal-gain bound is + never negative when `occ ≥ 2`: + - an internal node has `(occ−1)·(payloadMax + 1) − occ ≥ 2·occ − 3 > 0`; + - a leaf of size ≥ 2 has `(occ−1)·size − occ ≥ occ − 2 ≥ 0`. +- **The largest components** are 45 at w = 1 and 44 at w = 2 and 3, all in + `Lean.Grind.Config.mk.injEq`. The next are `Lean.Meta.Simp.Config.mk.injEq` (30–31) and + `UInt8.utf8ByteSize_eq_utf8ByteSize_parseFirstByte` (35 at w = 1, 31 at w = 3). The ten + largest for each `w` are in the harness output below. + +### Share-width loss in the current stored encoding + +This part does not depend on `payloadMin` and is unchanged from the previous run. Share +references are counted syntactically in the stored roots and table entries (the current +heuristic encoding). The largest stored table has 22,088 entries, so every index ≥ 256 +costs 3 bytes today. + +| stored table entries | constants | refs to 0–7 (1 B now) | refs to 8–255 (2 B) | refs to ≥ 256 (3 B) | loss under uniform width | +|---|---:|---:|---:|---:|---| +| 9–255 | 37,610 | 776,978 | 3,298,554 | 0 | w = 2: **776,978 B** | +| > 255 | 4,335 | 202,727 | 2,795,056 | 3,328,853 | w = 3: 2·202,727 + 2,795,056 = **3,200,510 B** | +| 1–8 (extra) | 11,367 | 119,925 | 0 | 0 | not requested | + +- **Scale:** the corpus stores 80,208,288 bytes, with 10,522,093 Share references. +- **Derived arithmetic:** the Share references occupy 23,273,409 bytes. The w = 2 loss is + 0.97% of the stored bytes, the w = 3 loss 3.99%, and the two together 3,977,488 bytes + (4.96%). + +## Share-width schemes on the MSS encoding follow-up + +This section prices the Share references of each rooted constant's MSS encoding under +seven width schemes. It is implemented in `schemeReport`. + +- **References.** Every occurrence of an MSS entry is a Share. The harness counts the + Share nodes in the materialized MSS table and roots, grouped by index. For all 55,386 + rooted constants the count equals `Σ deg(t)` over the MSS entries, which confirms + `refcount(t) = deg(t)`. +- **The seven schemes:** + + | scheme | Share width | + |---|---| + | A | the current tiers, by index in MSS priority order: 1 byte below 8, 2 below 256, 3 below 65,536. This is the real MSS encoding. | + | B | one width per constant: 2 bytes (11-bit index) if the MSS entry count, which is the candidate count, is ≤ 2048; otherwise 3 bytes (19-bit index) | + | C | as B, but 1 byte (3-bit index) when the entry count is ≤ 8 | + | D | one width per constant, with the Share tag byte's whole low nibble holding index bits: 1 byte (4-bit index) for ≤ 16 entries, 2 bytes (12-bit) for ≤ 4,096, 3 bytes (20-bit) above | + | E | position tiers with a nibble escape, by index in MSS priority order: 1 byte for index < 15, 2 bytes for index < 15 + 4,096 = 4,111, 3 bytes beyond. **Not realizable:** with a 4-bit Share flag, the first byte has only 4 bits and a "more bytes follow" marker costs some of them, so 2 bytes carry at most 10–11 index bits. It is kept for reference only. | + | F | realizable position tiers with two marker bits (3-bit direct index, or 2 bits + 1 byte, or 2 bits + 2 bytes): 1 byte for index < 8, 2 bytes for index < 8 + 1,024 = 1,032, 3 bytes beyond | + | G | realizable position tiers with nibble values 14 and 15 as escapes: 1 byte for index < 14, 2 bytes for index < 14 + 256 = 270, 3 bytes beyond | + +- **Constant bytes under a scheme** are `MSS bytes − refbytes(A) + refbytes(scheme)`. + Nothing else in the encoding changes. + +### Results over the 55,386 rooted constants + +There are 9,297,007 Share references in total. 20 constants have more than 2,048 MSS +entries and so take width 3 under B and C. 22,270 have at most 8 entries and take +width 1 under C. + +| scheme | reference bytes | MSS constant bytes | Δ vs A | Δ / MSS total | Δ / heuristic total | +|---|---:|---:|---:|---:|---:| +| A (index tiers) | 17,568,850 | 68,547,873 | 0 | | | +| B (2 or 3 per constant) | 18,990,396 | 69,969,419 | +1,421,546 | +2.07% | +1.77% | +| C (1, 2 or 3 per constant) | 18,724,875 | 69,703,898 | +1,156,025 | +1.69% | +1.44% | +| D (1, 2 or 3 per constant, nibble index) | 18,207,733 | 69,186,756 | +638,883 | +0.93% | +0.80% | +| E (index tiers < 15 / < 4,111 / beyond; not realizable) | 15,442,797 | 66,421,820 | −2,126,053 | −3.10% | −2.65% | +| F (index tiers < 8 / < 1,032 / beyond) | 16,577,564 | 67,556,587 | **−991,286** | −1.45% | −1.24% | +| G (index tiers < 14 / < 270 / beyond) | 16,741,559 | 67,720,582 | **−827,291** | −1.21% | −1.03% | + +The MSS total is 68,547,873 bytes and the heuristic total is 80,161,846 bytes (rooted +constants). Derived arithmetic: the MSS total stays below the heuristic total by 12.71% under B +(1 − 69,969,419 / 80,161,846), 13.05% under C, 13.69% under D, 17.14% under E, 15.72% under F and 15.52% under G. + +**Per constant:** + +| comparison | better | equal | worse | +|---|---:|---:|---:| +| B vs A | 829 | 555 | 54,002 | +| C vs A | 829 | 22,271 | 32,286 | +| D vs A | 9,773 | 22,271 | 23,342 | +| E vs A | 33,116 | 22,270 | 0 | +| F vs A | 1,352 | 54,034 | 0 | +| G vs A | 33,116 | 22,270 | 0 | + +- All 829 constants that improve under B are among the 4,335 below. +- **Largest losses under B:** + - `Nat.digitChar_iff_aux` +17,274: 2,763 entries, so width 3; A 43,371 → B 60,645 + reference bytes. + - `…ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` +13,382 (4,874 entries). + - `…Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'` +10,675 + (2,712 entries). +- **Largest gains under B:** all have 1,600–1,900 entries, just below the 2,048 cut. + - `…Vector.extract_reverse._proof_1` −7,579 (1,908 entries). + - `…Array.toList_extract._proof_1_1` −6,803. + - `…Int.max_min_distrib_left._proof_1_1` −6,743. +- The ten of each are in the harness output below. + +### Restricted to the 4,335 constants whose current heuristic table exceeds 255 entries + +- **Totals:** their MSS bytes are 25,359,218 and their heuristic bytes 33,341,195. Their + MSS entry counts range from 44 to 5,146, and 20 of them have more than 2,048 entries. +- **Reference bytes:** A 11,525,602 and B 11,441,534, so B − A = **−84,068 bytes**. That is + −0.33% of their MSS bytes and −0.25% of their heuristic bytes. +- **Per constant, B vs A:** better 829, equal 1, worse 3,505. + +### Scheme D in detail + +- **Width classes under D:** + + | width | entries | constants | + |---|---|---:| + | 1 byte | ≤ 16 | 31,200 | + | 2 bytes | 17–4,096 | 24,180 | + | 3 bytes | > 4,096 | 6 | + +- **Equal constants:** the 22,271 constants equal under D are the same count as under C: + the 22,270 constants with at most 8 entries, plus 1. For a constant with 9–16 entries, + D is never worse than A. +- **Largest losses under D** are the six constants with more than 4,096 entries: + - `…ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` +13,382 (4,874 entries); + - `…Vector.extract_append._proof_1` +7,936; + - `…Vector.extract_extract._proof_1` +7,488; + - `…Array.extract_append._proof_1_1` +6,363; + - two more `extract_append_extract` proofs, at +5,867 and +5,727. + + After them come constants with 160–360 entries and many references to indices below 8, + such as `…Nat.digitChar_ne.match_1_1` (+1,072, 199 entries). +- **Largest gains under D** come from constants with roughly 1,800–3,700 entries, which + pay 3 bytes under A for every index ≥ 256: + - `…Array.extract_extract._proof_1_1` −17,041 (3,640 entries); + - `…Int.add_one_tdiv._proof_1_1` −15,320 (3,236); + - `…Vector.extract_add_left._proof_1` −12,595 (2,854). +- The ten of each are in the harness output below. + +**D restricted to the 4,335 constants whose heuristic table exceeds 255 entries:** + +- Width classes: 0 at 1 byte, 4,329 at 2 bytes, 6 at 3 bytes. +- Reference bytes: A 11,525,602 and D 11,226,247, so D − A = **−299,355 bytes**. That is + −1.18% of their MSS bytes (25,359,218) and −0.90% of their heuristic bytes + (33,341,195). +- D vs A: better 843, equal 1, worse 3,491. + +### Scheme E in detail + +Scheme E is not realizable as specified (see the scheme table above). Its numbers are kept +only as a reference point for F and G. + +- **Counting.** Share nodes are counted on the materialized MSS encodings in E's index + buckets (< 15, 15–4,110, ≥ 4,111). For every rooted constant the three buckets sum to + the same Share count as A's buckets. +- **E is never worse than A for any constant.** At every index E's width is at most A's: + + | indices | A | E | + |---|---:|---:| + | 0–7 | 1 | 1 | + | 8–14 | 2 | 1 | + | 15–255 | 2 | 2 | + | 256–4,110 | 3 | 2 | + | 4,111–65,535 | 3 | 3 | + + The measured counts agree: 33,116 better, 22,270 equal and 0 worse. + - The 22,270 equal constants are exactly those with at most 8 MSS entries (checked from + the CSV), which only use indices below 8. + - Every constant with more than 8 entries references index 8, since every entry has + `deg ≥ 2`, so it gains at least 2 bytes. +- **"Largest losses".** Because there are no losses, the harness's list of ten largest + losses under E is ten ties at 0, in name order. +- **Largest gains under E** come from the big `Init.Data.{Vector,Array}.Extract` proofs, + which have most of their references at indices 15–4,110: + - `…Array.extract_append._proof_1_1` −21,634 (5,146 entries; 957 / 26,083 / 4,383 refs + in E's buckets); + - `…Vector.extract_append_extract._proof_1` −21,571; + - `…Array.extract_append_extract._proof_1_1` −21,432. + + The ten are in the harness output below. +- **Totals:** E saves 2,126,053 bytes against the real MSS encoding. That is 3.10% of the + MSS total and 2.65% of the heuristic total. Under E the MSS total is 17.14% below the + heuristic total (derived: 1 − 66,421,820 / 80,161,846). + +### Schemes F and G in detail (realizable position tiers) + +- **Counting.** Share nodes are counted on the materialized MSS encodings in each scheme's + index buckets: F < 8 / 8–1,031 / ≥ 1,032, and G < 14 / 14–269 / ≥ 270. For every + rooted constant the buckets of each scheme sum to the same Share count as A's. +- **No constant is worse than A under F or under G.** The harness reports 0 worse + constants and a largest per-constant Δ of 0 for both. This matches the widths: + + | indices | A | F | G | + |---|---:|---:|---:| + | 0–7 | 1 | 1 | 1 | + | 8–13 | 2 | 2 | 1 | + | 14–255 | 2 | 2 | 2 | + | 256–269 | 3 | 2 | 2 | + | 270–1,031 | 3 | 2 | 3 | + | ≥ 1,032 | 3 | 3 | 3 | + +- **F:** saves 991,286 bytes (−1.45% of the MSS total, −1.24% of the heuristic total). + - 1,352 constants are better and 54,034 equal. + - The better constants are exactly the 1,352 rooted constants with at least 257 MSS + entries (checked from the CSV). Only those use indices 256–1,031. + - Largest gains: `…Array.extract_append._proof_1_1` −6,490, + `…Vector.extract_extract._proof_1` −6,279 and `…Int.add_one_tdiv._proof_1_1` −6,208. +- **G:** saves 827,291 bytes (−1.21% of the MSS total, −1.03% of the heuristic total). + - 33,116 constants are better and 22,270 equal. + - The better constants are exactly the rooted constants with more than 8 MSS entries: + all of them reference indices 8–13, which drop from 2 bytes to 1. + - Largest gains: `…Array.extract_extract._proof_1_1` −1,853, + `…Vector.extract_reverse._proof_1` −1,265 and + `…Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'` −1,146. +- **MSS vs heuristic** (derived): under F the MSS total is 15.72% below the heuristic total + (1 − 67,556,587 / 80,161,846), and under G 15.52% below. +- The ten largest gains for each scheme are in the harness output below. + +## Exact uniform-width optimizer follow-up + +This section runs the Lean exact optimizer for the uniform-width cost model +(`Ix.Sharing.Exact`) over the corpus. + +- **Code.** The harness ran on the development branch once it contained the Lean exact + core (`Ix/Sharing/Exact/*`) and its Rust port. The harness files merged unchanged. +- **Call.** For every rooted constant and `w ∈ {1, 2, 3}` the harness calls + `Ix.Sharing.Exact.optimizeSharingUniformTable w c.sharing (constantInfoRoots c.info) limits`. +- **Limits:** + - `maxStates` = 2^20 = 1,048,576, the suggested size of about 10^6; + - everything else at the defaults of that commit: `maxCostEvals` 2^30, `maxNodes` 2^20, + `maxDepth` 2^14, `maxExprVisits` 2^26, `maxMaterialize` 2^26, `maxOutputBytes` 2^28. +- **Processing each certified result:** + - the roots are placed with the production cursor helpers and serialized with + `serConstant`, which gives the real length under v3's Tag4 tiers; + - the bytes are decoded, re-encoded, expanded and compared exactly with the original + expanded roots; + - the real length is checked to equal the fixed bytes plus the optimizer's + `variableBytes`; + - the same table and roots are priced under scheme F widths; + - the model length is the fixed bytes plus the optimizer's `modelBytes`. +- **Wall time** is the optimizer call alone, single-threaded. + +### Checks (every certified run, every `w`) + +- **Outputs:** 0 decode/expand failures. The real length equals fixed + `variableBytes` + in every case, and the optimizer's distinct-subterm count equals this harness's `N` in + every case. +- **Classes agree with an independent reimplementation.** The harness reimplements the + optimizer's classification on its own blake3 DAG (`classifyW1Mode`), with the + optimizer's rules: + - certain-excluded: `(occ−1)·size < occ·w`, for every term; + - candidates: `deg ≥ 2` and not certain-excluded; + - bounds: the optimizer's `inl⁻` / merged bounds with exact headers; + - certain-stored: `g ≥ 2` with the optimizer's three gain formulas; + - components: as defined above. + + The optimizer's reported counts of certain-stored, certain-excluded, uncertain and low-degree + terms, its number of components and its largest component equal the reimplementation + for **every** certified constant: 55,294, 55,358 and 55,338 at w = 1, 2 and 3, with 0 + differences. +- **Lower bound.** No measured encoding (heuristic, MSS, the three uniform outputs) is + shorter than the w = 1 model optimum for any of the 55,263 constants certified at all + three widths. + +### Certification and failures + +| w | certified | failed | of which `states` (2^20) | of which `costEvals` (2^30) | +|---:|---:|---:|---:|---:| +| 1 | 55,294 | 92 | 90 | 2 | +| 2 | 55,358 | 28 | 26 | 2 | +| 3 | 55,338 | 48 | 46 | 2 | + +- **The two `costEvals` failures** at every width are `Lean.Grind.Config.mk.injEq` + (largest component 45 / 44 / 44 under the optimizer's definitions) and + `Lean.Meta.Simp.Config.mk.injEq` (57 / 57 / 61). These six runs are the six slowest + overall, at 83–108 s each. +- **Where the limit bites.** Joining the run-9 certification with the run-10 + reimplementation (from the CSVs): + - every failing constant has a largest component of **at least 20**, with medians of + 25 / 23 / 24 and maxima of 57 / 57 / 61; + - **every** constant with a component of 22 or more failed (83 / 24 / 33); + - at 20–21, 17 / 4 / 3 constants certified; + - the largest certified component is 21 / 20 / 20. + + So with `maxStates` = 2^20, the limit sits at a largest component of 20–21. + +### Bytes, over each width's certified constants + +| w | heuristic | MSS | uniform real (current tiers) | uniform, scheme F widths | uniform model | unshared | +|---:|---:|---:|---:|---:|---:|---:| +| 1 | 78,855,708 | 67,563,348 | 66,737,821 (−1.22% vs MSS) | 66,047,771 (−2.24%) | 59,469,841 | 987,599,557 | +| 2 | 79,830,766 | 68,297,958 | 67,593,621 (−1.03%) | 66,954,321 (−1.97%) | 68,379,047 | 1,038,467,344 | +| 3 | 79,849,102 | 68,301,284 | 68,216,736 (−0.12%) | 67,644,231 (−0.96%) | 74,603,766 | 1,061,642,946 | + +The uniform real lengths are 15.37%, 15.33% and 14.57% below the heuristic on the same +constants. + +**Per constant, uniform output (real length) vs MSS:** + +| w | better | equal | worse | gains p50 / p90 / max | losses p50 / p90 / max | +|---:|---:|---:|---:|---|---| +| 1 | 31,245 | 23,833 | 216 | 10 / 39 / 2,670 | 1 / 4 / 46 | +| 2 | 21,751 | 6,098 | 27,509 | 14 / 61 / 5,252 | 5 / 14 / 929 | +| 3 | 12,687 | 3,526 | 39,125 | 14 / 75 / 5,398 | 9 / 29 / 1,523 | + +- **Against the heuristic (better / equal / worse):** 50,302 / 4,938 / 54 at w = 1; + 46,968 / 3,003 / 5,387 at w = 2; 43,719 / 2,683 / 8,936 at w = 3. +- **Largest gains and losses vs MSS** (the ten of each per width are in the harness output + below): + - w = 1: gain `…Array.extract_append._proof_1_1` −2,670 (105,389 → 102,719); loss + `Lean.Meta.Simp.Config.mk.inj` +46 (1,984 → 2,030). + - w = 2: gain the same constant −5,252; loss `Std.Iter.step_flatMapAfterM` +929. + - w = 3: gain `…Vector.extract_append_extract._proof_1` −5,398; loss + `Std.Iter.step_flatMapAfterM` +1,523. + +### Wall time (optimizer call, µs) + +| w | median | p90 | p99 | max | +|---:|---:|---:|---:|---:| +| 1 | 249 | 2,964 | 182,154 | 108,188,764 | +| 2 | 210 | 2,517 | 47,081 | 98,799,418 | +| 3 | 179 | 2,578 | 58,856 | 103,226,807 | + +The total over all 166,158 runs is 6,875,358 ms (1 h 55 min). All ten slowest runs are +failures: the six `costEvals` runs above, then four `states` failures at w = 1 +(51–63 s). + +### Lower-bound gap against the w = 1 model optimum + +Under v3's Tag4 tiers (as under TagN) every Share costs at least 1 byte, so the w = 1 +model optimum lower-bounds every tiered encoding. Over the 55,263 constants +certified at all three widths, Σ model(w = 1) = 59,370,988: + +| encoding | Σ bytes | Σ (bytes − model w=1) | % of Σ model | +|---|---:|---:|---:| +| heuristic | 78,696,174 | 19,325,186 | +32.55% | +| MSS | 67,438,618 | 8,067,630 | +13.59% | +| uniform w = 1 output | 66,615,107 | **7,244,119** | +12.20% | +| uniform w = 2 output | 66,778,657 | 7,407,669 | +12.48% | +| uniform w = 3 output | 67,406,916 | 8,035,928 | +13.54% | +| best of these per constant | 66,331,917 | 6,960,929 | +11.72% | + +### The optimizer's classes vs this harness's own classification + +Over the 55,263 constants certified at all widths. The two classifications are not +expected to agree, because the definitions differ: +- The optimizer uses `g ≥ 2` for certain-stored (the harness uses `g > 0`). +- The optimizer applies `(occ−1)·size < occ·w` to every term (the harness applies the + `payloadMax` test to candidates only). +- The optimizer drops certain-excluded terms from the "may be stored" set when computing + bounds. +- The optimizer uses exact header sizes. + +Where the definitions coincide, that is with the harness's reimplementation of the +optimizer's rules, they agree exactly (above). + +| w | own certain-stored | optimizer | own uncertain | optimizer | own max component | optimizer | +|---:|---:|---:|---:|---:|---:|---:| +| 1 | 1,842,180 | 1,437,377 | 444,030 | 848,833 | 16 | 21 | +| 2 | 1,460,911 | 1,189,917 | 480,307 | 751,301 | 14 | 20 | +| 3 | 1,235,457 | 1,063,687 | 486,863 | 658,633 | 19 | 20 | + +## Integer repricing (TagN) follow-up + +This section reprices every integer of the stored (heuristic) encoding of all 56,622 +constants under three replacement codes. It is implemented in `ladConstant` and +`tagNReport`. + +- **The walk.** The harness walks each encoding exactly as `putConstant`, `putExpr` and + `putUniv` write it: App/Lam/All telescope counts are taken as the writers collect them, + and a successor chain is one `Tag2`. Each integer is assigned to a field class. +- **The codes:** + + | code | replaces | 1 byte | 2 bytes | 3 bytes | 5 bytes | 9 bytes | + |---|---|---|---|---|---|---| + | TagN | every `Tag4` | below 8 | below 8 + 1024 | below 1032 + 65536 | below that + 2^32 | beyond | + | TagN-byte (working name) | every `Tag0` | below 128 | below 128 + 16384 | below 16512 + 65536 | below that + 2^32 | beyond | + | Tag2 variant of TagN | every `Tag2` | below 32 | below 32 + 4096 | below 4128 + 65536 | below that + 2^32 | beyond | + + The current costs are `tag4EncodedSize`, `tag0EncodedSize` and `putTag2`. +- **Check.** For **all 56,622** constants, the integer bytes plus the non-integer bytes + (flag and contract bytes, addresses) equal `rawBytes.size`. +- **Cross-check.** The walk finds 10,522,093 Share indices occupying 23,273,409 bytes, + the same figures as the earlier count of Share references by index. + +### Results + +The corpus stores 80,208,288 bytes: +- `Tag4` integers: 22,822,097, taking 36,407,507 bytes; +- `Tag0` integers: 3,486,829, taking 3,504,738 bytes; +- `Tag2` integers: 234,690, taking 234,690 bytes; +- other bytes: 40,061,353. + +| repricing | family | bytes now | bytes after | change | % of stored bytes | +|---|---|---:|---:|---:|---:| +| TagN | `Tag4` | 36,407,507 | 34,361,119 | **−2,046,388** | −2.55% | +| TagN-byte | `Tag0` | 3,504,738 | 3,500,360 | −4,378 | −0.0055% | +| Tag2 variant | `Tag2` | 234,690 | 234,690 | 0 | 0 | +| TagN + TagN-byte | | | | −2,050,766 | −2.56% | +| all three | | | | −2,050,766 | −2.56% | + +- **No integer gets longer** under any of the three codes: the bytes-lost column is 0 in + every field class. +- **Where the savings come from:** + - Share indices: −2,046,174 bytes. These are the indices 256–1,031, which go from 3 + bytes to 2. + - Table counts: −4,330. Str/Nat indices: −214. Ref/Recur indices: −48. + - Every other field class: 0. That covers Var indices, Sort levels, App argument + counts, Lam/All binder counts, Ref/Recur universe-list lengths and universe indices, + Prj fields and type indices, Let flags, ConstantInfo headers and scalar fields, and + universe terms. +- **Current widths per tag family** (the full table, including the repriced widths, is in + the harness output below): + + | family | 1 byte | 2 bytes | 3 bytes | 4–9 bytes | + |---|---:|---:|---:|---:| + | `Tag4` | 12,565,754 | 6,927,276 | 3,329,067 | **0** | + | `Tag0` | 3,473,304 | 9,141 | 4,384 | **0** | + | `Tag2` | 234,690 | 0 | 0 | **0** | + + **No integer in Init currently uses a 4-, 5-, 6-, 7-, 8- or 9-byte form, in any tag + family.** + +## Metadata and sharing follow-up (Init and Mathlib) + +The question is whether metadata expressions should participate in sharing. This +section measures where the bytes of a whole `.ixe` go, and what `metaSharing` +contains, on Init (`init.ixe`, 195,387,870 bytes) and on Mathlib (`mathlib.ixe`, +3,343,271,273 bytes; the corpus of `sharing-minimum-measurements-mathlib.md`). It was +implemented as the harness's `--meta` mode, which existed only in development versions of +the harness and was removed before this PR. + +### Method + +- **Streaming scanner.** The harness reads the file section by section with the + production readers (`getExprMetaDataIndexed`, `getExpr`, `getUniv`, + `getFusedHint`, …). It mirrors `getEnv` and `getConstantMetaIndexed` exactly and + records the byte range of every component. A constant is parsed only when a `Named` + entry needs it. +- **Why not `deEnv` on Mathlib.** `deEnv` was used on Init but **not** on Mathlib. It + materializes the whole environment, and the scanner already reads the full `Named` + section without doing so. +- **Checks:** + - On both files the byte categories sum **exactly** to the file size. + - Every `Named` entry's metadata blob parses to exactly its length prefix. + - On Init, every total the scanner reports equals a full `Ixon.deEnv` load: named + entries, blobs, constants, non-empty `metaSharing`, its entries and their + `serExpr` bytes, `metaRefs`, `metaUnivs`, entries with `original`, and `original` + `metaSharing` entries. +- **`metaSharing` analysis.** The constant's primary sharing table, its primary roots + and the `metaSharing` entries are expanded into one canonical DAG with the exact core's + `Ix.Sharing.Exact.expand`. + - **Which table is "primary".** A `Share` in an entry would index the primary table, + as in `DecompileM.mkBlockCtx`. For a projection, the primary table is the block's, + as in `DecompileM.decompileOne`. + - **"Structurally equal"** is exact here, because the exact core's interner keys on the + full node. + Index-level equality is what a dictionary can exploit. + - **Re-encoding.** Each entry is re-encoded optimally with the primary table as a fixed + dictionary at its current index widths (`Prep.materializeWith`). The harness + checks that the output re-expands (`reexpand`) to the same terms and that its + `serExpr` bytes equal the predicted `C_M`. + - **Deduplication.** "Deduplicated" counts each distinct entry of a constant's table + once. +- **Names** of the constants with non-empty `metaSharing` come from the lazy + `deEnvAnon` loader. + +### Where the bytes go + +| component | Init bytes | Init % | Mathlib bytes | Mathlib % | +|---|---:|---:|---:|---:| +| §2 anonymous constants (bodies, addresses, length prefixes) | 82,179,806 | 42.06% | 1,492,588,407 | 44.64% | +| §5 ExprMeta arenas (primary + `original`) | 83,050,319 | 42.51% | 1,436,611,288 | 42.97% | +| §5 everything else (keys, hints, ConstantMeta info, metaSharing, metaRefs, metaUnivs, univPatches, `original` header) | 2,559,387 | 1.31% | 41,384,722 | 1.24% | +| §4 names | 24,654,949 | 12.62% | 344,172,899 | 10.29% | +| §1 blobs | 2,834,610 | 1.45% | 27,209,569 | 0.81% | +| §3 anonymous hints, header, §6 comms | 108,799 | 0.06% | 1,304,388 | 0.04% | + +- **Mathlib's non-constant bytes are 1,850,682,866 (55.36% of the file):** + - 77.6% of them are ExprMeta arenas; + - 18.6% are names. +- **The arena's App nodes are the largest single item.** An arena App node stores only + its two child arena indices. + + | | App nodes | bytes | % of file | avg bytes per node | + |---|---:|---:|---:|---:| + | Mathlib | 219,151,448 | 1,153,185,700 | 34.49% | 5.26 | + | Init | 13,111,962 | 66,602,568 | 34.09% | | + + The next largest arena node kinds in Mathlib are binder nodes (138.9 MB, 4.15%) and + ref nodes (112.6 MB, 3.37%). +- **Full category tables.** The full per-category and per-node-kind tables for both + files are in the generated fragments at the end of this document. + +### `metaSharing` + +- **Init:** no `Named` entry has a non-empty `metaSharing`, in either the primary or the + `original` metadata, so there is nothing to share. Init has 2,363 `metaUnivs` entries + and 0 `metaRefs`. +- **Mathlib:** 7 of 778,344 `Named` entries have a non-empty `metaSharing`, all + `Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_1` … `_7`. None of the 22,265 + `original` metadata has one. Mathlib has 413,181 `metaUnivs` entries and 0 `metaRefs`. + +| Mathlib `metaSharing` | value | +|---|---:| +| tables / entries | 7 / 524 (30 to 114 per table) | +| serialized bytes of the entries | 42,929 (0.0013% of the file) | +| entries equal to a subterm of the primary term | 412 (34,613 bytes) | +| entries equal to a primary table entry | 288 | +| re-encoded optimally against the primary table | **5,495 bytes** (saves 37,434 = 0.0011% of the file) | +| deduplicated within each table (203 distinct entries) | 14,599 bytes | +| re-encoded and deduplicated | **2,586 bytes** (saves 40,343 = 0.0012% of the file) | +| `Share` nodes inside metadata expressions | **0** | + +The current entries are stored fully unshared: their unshared size equals their stored +size. + +### Not measured + +- **Duplication inside ExprMeta arenas** was not measured, for example identical nodes + or subtrees within a constant's arena. The arenas are not Ixon expressions, and the + question was about `metaSharing`. +- **Not counted in the deduplication figure:** + - sharing of subterms *between* `metaSharing` entries; + - sharing across constants; + - any change to the call-site entries' `sharingIdx` widths that deduplication would + require. +- **The primary table was held fixed.** The re-encoding never adds entries for the + metadata or reorders the primary table. +- **The `deEnv` cross-check was run on Init only.** On Mathlib the scanner is checked by + the byte-sum and per-entry framing checks. + +## ExprMeta arena structure follow-up (for a later PR) + +This section measures the ExprMeta arenas, the largest non-constant part of the file: +how far child references reach, and how much repeats within an arena. The encoding it led +to (implicit post-order children) is part of format v4; hash-consing is left for a later +PR ([`sharing-minimum-arena.md`](sharing-minimum-arena.md)). It covers every arena, +primary and `original`, of Init and Mathlib, with the `--meta` scanner (code in +`arenaStudy` / `arenaReport`, removed with `--meta` before this PR). An arena stores its +nodes bottom-up, and a child field is the `Tag0` of the child's absolute index within the +arena. + +### Method + +- **(1) Child deltas.** For every child slot of App, Binder, LetBinder, Prj and Mdata + nodes, the harness histograms `parent index − child index`. It also prices each child + field two ways: + - today: `Tag0` of the absolute index; + - as a backward delta with TagN-byte widths: 1 byte below 128, 2 below 16,512, 3 below + 82,048, 5 below that + 2^32, 9 beyond. + + Call-site metadata references are excluded, as requested. +- **(2) Duplication.** Each arena is hash-consed bottom-up on (kind, payload, canonical + child IDs): + - payload is the name address and binder info, the `mdata` stack, or the call-site + shape; + - a node is a *duplicate* when its canonical ID already occurred in the same arena; + - a *maximal duplicate subtree* is rooted at a duplicate node that no duplicate node + references, and contains the duplicate nodes reachable from it through duplicates. +- **(3) App-only figures:** the App slots of (1); the App nodes of (2); and maximal + duplicate subtrees rooted at an App. +- **Checks:** + - no child points forward or to itself, in either corpus; + - arena node bytes equal the per-kind arena bytes reported above; + - the maximal duplicate subtrees cover exactly the duplicate nodes; + - an independent recount, comparing full subtree strings on every arena of at most + 256 nodes, agrees with the hash-consing count on **52,699 / 52,699** Init arenas and + **539,729 / 539,729** Mathlib arenas checked (15,296 and 253,665 larger arenas were + not recounted). + +### Results + +| | Init | Mathlib | +|---|---:|---:| +| arenas / nodes | 67,995 / 16,335,501 | 793,394 / 272,299,746 | +| node bytes (% of file) | 82,945,079 (42.45%) | 1,435,189,339 (42.93%) | +| child references studied | 28,914,135 | 481,089,260 | +| … to the immediately preceding node (Δ = 1) | 12,044,879 (41.66%) | 206,104,585 (42.84%) | +| child-field bytes today | 57,823,309 | 1,009,893,689 | +| as TagN-byte backward deltas | 36,922,863 | 618,324,166 | +| **change (% of file)** | **−20,900,446 (−10.70%)** | **−391,569,523 (−11.71%)** | +| … App slots only | −19,784,967 (−10.13%) | −371,878,062 (−11.12%) | +| duplicate nodes (within an arena) | 7,348,183 (45.0% of nodes) | 133,235,031 (48.9% of nodes) | +| **bytes in duplicate nodes (% of file)** | **37,063,057 (18.97%)** | **708,442,761 (21.19%)** | +| maximal duplicate subtrees | 1,490,676 | 17,821,128 | +| App nodes / App duplicates | 13,192,988 / 6,610,293 | 221,528,194 / 119,976,692 | +| bytes in duplicate App nodes | 34,390,613 (17.60%) | 662,307,925 (19.81%) | +| maximal duplicate subtrees rooted at an App (bytes) | 1,293,632 (31,940,216; 16.35%) | 14,629,275 (633,508,953; 18.95%) | + +- **Slot details:** + - The App function slot has the most Δ = 1 children: 125,476,650 of 221,528,194 in + Mathlib. It also has the largest delta saving: −251.7 MB, 7.53% of the file. + - The Binder type slot is the only one where deltas cost more than today: +474,077 + bytes in Mathlib. + - Per-slot histograms and the subtree-size histogram are in the generated fragments. + +### Not measured + +- **Combined effect.** The two measures are not additive. Removing duplicates renumbers + the arena, which changes every delta. Neither measure includes the cost of + redirecting references (roots, call-site entries) to a surviving duplicate. +- **Other arena fields:** `Tag0` child fields of call-site nodes, name indices and node + tags were not repriced. +- **Duplication across arenas** (between constants) and between primary and `original` + arenas of the same constant. + +## Verification of the harness + +- **Production rebuild: 0 mismatches out of 56,622.** For every constant, the harness + expanded the stored table and recovered the ordered roots with + `Ix.CompileM.constantInfoRootExprs`. It then rebuilt the Constant with + `Ix.CompileM.buildConstantWithSharing` (then the heuristic `Ix.Sharing.applySharing`, + since removed) and compared + `Ixon.serConstant` byte-for-byte with `LazyConstant.rawBytes`. All were identical. The + corpus was written by the Rust compiler (`ix compile` → `rsCompileEnvBytesFFI`), so this + also shows that Lean's heuristic reproduces Rust's bytes on all of `Init`. +- Plain decode/encode roundtrip (`serConstant (get lc) = rawBytes`): 0 differences. +- Compositional unshared size vs `serConstant` of the actual unshared Constant (same info + fields, refs and univs, expanded roots, empty table): 56,615 equal and 0 different. The + 7 constants whose unshared roots exceed 16 MiB were not serialized (listed below); their + unshared sizes rely on the compositional function only. +- `occ` (the heuristic's `SubtermInfo.usageCount`) vs an independent brute-force walk of the + expanded roots as trees (every shared pointer revisited): 55,390 constants equal and 0 + different. The remaining 1,232 constants have unshared roots above 64 KiB and were not walked. +- Structural checks: every stored table used backward references only (entry `i` refers to + `j < i`), and every root reference was in range. There were 0 expansion errors and 0 + skipped constants. + +## Definitions + +- **Rows** are the distinct constant addresses in `env.consts` (56,622). This is not the + 66,621 names in the file, nor the 65,995 "Total constants" printed by `ix compile`. + Declarations that share an address are measured once. A mutual block is one row, named by + its least projection name with a `[block]` suffix. Projection constants (`iPrj`, `cPrj`, + `rPrj`, `dPrj`; 1,236 rows) have no roots. They appear only in the "all processed" + distribution and the totals. +- **Expansion:** the stored table is expanded left to right. Each `Share j` is replaced by the + single in-memory expansion of entry `j`, so repeated indices reuse one subtree. The + expanded roots are therefore a DAG that is linear in the stored bytes, with no `Share` + leaves. +- **`N`:** the number of distinct subterms of all expanded roots of the constant together, + leaves and whole roots included. It is computed by `Ix.Sharing.analyzeBlock` (the + heuristic's analysis; the trimmed harness keeps a local copy, `analyzeBlock`). +- **`occ(t)`:** `SubtermInfo.usageCount`. `countRootUsages` adds 1 per root occurrence, and + `propagateUsageCounts` then adds each parent's count to each child entry of its `children` + array, in reverse traversal order. That is the number of occurrences of `t` in the fully + expanded forest, counted through every DAG edge with multiplicity, as §4.1 defines `occ`. + The brute-force check above confirms this reading. +- **`size(t)`:** the standalone unshared `putExpr` length of `t`. It is computed on the DAG + with a `Nat` accumulator: + - An App spine of `k` arguments costs `Tag4(k)` plus its head plus its arguments. + - A Lam or All telescope of `k` binders costs `Tag4(k)`, plus one contract byte and the + type for each binder, plus the body. + - Prj, Let and leaves cost their node header (`putNodeHeader`) plus their children. +- **Candidates:** `occ ≥ 2 ∧ size > 1` (R1 and R2 of §4.1). The size > 2 and size > 3 columns + apply stricter size cutoffs to the same set. +- **Unshared bytes:** the complete Constant with an empty sharing table (one `Tag0` byte for + the count), the expanded roots inline, and all other fields unchanged. It is computed as + `rawBytes.size − Tag0(table size) − Σ|stored entry| − Σ|stored root| + 1 + Σ size(root)`. +- **Max telescope length:** the largest `Tag4` count written for any App spine or Lam/All + telescope in the constant. +- **Percentiles** are nearest-rank (`p`-th value is the sorted element at + `⌈p·n/100⌉ − 1`). Means are rounded to two decimals. + +## Caveats + +- **Hash equality is treated as structural equality.** Subterm identity is the blake3 + Merkle hash of `Ix.Sharing.computeNodeHash` (node header bytes plus child hashes), as in + the heuristic sharing pass. The structural keys of §3.2 are not computed and collisions + are not checked. +- Candidate counts apply only R1 and R2. No dominance, decomposition or other reduction has + been applied. The counts measure the set the exact search would face under the reductions + already proved in §4.1. They do not measure DP states, transitions or time, which only + the exact optimizer reports (see the exact uniform-width optimizer follow-up). +- The corpus is `Init` only (Rust-compiled `init.ixe`). `Std`, `Lean` and Mathlib were not + measured. +- For the 7 constants above 16 MiB unshared, the unshared size is compositional and was not + serialized. For the 1,232 constants above 64 KiB, `occ` rests on the code reading plus the + 55,390 checked cases. +- Timings are for this single-threaded harness. They include two hash-consing passes per + constant (one for the measurement and one inside the production rebuild), plus the + validation serializations. They are not optimizer timings. + +## Reproduction + +The harness ran at the commits in the table below. `$S` is any directory holding the +corpus `init.ixe` (195,387,870 bytes, format v3), written by +`lake exe ix compile Benchmarks/CompileInit.lean --out $S/init.ixe` before format v4. The +corpus was not regenerated between runs. A reader accepts only its own format version, +and the harness was later trimmed (see the status note), so these commands need the +development version of the harness used for the tenth run and a v3 corpus; neither is in this +PR (the trimmed harness has no `--no-uniform` or `--uni-max-states`). + +```text +nix develop --command bash -c 'lake build sharing-study' +# -> Build completed successfully. +# Ninth run: everything, including the exact uniform optimizer. +nix develop --command bash -c "lake exe sharing-study $S/init.ixe \ + --md $S/results9.md --csv $S/sharing-minimum-measurements.csv --progress 2500" +# Tenth run: everything except the uniform optimizer. +nix develop --command bash -c "lake exe sharing-study $S/init.ixe --no-uniform \ + --md $S/results10.md --csv $S/sharing-minimum-measurements.csv" +# -> both exit 0; defaults --validate-max 16777216 --occ-check-max 65536, +# --uni-max-states 1048576 +``` + +There were ten full runs. + +| run | measured | harness-internal time | end to end | +|---|---|---|---| +| First | P1.5 only | 146.8 s | about 152 s | +| Second | P1.5 + MSS | 185.2 s | 193.3 s | +| Third | + uniform-width classification (first `payloadMin`) | 316.3 s | 335.0 s | +| Fourth | same, with the corrected `payloadMin` | 379.5 s | 397.6 s | +| Fifth | + Share-width schemes A–C | 199.1 s | 210.0 s | +| Sixth | + scheme D | 210.5 s | 222.0 s | +| Seventh | + scheme E | 237.2 s | 262.0 s | +| Eighth | + schemes F and G | 295.3 s | 315.7 s | +| Ninth (see note) | + exact uniform optimizer, w = 1, 2, 3 | 7,125.3 s, of which 6,875.4 s in the optimizer | 7,140.9 s | +| Tenth | + TagN repricing, `--no-uniform` | 374.7 s | 386.3 s | + +- **Ninth run.** It was built from the tenth run's harness minus the TagN code and the last + six CSV columns, which were added while it ran. Its sections that also appear in the + tenth run are identical apart from the timing lines and the "slowest constants" table + (checked with `diff`). +- **Timings vary with machine load.** The fifth to eighth runs did more work than the + fourth yet took less time, so wall times should not be compared across runs. +- **CSVs.** Both are too large to track; the commands above regenerate them: + - the tenth run's CSV, 13,491,833 bytes, 94 columns (`$S/sharing-minimum-measurements.csv`). + Its `u{w}_*` columns are empty (`--no-uniform`); its `w1m{w}_comp` and `tagn*_change` + columns are new. + - the ninth run's CSV, 16,651,701 bytes, 88 columns, with the uniform columns + (`u{w}_ok, u{w}_us, u{w}_cs, u{w}_ce, u{w}_unc, u{w}_comp, u{w}_states, u{w}_model, + u{w}_real, u{w}_realF, u{w}_table`); it was renamed + `sharing-minimum-measurements-run9.csv` before the tenth run wrote the same path. +- **Earlier CSV columns:** + + ```text + addr (first 16 hex digits), name, kind, members (muts: i/c/r/d counts), roots, N, + occ_ge2, cand, cand_gt2, cand_gt3, table, raw_bytes, unshared_bytes, rebuild_ok, + roundtrip_ok, unshared_validated, occ_checked, max_app, max_lam, max_all, us (harness µs), + mss_bytes, mss_table, mss_ok, mss_cont, mss_cont_p2, mss_cont_p2u, + w1_cs, w1_ce, w1_unc, w1_comp, w2_cs, w2_ce, w2_unc, w2_comp, w3_cs, w3_ce, w3_unc, w3_comp, + refs_lt8, refs_8_255, refs_ge256, + mss_refs_lt8, mss_refs_8_255, mss_refs_ge256, mss_deg_sum, + mss_refs_lt15, mss_refs_15_4110, mss_refs_ge4111, + mss_refs_lt8f, mss_refs_8_1031, mss_refs_ge1032, mss_refs_lt14, mss_refs_14_269, mss_refs_ge270 + ``` + +Rerunning the commands above regenerates both CSVs. + +Metadata study (`--meta` mode). `--meta` and `--meta-crosscheck` existed only in development +versions of the harness, removed before this PR, so these commands need such a version and the +v3 corpora: + +```text +nix develop --command bash -c "lake exe sharing-study $S/init.ixe --meta --meta-crosscheck \ + --progress 0 --md $S/meta-init.md" +# -> exit 0; 57 s end to end, peak RSS 2.25 GB (including the deEnv cross-check) +nix develop --command bash -c "lake exe sharing-study $S/mathlib.ixe --meta \ + --progress 200000 --md $S/meta-mathlib.md" +# -> exit 0; 203 s end to end, peak RSS 4.75 GB; an earlier identical run gave the same output +``` + +With the arena measurements (rerun once the arena tables were added; these are the outputs below): + +```text +nix develop --command bash -c "lake exe sharing-study $S/init.ixe --meta --meta-crosscheck \ + --progress 0 --md $S/meta2-init.md" +# -> exit 0; 43 s end to end, peak RSS 2.26 GB +nix develop --command bash -c "lake exe sharing-study $S/mathlib.ixe --meta \ + --progress 200000 --md $S/meta2-mathlib.md" +# -> exit 0; 529 s end to end, peak RSS 4.74 GB; identical to a run without the +# independent recount apart from the scan time and the recount line +``` + +--- + +The rest of this document is the harness's `--md` output from the tenth run. It is +followed by the uniform-optimizer section of the ninth run's output and by the `--meta` +outputs for Init and Mathlib. All are unedited apart from the corpus paths (written +`$S/…`) and the label of the exact optimizer (written "optimizer"). + +## Results + +- Corpus: `$S/init.ixe` (195387870 bytes), 56622 stored constants (distinct addresses), 66621 names. +- Constants processed: 56622; skipped: 0; with at least one expression root: 55386. +- Harness wall time: load 302 ms, measurement 374353 ms, total 374655 ms. +- Production rebuild (`buildConstantWithSharing` on expanded roots, then `serConstant`) differs from `rawBytes`: **0** constants. +- Decode/encode roundtrip (`serConstant ∘ get`) differs from `rawBytes`: 0 constants. +- Compositional unshared size checked against `serConstant` of the real unshared Constant: 56615 equal, 0 different, 7 not checked (unshared roots > 16777216 bytes). +- `usageCount` (occ) checked against a brute-force walk of the fully expanded roots: 55390 equal, 0 different, 1232 not checked (unshared roots > 65536 bytes). +- Constants whose stored (heuristic) bytes exceed their unshared bytes: 600. +- Total `rawBytes.size`: 80208288; total unshared Constant bytes: 1070001199. + +### Constants whose unshared size was not validated by serialization + +| constant | kind | unshared bytes | stored bytes | +|---|---|---:|---:| +| `WellFounded.partialExtrinsicFix₃_eq_partialExtrinsicFix` | defn | 85713622 | 39575 | +| `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | defn | 45668977 | 170285 | +| `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 32655304 | 154009 | +| `Vector.attach_append` | defn | 31288165 | 20827 | +| `_private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1` | defn | 27720363 | 156535 | +| `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1` | defn | 26030750 | 156976 | +| `_private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1` | defn | 17519911 | 142164 | + +### Distributions over constants with at least one root (55386) + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| `N` (distinct subterms) | 1 | 86 | 470 | 2015 | 27628 | 215.50 | +| `occ ≥ 2` (R1 only) | 0 | 40 | 240 | 1196 | 22467 | 115.78 | +| candidates (R1+R2: occ ≥ 2, size > 1) | 0 | 34 | 232 | 1187 | 22458 | 109.96 | +| candidates with size > 2 | 0 | 29 | 209 | 1138 | 22317 | 100.63 | +| candidates with size > 3 | 0 | 25 | 193 | 1113 | 22224 | 94.42 | +| current table size | 0 | 26 | 203 | 1096 | 22088 | 96.21 | +| `rawBytes.size` | 9 | 693 | 3081 | 11329 | 170285 | 1447.33 | +| unshared Constant bytes | 9 | 781 | 8587 | 193603 | 85713622 | 19318.14 | +| max telescope length | 0 | 6 | 10 | 17 | 95 | 6.59 | +| roots | 1 | 2 | 2 | 2 | 20 | 2.01 | + +### Distributions over all processed constants (56622, projections included) + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| `N` (distinct subterms) | 0 | 83 | 463 | 1994 | 27628 | 210.80 | +| `occ ≥ 2` (R1 only) | 0 | 39 | 236 | 1178 | 22467 | 113.25 | +| candidates (R1+R2: occ ≥ 2, size > 1) | 0 | 33 | 227 | 1169 | 22458 | 107.56 | +| candidates with size > 2 | 0 | 28 | 204 | 1117 | 22317 | 98.43 | +| candidates with size > 3 | 0 | 24 | 189 | 1092 | 22224 | 92.36 | +| current table size | 0 | 25 | 198 | 1075 | 22088 | 94.11 | +| `rawBytes.size` | 9 | 674 | 3043 | 11216 | 170285 | 1416.56 | +| unshared Constant bytes | 9 | 756 | 8290 | 188708 | 85713622 | 18897.27 | +| max telescope length | 0 | 6 | 9 | 17 | 95 | 6.45 | +| roots | 0 | 2 | 2 | 2 | 20 | 1.96 | + +### Candidate-count buckets (R1+R2), constants with at least one root (55386), cumulative + +| candidates | constants | share | +|---|---:|---:| +| ≤ 8 | 9532 | 17.2% | +| ≤ 16 | 16600 | 30.0% | +| ≤ 24 | 22267 | 40.2% | +| ≤ 32 | 26799 | 48.4% | +| ≤ 64 | 37298 | 67.3% | +| ≤ 128 | 45372 | 81.9% | +| > 128 | 10014 | 18.1% | + +### Candidates with size > 3, constants with at least one root, cumulative + +| candidates | constants | share | +|---|---:|---:| +| ≤ 8 | 14105 | 25.5% | +| ≤ 16 | 21566 | 38.9% | +| ≤ 24 | 27435 | 49.5% | +| ≤ 32 | 31682 | 57.2% | +| ≤ 64 | 40729 | 73.5% | +| ≤ 128 | 46981 | 84.8% | +| > 128 | 8405 | 15.2% | + +### Ten constants with the most candidates + +| # | constant | kind | `N` | `occ≥2` | candidates | size>2 | size>3 | table | stored B | unshared B | max telescope | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| 1 | `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | defn | 27628 | 22467 | 22458 | 22317 | 22224 | 22088 | 170285 | 45668977 | 17 | +| 2 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1` | defn | 26943 | 19293 | 19283 | 19198 | 19178 | 19176 | 156535 | 27720363 | 11 | +| 3 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1` | defn | 26754 | 19102 | 19091 | 19005 | 18984 | 18983 | 156976 | 26030750 | 11 | +| 4 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 26494 | 19027 | 19017 | 18932 | 18912 | 18915 | 154009 | 32655304 | 11 | +| 5 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1` | defn | 24658 | 17300 | 17290 | 17201 | 17181 | 17184 | 142164 | 17519911 | 11 | +| 6 | `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1` | defn | 24507 | 17151 | 17140 | 17050 | 17029 | 17031 | 141015 | 16595260 | 11 | +| 7 | `_private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1` | defn | 18802 | 13290 | 13281 | 13193 | 13177 | 13168 | 109553 | 14841104 | 10 | +| 8 | `_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.«0».Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'` | defn | 16156 | 11705 | 11692 | 11643 | 11602 | 11542 | 90971 | 3538954 | 24 | +| 9 | `_private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1` | defn | 19523 | 11465 | 11454 | 11370 | 11349 | 11349 | 104173 | 12235507 | 11 | +| 10 | `_private.Init.Data.Array.Extract.«0».Array.extract_add_left._proof_1_2` | defn | 13362 | 9625 | 9614 | 9530 | 9509 | 9502 | 77260 | 15196324 | 11 | + +### Totals by ConstantInfo kind + +| kind | constants | `rawBytes.size` | unshared bytes | stored/unshared | table entries | candidates | stored > unshared | +|---|---:|---:|---:|---:|---:|---:|---:| +| defn | 54358 | 79781914 | 1069502355 | 7.5% | 5306842 | 6064401 | 567 | +| recr | 500 | 240228 | 301965 | 79.6% | 18237 | 21747 | 29 | +| axio | 13 | 784 | 787 | 99.6% | 9 | 9 | 1 | +| quot | 4 | 311 | 312 | 99.7% | 1 | 1 | 0 | +| muts | 511 | 138609 | 149338 | 92.8% | 3415 | 4357 | 3 | +| iPrj | 501 | 18537 | 18537 | 100.0% | 0 | 0 | 0 | +| cPrj | 710 | 26980 | 26980 | 100.0% | 0 | 0 | 0 | +| rPrj | 3 | 111 | 111 | 100.0% | 0 | 0 | 0 | +| dPrj | 22 | 814 | 814 | 100.0% | 0 | 0 | 0 | +| **all** | 56622 | 80208288 | 1070001199 | 7.5% | 5328504 | 6090515 | 600 | + +### Longest telescopes + +- App spine: 95 (`Lean.Grind.Config.mk.inj`) +- Lam telescope: 95 (`Lean.Grind.Config.mk.noConfusion`) +- All telescope: 95 (`Lean.Grind.Config.mk.noConfusion`) + +### Slowest constants in this harness (all steps above, per constant) + +| constant | kind | ms | `N` | stored B | +|---|---|---:|---:|---:| +| `_private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1` | defn | 1853 | 18802 | 109553 | +| `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 1562 | 26494 | 154009 | +| `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_4` | defn | 1440 | 11095 | 65930 | +| `_private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1` | defn | 1336 | 14521 | 76215 | +| `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_3` | defn | 1315 | 11281 | 67894 | + +## Maximal structural sharing (MSS) + +Rule: store exactly the subterms with compact-DAG indegree `deg ≥ 2` (edges with multiplicity plus root occurrences) and unshared size > 1; every occurrence of a stored term is a Share; order by priority topological order (largest `deg`, then smaller blake3 hash bytes). Built with `Ix.Sharing.buildSharingEntries`/`rewriteExprs`, placed with the production root cursor helpers, serialized with `serConstant`. + +### Witnesses from the plan (§2) + +| fixture | unshared B | heuristic B | MSS B | expected MSS | MSS decode/expand check | MSS bytes | heuristic bytes | +|---|---:|---:|---:|---|---|---|---| +| `T2 → T2` | 20 | 19 | 17 | 17 (plan: exact minimum `d200009117b0b001921700170000000100`) | ok | `d200009117b0b001921700170000000100` | `d200009117b1b10291170000911700b0000100` | +| `T16 → T16` | 78 | 81 | 46 | 46 (plan: feasible improvement) | ok | `d200009117b0b0019810170017001700170017001700170017001700170017001700170017001700170000000100` | `d200009117b80eb80e0f921700170000911700b0911700b1911700b2911700b3911700b4911700b5911700b6911700b7911700b808911700b809911700b80a911700b80b911700b80c911700b80d000100` | +| `A → A → B → B`, `A = Prop → Prop`, `B = Prop → Type` | 28 | 25 | 25 | 25 (plan: minimum, two tied orders) | ok | `d200009317b117b117b0b00291170001911700000002000100` | `d200009317b117b117b0b00291170001911700000002000100` | + +Negative controls for the MSS decode/expand/equality check: + +- `T2 → T2` MSS bytes vs roots `T2 → T2'` (one leaf `Sort 0` replaced by `Sort 1`): behaves as expected +- `T2 → T2` MSS bytes vs roots `T16 → T16`: behaves as expected +- `T2 → T2` MSS bytes vs its own roots (must be accepted): behaves as expected + +### Corpus verification + +- MSS built for 56622 constants; decode, re-encode (byte-identical), table expansion and exact pointer-memoized structural equality of the expanded roots with the original expanded roots: 56622 ok, **0** failed. + +### Totals over the 55386 constants with at least one root + +| encoding | total bytes | vs heuristic | +|---|---:|---:| +| heuristic (stored `rawBytes`) | 80161846 | | +| MSS | 68547873 | -11613973 (−14.5%) | +| unshared | 1069954757 | 989792911 | + +### MSS − heuristic per constant + +| outcome | constants | share | bytes | +|---|---:|---:|---:| +| MSS smaller | 50173 | 90.6% | −11614906 | +| equal | 4994 | 9.0% | 0 | +| MSS larger | 219 | 0.4% | +933 | + +- Losses (MSS − heuristic) over the 219 larger constants: p50 3, p90 8, p99 27, max 50, mean 4.26. +- Savings (heuristic − MSS) over the 50173 smaller constants: p50 53, p90 384, p99 3083, max 65763, mean 231.50. +- Signed Δ = MSS − heuristic over all 55386 rooted constants: min -65763, p1 -2886, p10 -348, p50 -45, p90 -1, p99 0, max 50. +- MSS larger than unshared: 0 constants, total excess 0 bytes, max 0. (Heuristic larger than unshared: 600.) + +### Table sizes (rooted constants) + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| MSS table size | 0 | 12 | 102 | 437 | 5146 | 42.35 | +| heuristic table size | 0 | 26 | 203 | 1096 | 22088 | 96.21 | +| MSS continuation-only entries | 0 | 2 | 25 | 132 | 1950 | 10.25 | +| … with MSS entry payload ≤ 2 | 0 | 0 | 1 | 5 | 16 | 0.41 | +| … with unshared payload ≤ 2 | 0 | 0 | 0 | 0 | 9 | 0.01 | + +- Total MSS entries 2345582; heuristic entries 5328504. +- Continuation-only entries (never a root; every occurrence is the function child of an App for an App term, or the body of a Lam/All for a Lam/All term): 567668 in total; with MSS entry payload ≤ 2: 22588; with unshared payload ≤ 2: 781. +- Constants with at least one continuation-only entry of MSS payload ≤ 2: 11192; of these, MSS larger than heuristic: 41, equal: 39, smaller: 11112. +- Of the 219 constants where MSS is larger, 41 have such an entry; of the 50173 where MSS is smaller, 11112. + +### MSS by ConstantInfo kind (rooted constants) + +| kind | constants | heuristic B | MSS B | unshared B | MSS/heuristic | MSS smaller | equal | MSS larger | +|---|---:|---:|---:|---:|---:|---:|---:|---:| +| defn | 54358 | 79781914 | 68212975 | 1069502355 | 85.5% | 49405 | 4737 | 216 | +| recr | 500 | 240228 | 199955 | 301965 | 83.2% | 494 | 6 | 0 | +| axio | 13 | 784 | 779 | 787 | 99.4% | 3 | 10 | 0 | +| quot | 4 | 311 | 311 | 312 | 100.0% | 0 | 4 | 0 | +| muts | 511 | 138609 | 133853 | 149338 | 96.6% | 271 | 237 | 3 | + +### Ten largest MSS losses (MSS − heuristic) + +| # | constant | kind | heuristic B | MSS B | Δ | unshared B | heuristic table | MSS table | cont. p≤2 | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `Std.Packages.LinearPreorderOfOrdArgs.noConfusionType` | defn | 2469 | 2519 | 50 | 2836 | 57 | 95 | 0 | +| 2 | `Float.exactlyRepresentablePowersOfTen.eq_1` | defn | 1448 | 1479 | 31 | 1663 | 9 | 26 | 0 | +| 3 | `Float.exactlyRepresentablePowersOfTen` | defn | 1332 | 1359 | 27 | 1545 | 8 | 23 | 0 | +| 4 | `Std.Packages.PreorderOfLEArgs.noConfusionType` | defn | 1684 | 1710 | 26 | 1866 | 44 | 72 | 0 | +| 5 | `Lean.Data.AC.Context.noConfusionType` | defn | 623 | 644 | 21 | 683 | 8 | 22 | 0 | +| 6 | `Std.PreorderPackage.noConfusionType` | defn | 556 | 573 | 17 | 612 | 8 | 19 | 0 | +| 7 | `Ix.6f88b4848716a9da0ed22405a07425464335ba158bd5650c013ff4578a796818.Std.Packages.LinearPreorderOfOrdArgs` | muts | 1385 | 1400 | 15 | 1485 | 19 | 33 | 0 | +| 8 | `Lean.Grind.CommRing.Mon.revlexFuel._sunfold` | defn | 919 | 934 | 15 | 938 | 8 | 17 | 0 | +| 9 | `Lean.Grind.CommRing.Mon.revlexFuel._unsafe_rec` | defn | 887 | 902 | 15 | 906 | 8 | 17 | 0 | +| 10 | `Lean.Grind.CommRing.Mon.revlexWF._unsafe_rec` | defn | 760 | 773 | 13 | 777 | 8 | 15 | 0 | + +### Ten largest MSS wins (heuristic − MSS) + +| # | constant | kind | heuristic B | MSS B | Δ | unshared B | heuristic table | MSS table | cont. p≤2 | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | defn | 170285 | 104522 | -65763 | 45668977 | 22088 | 4874 | 0 | +| 2 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1` | defn | 156535 | 104331 | -52204 | 27720363 | 19176 | 5136 | 0 | +| 3 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1` | defn | 156976 | 105389 | -51587 | 26030750 | 18983 | 5146 | 0 | +| 4 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 154009 | 102666 | -51343 | 32655304 | 18915 | 4919 | 0 | +| 5 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1` | defn | 142164 | 97145 | -45019 | 17519911 | 17184 | 4703 | 0 | +| 6 | `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1` | defn | 141015 | 96716 | -44299 | 16595260 | 17031 | 4678 | 0 | +| 7 | `_private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1` | defn | 109553 | 72208 | -37345 | 14841104 | 13168 | 3236 | 0 | +| 8 | `_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.«0».Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'` | defn | 90971 | 53900 | -37071 | 3538954 | 11542 | 2712 | 1 | +| 9 | `_private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1` | defn | 104173 | 76309 | -27864 | 12235507 | 11349 | 3640 | 0 | +| 10 | `String.Slice.Pattern.Model.LawfulToBackwardSearcherModel.defaultImplementation` | defn | 70419 | 43015 | -27404 | 4186174 | 9332 | 2407 | 1 | + +## Uniform-reference-width classification + +Candidates are the subterms with compact `deg ≥ 2` and unshared size > 1 (the MSS stored set). For `w ∈ {1, 2, 3}` each candidate is CERTAIN-STORED if `g(deg, headdeg, payloadMin) > 0`, CERTAIN-EXCLUDED if `g(occ, occ, payloadMax) < 0` or it is a leaf with `(occ−1)·size < occ·w`, and UNCERTAIN otherwise, where `g(n, H, b) = (n−1)·b + (H−1)·hdr − n·w`. `payloadMin` is the width-aware recursive lower bound (a candidate child costs at most `w`, a non-candidate child its own recursive minimum; continuation children without their header). `headdeg` treats only an App in App-function position and a Lam/All in same-kind body position as continuations. Uncertain nodes are in one component when a directed DAG path whose intermediate nodes are not certain-stored joins them (transitively). Arithmetic is exact; `occ` is not capped. + +- Classification errors: 0. +- Witnesses (cs/ce/unc/largest component for w = 1 | 2 | 3): + - `T2 → T2`: 1/0/0/0 | 1/0/0/0 | 0/0/1/1 (candidates 1) + - `T16 → T16`: 1/0/0/0 | 1/0/0/0 | 1/0/0/0 (candidates 1) + - `A → A → B → B`: 2/0/0/0 | 0/0/2/1 | 0/2/0/0 (candidates 2) +- Candidates over the 55386 rooted constants: 2345582 (MSS table entries: 2345582). + +### w = 1 + +- Totals: certain-stored 1887527 (80.5% of candidates), certain-excluded 0 (0.0%), uncertain 458055 (19.5%); nodes meeting both certain conditions 0; candidates with `payloadMin > payloadMax` 0; candidates whose class changes when every function-child occurrence counts as a non-head 100. +- Largest component recomputed by the literal brute force (DAGs with ≤ 1000 nodes): 53652 equal, **0** different, 1734 not checked. + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| certain-stored | 0 | 10 | 81 | 341 | 4211 | 34.08 | +| certain-excluded | 0 | 0 | 0 | 0 | 0 | 0.00 | +| uncertain | 0 | 2 | 21 | 95 | 970 | 8.27 | +| largest uncertain component | 0 | 1 | 2 | 4 | 45 | 1.06 | + +| bucket | constants by `uncertain` | share | constants by largest component | share | +|---|---:|---:|---:|---:| +| = 0 | 13486 | 24.3% | 13486 | 24.3% | +| ≤ 8 | 43174 | 78.0% | 55332 | 99.9% | +| ≤ 16 | 48357 | 87.3% | 55382 | 100.0% | +| ≤ 32 | 52353 | 94.5% | 55384 | 100.0% | +| > 32 | 3033 | 5.5% | 2 | 0.0% | +| > 128 | 332 | 0.6% | 0 | 0.0% | +| > 1024 | 0 | 0.0% | 0 | 0.0% | + +Ten constants with the largest uncertain component (w = 1): + +| # | constant | kind | `N` | candidates | certain-stored | certain-excluded | uncertain | largest component | +|---:|---|---|---:|---:|---:|---:|---:|---:| +| 1 | `Lean.Grind.Config.mk.injEq` | defn | 3512 | 360 | 236 | 0 | 124 | 45 | +| 2 | `_private.Init.Data.String.Decode.«0».UInt8.utf8ByteSize_eq_utf8ByteSize_parseFirstByte` | defn | 1056 | 296 | 192 | 0 | 104 | 35 | +| 3 | `Lean.Meta.Simp.Config.mk.injEq` | defn | 1994 | 256 | 164 | 0 | 92 | 31 | +| 4 | `_private.Init.Data.BitVec.Bitblast.«0».BitVec.addRecAux_cpopTree._unary` | defn | 2614 | 594 | 471 | 0 | 123 | 17 | +| 5 | `_private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1` | defn | 19523 | 3640 | 3062 | 0 | 578 | 16 | +| 6 | `_private.Init.Data.Nat.Internal.SOM.«0».Nat.Internal.SOM.Poly.add_denote.go` | defn | 1474 | 340 | 224 | 0 | 116 | 16 | +| 7 | `Lean.Meta.DSimp.Config.mk.injEq` | defn | 746 | 126 | 82 | 0 | 44 | 15 | +| 8 | `Std.IterM.toArray_map_mapM` | defn | 2933 | 432 | 326 | 0 | 106 | 15 | +| 9 | `Std.IterM.toList_map` | defn | 2506 | 404 | 314 | 0 | 90 | 15 | +| 10 | `Std.IterM.toList_mapM_mapM` | defn | 2891 | 413 | 312 | 0 | 101 | 15 | + +### w = 2 + +- Totals: certain-stored 1504278 (64.1% of candidates), certain-excluded 349863 (14.9%), uncertain 491441 (21.0%); nodes meeting both certain conditions 0; candidates with `payloadMin > payloadMax` 0; candidates whose class changes when every function-child occurrence counts as a non-head 100. +- Largest component recomputed by the literal brute force (DAGs with ≤ 1000 nodes): 53652 equal, **0** different, 1734 not checked. + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| certain-stored | 0 | 6 | 63 | 315 | 4455 | 27.16 | +| certain-excluded | 0 | 3 | 17 | 46 | 135 | 6.32 | +| uncertain | 0 | 3 | 22 | 84 | 736 | 8.87 | +| largest uncertain component | 0 | 1 | 3 | 5 | 44 | 1.51 | + +| bucket | constants by `uncertain` | share | constants by largest component | share | +|---|---:|---:|---:|---:| +| = 0 | 11593 | 20.9% | 11593 | 20.9% | +| ≤ 8 | 39615 | 71.5% | 55328 | 99.9% | +| ≤ 16 | 47353 | 85.5% | 55384 | 100.0% | +| ≤ 32 | 52492 | 94.8% | 55385 | 100.0% | +| > 32 | 2894 | 5.2% | 1 | 0.0% | +| > 128 | 213 | 0.4% | 0 | 0.0% | +| > 1024 | 0 | 0.0% | 0 | 0.0% | + +Ten constants with the largest uncertain component (w = 2): + +| # | constant | kind | `N` | candidates | certain-stored | certain-excluded | uncertain | largest component | +|---:|---|---|---:|---:|---:|---:|---:|---:| +| 1 | `Lean.Grind.Config.mk.injEq` | defn | 3512 | 360 | 148 | 91 | 121 | 44 | +| 2 | `Lean.Meta.Simp.Config.mk.injEq` | defn | 1994 | 256 | 103 | 64 | 89 | 30 | +| 3 | `List.min_findIdx_findIdx` | defn | 932 | 234 | 135 | 22 | 77 | 15 | +| 4 | `Array.getD_getElem?` | defn | 359 | 76 | 41 | 9 | 26 | 14 | +| 5 | `Lean.Meta.DSimp.Config.mk.injEq` | defn | 746 | 126 | 53 | 31 | 42 | 14 | +| 6 | `List.getD_getElem?` | defn | 359 | 76 | 41 | 9 | 26 | 14 | +| 7 | `Vector.getD_getElem?` | defn | 392 | 77 | 50 | 8 | 19 | 14 | +| 8 | `Lean.Grind.AC.imp_eq` | defn | 130 | 30 | 10 | 5 | 15 | 13 | +| 9 | `Lean.Grind.AC.eq_simp_lhs_exact` | defn | 130 | 31 | 13 | 4 | 14 | 12 | +| 10 | `_private.Init.Data.Nat.Internal.SOM.«0».Nat.Internal.SOM.Poly.add_denote.go` | defn | 1474 | 340 | 182 | 44 | 114 | 12 | + +### w = 3 + +- Totals: certain-stored 1276154 (54.4% of candidates), certain-excluded 570132 (24.3%), uncertain 499296 (21.3%); nodes meeting both certain conditions 0; candidates with `payloadMin > payloadMax` 0; candidates whose class changes when every function-child occurrence counts as a non-head 92. +- Largest component recomputed by the literal brute force (DAGs with ≤ 1000 nodes): 53652 equal, **0** different, 1734 not checked. + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| certain-stored | 0 | 4 | 53 | 286 | 4392 | 23.04 | +| certain-excluded | 0 | 5 | 27 | 60 | 229 | 10.29 | +| uncertain | 0 | 2 | 22 | 98 | 978 | 9.01 | +| largest uncertain component | 0 | 1 | 3 | 6 | 44 | 1.37 | + +| bucket | constants by `uncertain` | share | constants by largest component | share | +|---|---:|---:|---:|---:| +| = 0 | 14878 | 26.9% | 14878 | 26.9% | +| ≤ 8 | 40386 | 72.9% | 55228 | 99.7% | +| ≤ 16 | 47612 | 86.0% | 55378 | 100.0% | +| ≤ 32 | 52174 | 94.2% | 55385 | 100.0% | +| > 32 | 3212 | 5.8% | 1 | 0.0% | +| > 128 | 318 | 0.6% | 0 | 0.0% | +| > 1024 | 0 | 0.0% | 0 | 0.0% | + +Ten constants with the largest uncertain component (w = 3): + +| # | constant | kind | `N` | candidates | certain-stored | certain-excluded | uncertain | largest component | +|---:|---|---|---:|---:|---:|---:|---:|---:| +| 1 | `Lean.Grind.Config.mk.injEq` | defn | 3512 | 360 | 145 | 92 | 123 | 44 | +| 2 | `_private.Init.Data.String.Decode.«0».UInt8.utf8ByteSize_eq_utf8ByteSize_parseFirstByte` | defn | 1056 | 296 | 154 | 42 | 100 | 31 | +| 3 | `Lean.Meta.Simp.Config.mk.injEq` | defn | 1994 | 256 | 100 | 65 | 91 | 30 | +| 4 | `BitVec.getMsbD_setWidth` | defn | 1044 | 258 | 125 | 44 | 89 | 20 | +| 5 | `Lean.Grind.imp_eq` | defn | 249 | 56 | 19 | 11 | 26 | 19 | +| 6 | `_private.Init.Data.Order.PackageFactories.«0».Std.FactoryInstances.isGE_compare` | defn | 405 | 105 | 27 | 28 | 50 | 19 | +| 7 | `_private.Init.Data.Order.PackageFactories.«0».Std.FactoryInstances.isLE_compare` | defn | 359 | 99 | 27 | 24 | 48 | 19 | +| 8 | `BitVec.msb_neg` | defn | 1541 | 378 | 202 | 61 | 115 | 18 | +| 9 | `Std.LinearPreorderPackage.ofOrd._proof_1` | defn | 567 | 143 | 54 | 32 | 57 | 16 | +| 10 | `Std.LinearPreorderPackage.ofOrd._proof_9` | defn | 401 | 96 | 41 | 23 | 32 | 16 | + +### Reference-width loss in the current stored encoding + +Share references counted syntactically in the stored roots and stored table entries of every constant (current heuristic encoding). The largest stored table has 22088 entries, so every index ≥ 256 is 3 bytes. + +| stored table entries | constants | refs to 0–7 (1 B) | refs to 8–255 (2 B) | refs to ≥ 256 (3 B) | loss under the uniform width | +|---|---:|---:|---:|---:|---| +| 1–8 | 11367 | 119925 | 0 | 0 | (not requested; 119925 if these cost 2 B) | +| 9–255 | 37610 | 776978 | 3298554 | 0 | w = 2: **776978** bytes | +| > 255 | 4335 | 202727 | 2795056 | 3328853 | w = 3: 2·202727 + 2795056 = **3200510** bytes | + +- Total stored bytes over all constants: 80208288; total Share references: 10522093. + +## Share-width schemes on the MSS encoding + +Every occurrence of an MSS entry is a Share. Scheme A: the current tiers by index in MSS order (1 byte below index 8, 2 below 256, 3 below 65536). Scheme B: one width per constant, 2 bytes if the MSS entry count (= candidate count) is ≤ 2048, else 3. Scheme C: as B, but 1 byte if the count is ≤ 8. Scheme D: one width per constant using the tag byte's whole low nibble: 1 byte if the count is ≤ 16, 2 if ≤ 4096, else 3. Scheme E: position tiers with a nibble escape, by index in MSS order: 1 byte below index 15, 2 below 15 + 4096, else 3 (as specified; not realizable with a 4-bit Share flag). Scheme F: realizable position tiers with two marker bits: 1 byte below index 8, 2 below 8 + 1024, else 3. Scheme G: realizable position tiers with nibble values 14 and 15 as escapes: 1 byte below index 14, 2 below 14 + 256, else 3. Constant bytes under a scheme are MSS bytes − refbytes(A) + refbytes(scheme). Share nodes are counted on the materialized MSS encoding. + +- Share nodes in the MSS encoding vs `Σ deg` over MSS entries: 55386 equal, **0** different. +- Share nodes counted in the scheme-F and scheme-G index buckets vs the scheme-A buckets: 55386 equal totals, **0** different. +- Share nodes counted in the scheme-E index buckets vs the scheme-A buckets: 55386 equal totals, **0** different. +- Rooted constants: 55386; Share references in their MSS encodings: 9297007; constants with more than 2048 MSS entries (width 3 under B and C): 20; with at most 8 entries (width 1 under C): 22270. + +| scheme | reference bytes | MSS constant bytes | Δ vs A | Δ / MSS total (A) | Δ / heuristic total | +|---|---:|---:|---:|---:|---:| +| A (index tiers) | 17568850 | 68547873 | 0 | +0.00% | +0.00% | +| B (2 or 3 per constant) | 18990396 | 69969419 | 1421546 | +2.07% | +1.77% | +| C (1, 2 or 3 per constant) | 18724875 | 69703898 | 1156025 | +1.69% | +1.44% | +| D (nibble: ≤ 16 / ≤ 4096 / more) | 18207733 | 69186756 | 638883 | +0.93% | +0.80% | +| E (index tiers < 15 / < 4111 / more) | 15442797 | 66421820 | -2126053 | −3.10% | −2.65% | +| F (index tiers < 8 / < 1032 / more) | 16577564 | 67556587 | -991286 | −1.45% | −1.24% | +| G (index tiers < 14 / < 270 / more) | 16741559 | 67720582 | -827291 | −1.21% | −1.03% | + +Totals for reference: MSS bytes (scheme A, the real encoding) 68547873; heuristic stored bytes 80161846. + +| comparison | better (fewer bytes) | equal | worse | +|---|---:|---:|---:| +| B vs A | 829 | 555 | 54002 | +| C vs A | 829 | 22271 | 32286 | +| D vs A | 9773 | 22271 | 23342 | +| E vs A | 33116 | 22270 | 0 | +| F vs A | 1352 | 54034 | 0 | +| G vs A | 33116 | 22270 | 0 | + +Width classes under D: 1 byte (≤ 16 entries) 31200 constants, 2 bytes (17–4096) 24180, 3 bytes (> 4096) 6. + +### Ten largest losses under B (B − A) + +| # | constant | kind | MSS entries | Share refs | refs < 8 / 8–255 / ≥ 256 | A ref bytes | B ref bytes | Δ (B − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `_private.Init.Data.Nat.ToString.«0».Nat.digitChar_iff_aux` | defn | 2763 | 20215 | 4736 / 7802 / 7677 | 43371 | 60645 | 17274 | 52808 | +| 2 | `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | defn | 4874 | 29452 | 2013 / 9356 / 18083 | 74974 | 88356 | 13382 | 104522 | +| 3 | `_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.«0».Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'` | defn | 2712 | 16793 | 1838 / 6999 / 7956 | 39704 | 50379 | 10675 | 53900 | +| 4 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1` | defn | 5136 | 31580 | 744 / 6448 / 24388 | 86804 | 94740 | 7936 | 104331 | +| 5 | `_private.Init.Data.Range.Polymorphic.RangeIterator.«0».Std.Rxc.Iterator.instIteratorLoop.loopWf_eq._unary` | defn | 2382 | 12573 | 1123 / 5400 / 6050 | 30073 | 37719 | 7646 | 44156 | +| 6 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 4919 | 31007 | 660 / 6168 / 24179 | 85533 | 93021 | 7488 | 102666 | +| 7 | `_private.Init.Data.Range.Polymorphic.RangeIterator.«0».Std.Rxo.Iterator.instIteratorLoop.loopWf_eq._unary` | defn | 2398 | 12299 | 1096 / 5199 / 6004 | 29506 | 36897 | 7391 | 43251 | +| 8 | `_private.Init.Data.Array.Lemmas.«0».Array.toList_reverse.go._unary` | defn | 2769 | 13884 | 1934 / 3454 / 8496 | 34330 | 41652 | 7322 | 50884 | +| 9 | `_private.Init.Data.String.Pattern.String.«0».String.Slice.Pattern.ForwardSliceSearcher.finitenessRelation._proof_2` | defn | 2327 | 12439 | 1216 / 4588 / 6635 | 30297 | 37317 | 7020 | 46275 | +| 10 | `String.Slice.Pattern.Model.LawfulToBackwardSearcherModel.defaultImplementation` | defn | 2407 | 11882 | 1133 / 4231 / 6518 | 29149 | 35646 | 6497 | 43015 | + +### Ten largest gains under B (A − B) + +| # | constant | kind | MSS entries | Share refs | refs < 8 / 8–255 / ≥ 256 | A ref bytes | B ref bytes | Δ (B − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_reverse._proof_1` | defn | 1908 | 10516 | 314 / 2309 / 7893 | 28611 | 21032 | -7579 | 36602 | +| 2 | `_private.Init.Data.Array.Lemmas.«0».Array.toList_extract._proof_1_1` | defn | 1786 | 9846 | 278 / 2487 / 7081 | 26495 | 19692 | -6803 | 34199 | +| 3 | `_private.Init.Data.Int.LemmasAux.«0».Int.max_min_distrib_left._proof_1_1` | defn | 1815 | 9731 | 433 / 2122 / 7176 | 26205 | 19462 | -6743 | 33682 | +| 4 | `_private.Init.Data.Nat.Lemmas.«0».Nat.sub_max_sub_left._proof_1_1` | defn | 1884 | 10582 | 610 / 2725 / 7247 | 27801 | 21164 | -6637 | 35895 | +| 5 | `_private.Init.Data.BitVec.Lemmas.«0».BitVec.getMsbD_extractLsb._proof_1_4` | defn | 1702 | 9256 | 290 / 2070 / 6896 | 25118 | 18512 | -6606 | 32947 | +| 6 | `_private.Init.Data.Int.LemmasAux.«0».Int.max_min_distrib_right._proof_1_1` | defn | 1760 | 9274 | 397 / 1956 / 6921 | 25072 | 18548 | -6524 | 32445 | +| 7 | `_private.Init.Data.Nat.Lemmas.«0».Nat.sub_min_sub_left._proof_1_1` | defn | 1816 | 9973 | 579 / 2589 / 6805 | 26172 | 19946 | -6226 | 34020 | +| 8 | `_private.Init.Data.Int.LemmasAux.«0».Int.min_max_distrib_left._proof_1_1` | defn | 1716 | 9026 | 425 / 1982 / 6619 | 24246 | 18052 | -6194 | 31434 | +| 9 | `_private.Init.Data.Int.LemmasAux.«0».Int.min_max_distrib_right._proof_1_1` | defn | 1687 | 8897 | 649 / 1765 / 6483 | 23628 | 17794 | -5834 | 30809 | +| 10 | `_private.Init.Data.Array.Extract.«0».Array.extract_reverse._proof_1_2` | defn | 1670 | 8901 | 313 / 2504 / 6084 | 23573 | 17802 | -5771 | 31386 | + +### B − A restricted to constants whose current heuristic table exceeds 255 entries + +- Constants: 4335; their MSS bytes 25359218, heuristic bytes 33341195; MSS entries: min 44, max 5146; with more than 2048 MSS entries: 20. +- Reference bytes: A 11525602, B 11441534; Δ (B − A) -84068 (−0.33% of their MSS bytes, −0.25% of their heuristic bytes). +- B vs A: better 829, equal 1, worse 3505. + +### Ten largest losses under D (D − A) + +| # | constant | kind | MSS entries | Share refs | refs < 8 / 8–255 / ≥ 256 | A ref bytes | D ref bytes | Δ (D − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | defn | 4874 | 29452 | 2013 / 9356 / 18083 | 74974 | 88356 | 13382 | 104522 | +| 2 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1` | defn | 5136 | 31580 | 744 / 6448 / 24388 | 86804 | 94740 | 7936 | 104331 | +| 3 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 4919 | 31007 | 660 / 6168 / 24179 | 85533 | 93021 | 7488 | 102666 | +| 4 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1` | defn | 5146 | 31423 | 750 / 4863 / 25810 | 87906 | 94269 | 6363 | 105389 | +| 5 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1` | defn | 4703 | 28903 | 640 / 4587 / 23676 | 80842 | 86709 | 5867 | 97145 | +| 6 | `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1` | defn | 4678 | 28730 | 643 / 4441 / 23646 | 80463 | 86190 | 5727 | 96716 | +| 7 | `_private.Init.Data.Nat.ToString.«0».Nat.digitChar_ne.match_1_1` | defn | 199 | 3103 | 1072 / 2031 / 0 | 5134 | 6206 | 1072 | 9309 | +| 8 | `_private.Init.Data.Iterators.Combinators.Monadic.FilterMap.«0».Std.Iterators.Types.Map.instProductivenessRelation._proof_2` | defn | 166 | 1262 | 528 / 734 / 0 | 1996 | 2524 | 528 | 4797 | +| 9 | `_private.Init.Meta.Defs.«0».Lean.Name.beq.match_1.eq_4` | defn | 163 | 1182 | 517 / 665 / 0 | 1847 | 2364 | 517 | 3772 | +| 10 | `Std.IterM.step_filterMapM` | defn | 362 | 2232 | 720 / 1279 / 233 | 3977 | 4464 | 487 | 7713 | + +### Ten largest gains under D (A − D) + +| # | constant | kind | MSS entries | Share refs | refs < 8 / 8–255 / ≥ 256 | A ref bytes | D ref bytes | Δ (D − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `_private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1` | defn | 3640 | 22811 | 497 / 4776 / 17538 | 62663 | 45622 | -17041 | 76309 | +| 2 | `_private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1` | defn | 3236 | 21512 | 1001 / 4190 / 16321 | 58344 | 43024 | -15320 | 72208 | +| 3 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1` | defn | 2854 | 16989 | 431 / 3532 / 13026 | 46573 | 33978 | -12595 | 57498 | +| 4 | `_private.Init.Data.Array.Extract.«0».Array.extract_add_left._proof_1_2` | defn | 2717 | 15681 | 452 / 4450 / 10779 | 41689 | 31362 | -10327 | 52203 | +| 5 | `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_3` | defn | 2477 | 13376 | 397 / 2928 / 10051 | 36406 | 26752 | -9654 | 46372 | +| 6 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_4` | defn | 2294 | 13015 | 373 / 2645 / 9997 | 35654 | 26030 | -9624 | 45467 | +| 7 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_reverse._proof_1` | defn | 1908 | 10516 | 314 / 2309 / 7893 | 28611 | 21032 | -7579 | 36602 | +| 8 | `_private.Init.Data.Array.Lemmas.«0».Array.toList_extract._proof_1_1` | defn | 1786 | 9846 | 278 / 2487 / 7081 | 26495 | 19692 | -6803 | 34199 | +| 9 | `_private.Init.Data.Int.LemmasAux.«0».Int.max_min_distrib_left._proof_1_1` | defn | 1815 | 9731 | 433 / 2122 / 7176 | 26205 | 19462 | -6743 | 33682 | +| 10 | `_private.Init.Data.Nat.Lemmas.«0».Nat.sub_max_sub_left._proof_1_1` | defn | 1884 | 10582 | 610 / 2725 / 7247 | 27801 | 21164 | -6637 | 35895 | + +### Ten largest losses under E (E − A) + +| # | constant | kind | MSS entries | Share refs | refs < 15 / 15–4110 / ≥ 4111 | A ref bytes | E ref bytes | Δ (E − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `Acc.brecOn` | defn | 8 | 22 | 22 / 0 / 0 | 22 | 22 | 0 | 298 | +| 2 | `Acc.casesOn` | defn | 6 | 14 | 14 / 0 / 0 | 14 | 14 | 0 | 233 | +| 3 | `Acc.inv` | defn | 6 | 15 | 15 / 0 / 0 | 15 | 15 | 0 | 200 | +| 4 | `Acc.inv_of_transGen` | defn | 8 | 16 | 16 / 0 / 0 | 16 | 16 | 0 | 294 | +| 5 | `Acc.ndrec` | defn | 5 | 11 | 11 / 0 / 0 | 11 | 11 | 0 | 174 | +| 6 | `Acc.ndrec.eq_1` | defn | 7 | 15 | 15 / 0 / 0 | 15 | 15 | 0 | 293 | +| 7 | `Acc.ndrecC` | defn | 5 | 11 | 11 / 0 / 0 | 11 | 11 | 0 | 174 | +| 8 | `Acc.ndrecC.eq_1` | defn | 7 | 15 | 15 / 0 / 0 | 15 | 15 | 0 | 293 | +| 9 | `Acc.ndrecOn` | defn | 5 | 11 | 11 / 0 / 0 | 11 | 11 | 0 | 174 | +| 10 | `Acc.ndrecOn.eq_1` | defn | 7 | 15 | 15 / 0 / 0 | 15 | 15 | 0 | 293 | + +### Ten largest gains under E (A − E) + +| # | constant | kind | MSS entries | Share refs | refs < 15 / 15–4110 / ≥ 4111 | A ref bytes | E ref bytes | Δ (E − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1` | defn | 5146 | 31423 | 957 / 26083 / 4383 | 87906 | 66272 | -21634 | 105389 | +| 2 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1` | defn | 4703 | 28903 | 838 / 25762 / 2303 | 80842 | 59271 | -21571 | 97145 | +| 3 | `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1` | defn | 4678 | 28730 | 827 / 25505 / 2398 | 80463 | 59031 | -21432 | 96716 | +| 4 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 4919 | 31007 | 823 / 27107 / 3077 | 85533 | 64268 | -21265 | 102666 | +| 5 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1` | defn | 5136 | 31580 | 982 / 26789 / 3809 | 86804 | 65987 | -20817 | 104331 | +| 6 | `_private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1` | defn | 3640 | 22811 | 1812 / 20999 / 0 | 62663 | 43810 | -18853 | 76309 | +| 7 | `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | defn | 4874 | 29452 | 2977 / 24384 / 2091 | 74974 | 58018 | -16956 | 104522 | +| 8 | `_private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1` | defn | 3236 | 21512 | 1342 / 20170 / 0 | 58344 | 41682 | -16662 | 72208 | +| 9 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1` | defn | 2854 | 16989 | 1587 / 15402 / 0 | 46573 | 32391 | -14182 | 57498 | +| 10 | `_private.Init.Data.Array.Extract.«0».Array.extract_add_left._proof_1_2` | defn | 2717 | 15681 | 1299 / 14382 / 0 | 41689 | 30063 | -11626 | 52203 | + +### Scheme F vs A + +- Constants worse than A under F: **0**; largest per-constant Δ (F − A): 0. + +Ten largest gains under F (A − F): + +| # | constant | kind | MSS entries | Share refs | refs < 8 / 8–1031 / ≥ 1032 | A ref bytes | F ref bytes | Δ (F − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1` | defn | 5146 | 31423 | 750 / 11353 / 19320 | 87906 | 81416 | -6490 | 105389 | +| 2 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 4919 | 31007 | 660 / 12447 / 17900 | 85533 | 79254 | -6279 | 102666 | +| 3 | `_private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1` | defn | 3236 | 21512 | 1001 / 10398 / 10113 | 58344 | 52136 | -6208 | 72208 | +| 4 | `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | defn | 4874 | 29452 | 2013 / 15285 / 12154 | 74974 | 69045 | -5929 | 104522 | +| 5 | `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1` | defn | 4678 | 28730 | 643 / 10243 / 17844 | 80463 | 74661 | -5802 | 96716 | +| 6 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1` | defn | 5136 | 31580 | 744 / 11862 / 18974 | 86804 | 81390 | -5414 | 104331 | +| 7 | `_private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1` | defn | 3640 | 22811 | 497 / 9707 / 12607 | 62663 | 57732 | -4931 | 76309 | +| 8 | `_private.Init.Data.Int.LemmasAux.«0».Int.max_min_distrib_left._proof_1_1` | defn | 1815 | 9731 | 433 / 6942 / 2356 | 26205 | 21385 | -4820 | 33682 | +| 9 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1` | defn | 2854 | 16989 | 431 / 8267 / 8291 | 46573 | 41838 | -4735 | 57498 | +| 10 | `_private.Init.Data.Int.LemmasAux.«0».Int.min_max_distrib_left._proof_1_1` | defn | 1716 | 9026 | 425 / 6476 / 2125 | 24246 | 19752 | -4494 | 31434 | + +### Scheme G vs A + +- Constants worse than A under G: **0**; largest per-constant Δ (G − A): 0. + +Ten largest gains under G (A − G): + +| # | constant | kind | MSS entries | Share refs | refs < 14 / 14–269 / ≥ 270 | A ref bytes | G ref bytes | Δ (G − A) | MSS bytes (A) | +|---:|---|---|---:|---:|---|---:|---:|---:|---:| +| 1 | `_private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1` | defn | 3640 | 22811 | 1794 / 4035 / 16982 | 62663 | 60810 | -1853 | 76309 | +| 2 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_reverse._proof_1` | defn | 1908 | 10516 | 956 / 2290 / 7270 | 28611 | 27346 | -1265 | 36602 | +| 3 | `_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.«0».Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'` | defn | 2712 | 16793 | 2900 / 6021 / 7872 | 39704 | 38558 | -1146 | 53900 | +| 4 | `_private.Init.Data.BitVec.Lemmas.«0».BitVec.getMsbD_extractLsb._proof_1_3` | defn | 1337 | 7253 | 780 / 2335 / 4138 | 18989 | 17864 | -1125 | 25704 | +| 5 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1` | defn | 2854 | 16989 | 1469 / 2543 / 12977 | 46573 | 45486 | -1087 | 57498 | +| 6 | `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | defn | 4874 | 29452 | 2855 / 8698 / 17899 | 74974 | 73948 | -1026 | 104522 | +| 7 | `Std.Iter.step_flatMapAfterM` | defn | 1858 | 10970 | 2832 / 3106 / 5032 | 25141 | 24140 | -1001 | 35912 | +| 8 | `_private.Init.Data.Nat.ToString.«0».Nat.digitChar_iff_aux` | defn | 2763 | 20215 | 5628 / 6980 / 7607 | 43371 | 42409 | -962 | 52808 | +| 9 | `Std.IterM.toList_filterMapM_map` | defn | 1820 | 10539 | 2537 / 3265 / 4737 | 24198 | 23278 | -920 | 33661 | +| 10 | `Std.IterM.anyM_filterMapM` | defn | 1519 | 9132 | 2192 / 3289 / 3651 | 20559 | 19723 | -836 | 30148 | + +### D − A restricted to constants whose current heuristic table exceeds 255 entries + +- Constants: 4335; width classes under D: 1 byte 0, 2 bytes 4329, 3 bytes 6. +- Reference bytes: A 11525602, D 11226247; Δ (D − A) -299355 (−1.18% of their MSS bytes, −0.90% of their heuristic bytes). +- D vs A: better 843, equal 1, worse 3491. + +## Integer repricing: TagN, TagN-byte and the Tag2 variant + +The stored (heuristic) encoding of every constant is walked exactly as `putConstant`/`putExpr`/`putUniv` write it, and every integer is priced under the current codes (`tag4EncodedSize`, `tag0EncodedSize`, `putTag2`) and under TagN (replacing every `Tag4`: 1 byte below 8, 2 below 8 + 1024, 3 below 1032 + 65536, 5 below that + 2^32, 9 beyond), TagN-byte (replacing every `Tag0`: 1 byte below 128, 2 below 128 + 16384, 3 below 16512 + 65536, 5 below that + 2^32, 9 beyond) and the Tag2 variant of TagN (replacing every `Tag2`: 1 byte below 32, 2 below 32 + 4096, 3 below 4128 + 65536, 5 below that + 2^32, 9 beyond). + +- Walker check: integer bytes + other bytes = `rawBytes.size` for 56622 of 56622 constants (**0** different). +- Stored bytes: 80208288. `Tag4` integers: 22822097 (36407507 bytes). `Tag0` integers: 3486829 (3504738 bytes). `Tag2` integers: 234690 (234690 bytes). Other bytes: 40061353. +- TagN alone: 34361119 bytes for the `Tag4` integers, change -2046388 (−2.55% of stored bytes; gained 2046388, lost 0). +- TagN-byte alone: 3500360 bytes for the `Tag0` integers, change -4378 (−0.01%; gained 4378, lost 0). +- Tag2 variant alone: 234690 bytes for the `Tag2` integers, change 0 (+0.00%; gained 0, lost 0). +- TagN and TagN-byte together: change -2050766 (−2.56%). All three: change -2050766 (−2.56% of stored bytes). + +| field class | integers | current bytes | repriced bytes | change | bytes gained | bytes lost | +|---|---:|---:|---:|---:|---:|---:| +| Share indices (Tag4) | 10522093 | 23273409 | 21227235 | -2046174 | 2046174 | 0 | +| Var indices (Tag4) | 2680768 | 3394656 | 3394656 | 0 | 0 | 0 | +| Sort levels (Tag4) | 201291 | 201493 | 201493 | 0 | 0 | 0 | +| App argument counts (Tag4) | 6335600 | 6365386 | 6365386 | 0 | 0 | 0 | +| Lam/All binder counts (Tag4) | 620821 | 632681 | 632681 | 0 | 0 | 0 | +| Ref/Recur universe-list lengths (Tag4) | 2254605 | 2254605 | 2254605 | 0 | 0 | 0 | +| Prj fields (Tag4) | 6914 | 7010 | 7010 | 0 | 0 | 0 | +| Str/Nat indices (Tag4) | 124859 | 203121 | 202907 | -214 | 214 | 0 | +| Let flags (Tag4) | 18524 | 18524 | 18524 | 0 | 0 | 0 | +| ConstantInfo header: variant / mutual member count (Tag4) | 56622 | 56622 | 56622 | 0 | 0 | 0 | +| Ref/Recur indices (Tag0) | 2254605 | 2259158 | 2259110 | -48 | 48 | 0 | +| Ref/Recur universe indices (Tag0) | 990526 | 990526 | 990526 | 0 | 0 | 0 | +| Prj type indices (Tag0) | 6914 | 6914 | 6914 | 0 | 0 | 0 | +| table counts: sharing, refs, univs (Tag0) | 169866 | 183222 | 178892 | -4330 | 4330 | 0 | +| ConstantInfo scalar fields: lvls, params, indices, motives, minors, rule fields and counts, constructor counts and fields, cidx, projection idx (Tag0) | 64918 | 64918 | 64918 | 0 | 0 | 0 | +| universe terms: zero/succ-chain, max, imax, var headers (Tag2) | 234690 | 234690 | 234690 | 0 | 0 | 0 | + +Integers by width (bytes), per tag family, now and repriced: + +| width | `Tag4` now | TagN | `Tag0` now | TagN-byte | `Tag2` now | Tag2 variant | +|---:|---:|---:|---:|---:|---:|---:| +| 1 | 12565754 | 12565754 | 3473304 | 3473304 | 234690 | 234690 | +| 2 | 6927276 | 8973664 | 9141 | 13519 | 0 | 0 | +| 3 | 3329067 | 1282679 | 4384 | 6 | 0 | 0 | +| 4 | 0 | 0 | 0 | 0 | 0 | 0 | +| 5 | 0 | 0 | 0 | 0 | 0 | 0 | +| 6 | 0 | 0 | 0 | 0 | 0 | 0 | +| 7 | 0 | 0 | 0 | 0 | 0 | 0 | +| 8 | 0 | 0 | 0 | 0 | 0 | 0 | +| 9 | 0 | 0 | 0 | 0 | 0 | 0 | + +--- + +Uniform-optimizer section of the ninth run's harness output: + +## Exact uniform-width optimizer on the corpus + +Every rooted constant, w = 1, 2, 3: `Ix.Sharing.Exact.optimizeSharingUniformTable w c.sharing (constantInfoRoots c.info) limits` with maxStates 1048576, maxCostEvals 1073741824, maxNodes 1048576, maxDepth 16384, maxExprVisits 67108864, maxMaterialize 67108864, maxOutputBytes 268435456 (optimizer defaults except maxStates). Output roots are placed with the production cursor helpers and serialized with `serConstant` (current Tag4 tiers); the bytes are decoded, re-encoded, expanded and compared exactly with the original expanded roots. Model length = fixed bytes + `modelBytes`; real = serialized size; F = the same table and roots with scheme F Share widths. Wall time is the optimizer call only. + +### w = 1 + +- Certified: **55294** of 55386; failures: **92**. + - `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576`: 90 + - `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.costEvals) 1073741824`: 2 + - `_private.Init.Data.Vector.Extract.«0».Vector.extract_push._proof_1` (N 4007, 12804 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.String.Iterate.«0».String.Slice.ByteIterator.finitenessRelation._proof_1` (N 1231, 22521 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.BitVec.Bitblast.«0».BitVec.addRecAux_eq_of._proof_1_23` (N 2728, 31625 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.Vector.Extract.«0».Vector.extract_append_left._proof_1` (N 2955, 10988 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.Nat.Lemmas.«0».Nat.sub_add_sub_cancel._proof_1_1` (N 2183, 34483 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `BitVec.srem_zero_of_dvd` (N 852, 34022 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.Range.Polymorphic.IntLemmas.«0».Int.size_rco._proof_1_1` (N 2537, 15576 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.Range.Polymorphic.Nat.«0».Std.instLawfulRcoIntersectionNat_4._proof_1` (N 1412, 21473 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_4` (N 11095, 12024 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.BitVec.Lemmas.«0».BitVec.toInt_allOnes._proof_1_2` (N 2438, 50360 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` +- Output checks on certified constants: real length = fixed + `variableBytes` for 55294; decode/re-encode/expand/exact equality ok for 55294, **0** failed; optimizer distinct subterms = this harness's `N` for 55294; class counts and components equal to this harness's reimplementation of the optimizer's definitions for 55294, **0** different. +- Classes (optimizer, certified): certain-stored 1441164, certain-excluded 5759148, uncertain 851426, low degree 3655922; components 595302; lower count bracket chosen in 35 constants. + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| largest uncertain component (optimizer) | 0 | 2 | 5 | 12 | 21 | 2.50 | +| search states | 0 | 16 | 229 | 9864 | 1044855 | 1128.67 | +| uniform table size | 0 | 10 | 81 | 337 | 4280 | 33.89 | +| optimizer wall time (µs), all runs | 5 | 249 | 2964 | 182154 | 108188764 | 66835.26 | + +Totals over the 55294 certified constants: + +| encoding | total bytes | vs heuristic | vs MSS | +|---|---:|---:|---:| +| heuristic (stored) | 78855708 | 0 (+0.00%) | 11292360 (+16.71%) | +| MSS (current tiers) | 67563348 | -11292360 (−14.32%) | 0 (+0.00%) | +| uniform w = 1, real (current tiers) | 66737821 | -12117887 (−15.37%) | -825527 (−1.22%) | +| uniform w = 1, scheme F widths | 66047771 | -12807937 (−16.24%) | -1515577 (−2.24%) | +| uniform w = 1, model length | 59469841 | -19385867 (−24.58%) | -8093507 (−11.98%) | +| unshared | 987599557 | 908743849 (+1152.41%) | 920036209 (+1361.74%) | + +Uniform w = 1 (real) vs MSS per constant: better 31245, equal 23833, worse 216. Gains p50 10, p90 39, max 2670; losses p50 1, p90 4, max 46. Versus the heuristic: better 50302, equal 4938, worse 54. + +Ten largest gains of uniform w = 1 over MSS: + +| # | constant | kind | heuristic B | MSS B | uniform real B | Δ (uniform − MSS) | uniform table | MSS table | largest comp. | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1` | defn | 156976 | 105389 | 102719 | -2670 | 4247 | 5146 | 12 | +| 2 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_reverse._proof_1` | defn | 51942 | 36602 | 35026 | -1576 | 1553 | 1908 | 20 | +| 3 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1` | defn | 156535 | 104331 | 102877 | -1454 | 4280 | 5136 | 12 | +| 4 | `_private.Init.Data.Array.Extract.«0».Array.extract_reverse._proof_1_2` | defn | 45291 | 31386 | 29943 | -1443 | 1284 | 1670 | 13 | +| 5 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 154009 | 102666 | 101274 | -1392 | 4127 | 4919 | 9 | +| 6 | `_private.Init.Data.Int.LemmasAux.«0».Int.max_min_distrib_left._proof_1_1` | defn | 41952 | 33682 | 32406 | -1276 | 1476 | 1815 | 14 | +| 7 | `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | defn | 170285 | 104522 | 103264 | -1258 | 4076 | 4874 | 8 | +| 8 | `_private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1` | defn | 109553 | 72208 | 70982 | -1226 | 2782 | 3236 | 13 | +| 9 | `_private.Init.Data.BitVec.Bitblast.«0».BitVec.ssubOverflow_eq._proof_1_4` | defn | 40104 | 29919 | 28701 | -1218 | 1244 | 1549 | 12 | +| 10 | `_private.Init.Data.Int.LemmasAux.«0».Int.max_min_distrib_right._proof_1_1` | defn | 38651 | 32445 | 31227 | -1218 | 1412 | 1760 | 16 | + +Ten largest losses of uniform w = 1 against MSS: + +| # | constant | kind | heuristic B | MSS B | uniform real B | Δ (uniform − MSS) | uniform table | MSS table | largest comp. | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `Lean.Meta.Simp.Config.mk.inj` | defn | 2789 | 1984 | 2030 | 46 | 130 | 133 | 1 | +| 2 | `_private.Init.Data.BitVec.Bitblast.«0».BitVec.addRecAux_eq_of._proof_1_16` | defn | 12097 | 8654 | 8670 | 16 | 334 | 377 | 7 | +| 3 | `instLawfulMonadAttachStateTOfLawfulMonad` | defn | 5055 | 3843 | 3854 | 11 | 149 | 178 | 5 | +| 4 | `Nat.pow_mod` | defn | 1771 | 1522 | 1531 | 9 | 42 | 56 | 5 | +| 5 | `Std.Iter.anyM_filterM` | defn | 3984 | 2904 | 2912 | 8 | 97 | 102 | 4 | +| 6 | `Std.Iter.toArray_map` | defn | 1970 | 1679 | 1687 | 8 | 38 | 40 | 2 | +| 7 | `Vector.mapIdx_setIfInBounds` | defn | 1614 | 1305 | 1313 | 8 | 41 | 43 | 4 | +| 8 | `Vector.map_reverse` | defn | 1456 | 1251 | 1259 | 8 | 36 | 38 | 4 | +| 9 | `StateT.run_controlAt` | defn | 2429 | 2026 | 2033 | 7 | 49 | 56 | 3 | +| 10 | `Std.IterM.all_filterM` | defn | 3293 | 2569 | 2575 | 6 | 61 | 63 | 1 | + +### w = 2 + +- Certified: **55358** of 55386; failures: **28**. + - `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576`: 26 + - `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.costEvals) 1073741824`: 2 + - `Nat.Internal.Linear.ExprCnstr.denote_toNormPoly` (N 525, 27236 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.Range.Polymorphic.IntLemmas.«0».Int.size_rco._proof_1_1` (N 2537, 10828 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `List.min_findIdx_findIdx` (N 932, 23713 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `List.cons_append_cons_perm` (N 226, 21623 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `List.zip_eq_append_iff` (N 439, 17922 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `Lean.Grind.Ring.OfSemiring.instOrderedRingQOfLawfulOrderLTOfExistsAddOfLT` (N 3608, 25207 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `Array.zip_eq_append_iff` (N 439, 18000 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `Std.LinearPreorderPackage.ofOrd._proof_9` (N 401, 27134 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.Array.Extract.«0».Array.push_extract_getElem._proof_1_1` (N 5459, 13407 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `Int.fdiv_eq_ediv` (N 1262, 33021 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` +- Output checks on certified constants: real length = fixed + `variableBytes` for 55358; decode/re-encode/expand/exact equality ok for 55358, **0** failed; optimizer distinct subterms = this harness's `N` for 55358; class counts and components equal to this harness's reimplementation of the optimizer's definitions for 55358, **0** different. +- Classes (optimizer, certified): certain-stored 1216713, certain-excluded 6417329, uncertain 766911, low degree 3473646; components 537949; lower count bracket chosen in 37 constants. + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| largest uncertain component (optimizer) | 0 | 2 | 5 | 10 | 20 | 2.24 | +| search states | 0 | 15 | 171 | 3293 | 776614 | 483.15 | +| uniform table size | 0 | 7 | 66 | 321 | 4474 | 27.97 | +| optimizer wall time (µs), all runs | 2 | 210 | 2517 | 47081 | 98799418 | 21681.45 | + +Totals over the 55358 certified constants: + +| encoding | total bytes | vs heuristic | vs MSS | +|---|---:|---:|---:| +| heuristic (stored) | 79830766 | 0 (+0.00%) | 11532808 (+16.89%) | +| MSS (current tiers) | 68297958 | -11532808 (−14.45%) | 0 (+0.00%) | +| uniform w = 2, real (current tiers) | 67593621 | -12237145 (−15.33%) | -704337 (−1.03%) | +| uniform w = 2, scheme F widths | 66954321 | -12876445 (−16.13%) | -1343637 (−1.97%) | +| uniform w = 2, model length | 68379047 | -11451719 (−14.34%) | 81089 (+0.12%) | +| unshared | 1038467344 | 958636578 (+1200.84%) | 970169386 (+1420.50%) | + +Uniform w = 2 (real) vs MSS per constant: better 21751, equal 6098, worse 27509. Gains p50 14, p90 61, max 5252; losses p50 5, p90 14, max 929. Versus the heuristic: better 46968, equal 3003, worse 5387. + +Ten largest gains of uniform w = 2 over MSS: + +| # | constant | kind | heuristic B | MSS B | uniform real B | Δ (uniform − MSS) | uniform table | MSS table | largest comp. | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1` | defn | 156976 | 105389 | 100137 | -5252 | 4454 | 5146 | 12 | +| 2 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1` | defn | 142164 | 97145 | 92057 | -5088 | 4143 | 4703 | 9 | +| 3 | `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1` | defn | 141015 | 96716 | 91977 | -4739 | 4107 | 4678 | 9 | +| 4 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 154009 | 102666 | 98554 | -4112 | 4303 | 4919 | 9 | +| 5 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1` | defn | 156535 | 104331 | 100241 | -4090 | 4474 | 5136 | 12 | +| 6 | `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | defn | 170285 | 104522 | 100736 | -3786 | 4067 | 4874 | 6 | +| 7 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_4` | defn | 65930 | 45467 | 42134 | -3333 | 1883 | 2294 | 10 | +| 8 | `_private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1` | defn | 109553 | 72208 | 69075 | -3133 | 2793 | 3236 | 7 | +| 9 | `_private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1` | defn | 104173 | 76309 | 73308 | -3001 | 3135 | 3640 | 15 | +| 10 | `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_3` | defn | 67894 | 46372 | 43458 | -2914 | 2012 | 2477 | 10 | + +Ten largest losses of uniform w = 2 against MSS: + +| # | constant | kind | heuristic B | MSS B | uniform real B | Δ (uniform − MSS) | uniform table | MSS table | largest comp. | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `Std.Iter.step_flatMapAfterM` | defn | 62751 | 35912 | 36841 | 929 | 1634 | 1858 | 6 | +| 2 | `Std.IterM.toList_filterMapM_map` | defn | 56179 | 33661 | 34571 | 910 | 1623 | 1820 | 5 | +| 3 | `_private.Init.Data.Nat.ToString.«0».Nat.digitChar_iff_aux` | defn | 72333 | 52808 | 53537 | 729 | 2163 | 2763 | 2 | +| 4 | `_private.Init.Data.Nat.ToString.«0».Nat.digitChar_ne.match_1_1` | defn | 16798 | 9309 | 9913 | 604 | 163 | 199 | 15 | +| 5 | `_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.«0».Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'` | defn | 90971 | 53900 | 54484 | 584 | 2411 | 2712 | 5 | +| 6 | `Std.IterM.toList_mapM_eq_toList_filterMapM` | defn | 40698 | 25402 | 25922 | 520 | 1228 | 1396 | 7 | +| 7 | `Std.IterM.step_mapWithPostcondition` | defn | 15716 | 8652 | 9163 | 511 | 348 | 413 | 6 | +| 8 | `Std.IterM.step_filterMapWithPostcondition` | defn | 13584 | 8208 | 8711 | 503 | 368 | 419 | 3 | +| 9 | `Std.IterM.toList_map_eq_toList_mapM` | defn | 33801 | 21867 | 22363 | 496 | 1086 | 1233 | 9 | +| 10 | `Std.IterM.step_mapM` | defn | 17607 | 9869 | 10357 | 488 | 414 | 492 | 5 | + +### w = 3 + +- Certified: **55338** of 55386; failures: **48**. + - `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576`: 46 + - `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.costEvals) 1073741824`: 2 + - `List.findIdx?_eq_some_iff_findIdx_eq` (N 1175, 27030 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `Std._aux_Init_Data_Slice_Notation___macroRules_term__[_]_1` (N 797, 35854 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `Lean.Grind.Linarith.diseq_split` (N 699, 14031 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `Lean.Grind.not_eq_prop` (N 278, 31494 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.Range.Polymorphic.IntLemmas.«0».Int.size_rco._proof_1_1` (N 2537, 10632 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `List.min_findIdx_findIdx` (N 932, 25713 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `Std.IterM.DefaultConsumers.forIn'_eq_forIn'._unary` (N 4675, 45419 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `List.eraseP_comm` (N 764, 38566 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `Lean.Grind.imp_eq` (N 249, 21377 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` + - `_private.Init.Data.Nat.Internal.SOM.«0».Nat.Internal.SOM.Mon.mul_denote.go` (N 1034, 35324 ms): `Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576` +- Output checks on certified constants: real length = fixed + `variableBytes` for 55338; decode/re-encode/expand/exact equality ok for 55338, **0** failed; optimizer distinct subterms = this harness's `N` for 55338; class counts and components equal to this harness's reimplementation of the optimizer's definitions for 55338, **0** different. +- Classes (optimizer, certified): certain-stored 1091768, certain-excluded 6903959, uncertain 672738, low degree 3209123; components 478828; lower count bracket chosen in 30 constants. + +| Metric | min | median | p90 | p99 | max | mean | +|---|---:|---:|---:|---:|---:|---:| +| largest uncertain component (optimizer) | 0 | 1 | 5 | 11 | 20 | 2.08 | +| search states | 0 | 9 | 171 | 3680 | 1040448 | 582.86 | +| uniform table size | 0 | 5 | 55 | 293 | 4427 | 23.82 | +| optimizer wall time (µs), all runs | 2 | 179 | 2578 | 58856 | 103226807 | 35617.10 | + +Totals over the 55338 certified constants: + +| encoding | total bytes | vs heuristic | vs MSS | +|---|---:|---:|---:| +| heuristic (stored) | 79849102 | 0 (+0.00%) | 11547818 (+16.91%) | +| MSS (current tiers) | 68301284 | -11547818 (−14.46%) | 0 (+0.00%) | +| uniform w = 3, real (current tiers) | 68216736 | -11632366 (−14.57%) | -84548 (−0.12%) | +| uniform w = 3, scheme F widths | 67644231 | -12204871 (−15.28%) | -657053 (−0.96%) | +| uniform w = 3, model length | 74603766 | -5245336 (−6.57%) | 6302482 (+9.23%) | +| unshared | 1061642946 | 981793844 (+1229.56%) | 993341662 (+1454.35%) | + +Uniform w = 3 (real) vs MSS per constant: better 12687, equal 3526, worse 39125. Gains p50 14, p90 75, max 5398; losses p50 9, p90 29, max 1523. Versus the heuristic: better 43719, equal 2683, worse 8936. + +Ten largest gains of uniform w = 3 over MSS: + +| # | constant | kind | heuristic B | MSS B | uniform real B | Δ (uniform − MSS) | uniform table | MSS table | largest comp. | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1` | defn | 142164 | 97145 | 91747 | -5398 | 4097 | 4703 | 9 | +| 2 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1` | defn | 156976 | 105389 | 100158 | -5231 | 4403 | 5146 | 13 | +| 3 | `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1` | defn | 141015 | 96716 | 91536 | -5180 | 4059 | 4678 | 9 | +| 4 | `_private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_4` | defn | 65930 | 45467 | 41250 | -4217 | 1840 | 2294 | 10 | +| 5 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1` | defn | 156535 | 104331 | 100152 | -4179 | 4427 | 5136 | 13 | +| 6 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1` | defn | 154009 | 102666 | 98600 | -4066 | 4279 | 4919 | 7 | +| 7 | `_private.Init.Data.BitVec.Lemmas.«0».BitVec.getMsbD_extractLsb._proof_1_4` | defn | 48987 | 32947 | 29427 | -3520 | 1346 | 1702 | 20 | +| 8 | `_private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_3` | defn | 67894 | 46372 | 42946 | -3426 | 1967 | 2477 | 10 | +| 9 | `_private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1` | defn | 76215 | 57498 | 54434 | -3064 | 2464 | 2854 | 14 | +| 10 | `_private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1` | defn | 104173 | 76309 | 73358 | -2951 | 3121 | 3640 | 7 | + +Ten largest losses of uniform w = 3 against MSS: + +| # | constant | kind | heuristic B | MSS B | uniform real B | Δ (uniform − MSS) | uniform table | MSS table | largest comp. | +|---:|---|---|---:|---:|---:|---:|---:|---:|---:| +| 1 | `Std.Iter.step_flatMapAfterM` | defn | 62751 | 35912 | 37435 | 1523 | 1552 | 1858 | 6 | +| 2 | `Std.Iter.step_flatMapAfter` | defn | 34745 | 22093 | 23338 | 1245 | 993 | 1225 | 12 | +| 3 | `Std.IterM.toList_filterMapM_map` | defn | 56179 | 33661 | 34857 | 1196 | 1535 | 1820 | 3 | +| 4 | `_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.«0».Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'` | defn | 90971 | 53900 | 54948 | 1048 | 2312 | 2712 | 5 | +| 5 | `Std.IterM.toList_filterMapWithPostcondition` | defn | 31006 | 20058 | 20928 | 870 | 878 | 1078 | 6 | +| 6 | `Std.Iter.step_filterMap` | defn | 35128 | 22728 | 23584 | 856 | 1024 | 1279 | 9 | +| 7 | `Std.IterM.toList_mapWithPostcondition` | defn | 25948 | 16960 | 17681 | 721 | 745 | 939 | 4 | +| 8 | `Std.IterM.toList_mapM_eq_toList_filterMapM` | defn | 40698 | 25402 | 26087 | 685 | 1139 | 1396 | 7 | +| 9 | `Std.IterM.toList_map_eq_toList_mapM` | defn | 33801 | 21867 | 22516 | 649 | 1026 | 1233 | 6 | +| 10 | `_private.Init.Data.Nat.ToString.«0».Nat.digitChar_ne.match_1_1` | defn | 16798 | 9309 | 9947 | 638 | 141 | 199 | 15 | + +### Ten slowest optimizer runs (of 166158) + +| # | constant | w | ms | certified | `N` | largest comp. | states | error | +|---:|---|---:|---:|---|---:|---:|---:|---| +| 1 | `Lean.Grind.Config.mk.injEq` | 1 | 108188 | false | 3512 | 0 | 0 | Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.costEvals) 1073741824 | +| 2 | `Lean.Grind.Config.mk.injEq` | 3 | 103226 | false | 3512 | 0 | 0 | Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.costEvals) 1073741824 | +| 3 | `Lean.Grind.Config.mk.injEq` | 2 | 98799 | false | 3512 | 0 | 0 | Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.costEvals) 1073741824 | +| 4 | `Lean.Meta.Simp.Config.mk.injEq` | 2 | 90260 | false | 1994 | 0 | 0 | Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.costEvals) 1073741824 | +| 5 | `Lean.Meta.Simp.Config.mk.injEq` | 1 | 87968 | false | 1994 | 0 | 0 | Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.costEvals) 1073741824 | +| 6 | `Lean.Meta.Simp.Config.mk.injEq` | 3 | 82698 | false | 1994 | 0 | 0 | Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.costEvals) 1073741824 | +| 7 | `_private.Init.Data.Array.Extract.«0».Array.mem_extract_iff_getElem._proof_1_3` | 1 | 62649 | false | 3876 | 0 | 0 | Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576 | +| 8 | `_private.Init.Data.BitVec.Bitblast.«0».BitVec.addRecAux_eq_of._proof_1_21` | 1 | 57389 | false | 2298 | 0 | 0 | Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576 | +| 9 | `Nat.Internal.Linear.Poly.denote_eq_cancelAux` | 1 | 55674 | false | 2804 | 0 | 0 | Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576 | +| 10 | `_private.Init.Data.Int.LemmasAux.«0».Int.max_assoc._proof_1_1` | 1 | 51317 | false | 5794 | 0 | 0 | Ix.Sharing.Exact.SharingError.resourceExhausted (Ix.Sharing.Exact.Resource.states) 1048576 | + +Total optimizer wall time over all runs: 6875358 ms. + +### Lower-bound gap: real lengths minus the w = 1 model optimum + +Over the 55263 rooted constants certified at w = 1, 2 and 3. Σ model(w = 1) = 59370988. + +| encoding (current tiers) | Σ bytes | Σ (bytes − model w=1) | % of Σ model | constants below the model | +|---|---:|---:|---:|---:| +| heuristic (stored) | 78696174 | 19325186 | +32.55% | 0 | +| MSS | 67438618 | 8067630 | +13.59% | 0 | +| uniform w = 1 output | 66615107 | 7244119 | +12.20% | 0 | +| uniform w = 2 output | 66778657 | 7407669 | +12.48% | 0 | +| uniform w = 3 output | 67406916 | 8035928 | +13.54% | 0 | +| best of the above, per constant | 66331917 | 6960929 | +11.72% | 0 | + +### Optimizer classes vs this harness's own classification (corrected `payloadMin`) + +Totals over the constants certified at all three widths. The definitions differ (see the hand-written section), so equality is not expected. + +| w | own certain-stored | optimizer certain-stored | own certain-excluded (candidates) | optimizer certain-excluded (all terms) | own uncertain | optimizer uncertain | own max component | optimizer max component | +|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| 1 | 1842180 | 1437377 | 0 | 5748024 | 444030 | 848833 | 16 | 21 | +| 2 | 1460911 | 1189917 | 344992 | 6340304 | 480307 | 751301 | 14 | 20 | +| 3 | 1235457 | 1063687 | 563890 | 6827490 | 486863 | 658633 | 19 | 20 | + +--- + +Metadata study output (`--meta`) for Init: + +## Metadata study: `$S/init.ixe` + +- File: 195387870 bytes; blobs 26836; anonymous constants 56622; names 344786; Named entries 66621 (2000 with `original`); comms 0. Scan time 32875 ms. +- Byte categories sum to 195387870 bytes: **equal to the file size**. +- Cross-check against a full `Ixon.deEnv` load: named 66621 vs 66621, blobs 26836 vs 26836, constants 56622 vs 56622, non-empty metaSharing 0 vs 0, metaSharing entries 0 vs 0, metaSharing expression bytes (`serExpr`) 0 vs 0, metaRefs 0 vs 0, metaUnivs 2363 vs 2363, entries with `original` 2000 vs 2000, original metaSharing entries 0 vs 0: **all equal**. + +| component | bytes | % of file | +|---|---:|---:| +| header: version, consts Merkle root, main, assumptions | 35 | 0.00% | +| §1 blobs: count, addresses, length prefixes | 885986 | 0.45% | +| §1 blobs: payload | 1948624 | 1.00% | +| §2 constants: count, addresses, length prefixes | 1971518 | 1.01% | +| §2 constants: bodies (the anonymous constants) | 80208288 | 41.05% | +| §3 anonymous hints | 108763 | 0.06% | +| §4 names: count and addresses | 11033156 | 5.65% | +| §4 names: components (tag, parent address, string/number bytes) | 13621793 | 6.97% | +| §5 Named: count, name and constant keys | 460240 | 0.24% | +| §5 Named: per-name hints | 66621 | 0.03% | +| §5 Named: metadata blob length prefixes | 161358 | 0.08% | +| §5 ConstantMeta info (variant fields, name indices, root indices) | 1379169 | 0.71% | +| §5 ExprMeta arena | 82418893 | 42.18% | +| §5 metaSharing expressions (with count) | 66621 | 0.03% | +| §5 metaRefs (with count) | 66621 | 0.03% | +| §5 metaUnivs (with count) | 80359 | 0.04% | +| §5 univPatches (with count) | 84608 | 0.04% | +| §5 original: tag and address | 130621 | 0.07% | +| §5 original ConstantMeta info | 54031 | 0.03% | +| §5 original ExprMeta arena | 631426 | 0.32% | +| §5 original metaSharing expressions | 2000 | 0.00% | +| §5 original metaRefs | 2000 | 0.00% | +| §5 original metaUnivs | 2324 | 0.00% | +| §5 original univPatches | 2814 | 0.00% | +| §6 comms | 1 | 0.00% | + +- Section totals: §2 constants 82179806 (42.06%); §5 Named 85609706 (43.82%); §4 names 24654949 (12.62%); §1 blobs 2834610 (1.45%). + +ExprMeta arena by node kind (primary metadata; `original` metadata in the last two columns): + +| node kind | nodes | bytes | % of file | original nodes | original bytes | +|---|---:|---:|---:|---:|---:| +| leaf | 505548 | 505548 | 0.26% | 18649 | 18649 | +| app | 13111962 | 66602568 | 34.09% | 81026 | 270371 | +| binder | 1184509 | 8547545 | 4.37% | 41186 | 272337 | +| letBinder | 18979 | 199890 | 0.10% | 480 | 4055 | +| ref | 1340653 | 6265979 | 3.21% | 14117 | 63294 | +| prj | 5879 | 35254 | 0.02% | 63 | 315 | +| mdata | 12445 | 159222 | 0.08% | 5 | 52 | +| callSite | 0 | 0 | 0.00% | 0 | 0 | +| etaCallSite | 0 | 0 | 0.00% | 0 | 0 | + +### metaSharing + +- Named entries with non-empty `metaSharing`: 0 of 66621; with non-empty `original` metaSharing: 0. Entries per non-empty table: min 0, median 0, p90 0, p99 0, max 0. +- metaRefs entries: 0; metaUnivs entries: 2363. +- Analysis errors (constants not analysed): 0. + +| metadata | constants | entries | current bytes | unshared bytes | re-encoded against the primary table | distinct entries | current, deduplicated | re-encoded, deduplicated | entries equal to a primary subterm | equal to a primary table entry | Share nodes in entries | +|---|---:|---:|---|---:|---:|---:|---:|---:|---|---:|---:| +| primary `ConstantMeta` | 0 | 0 | 0 (0.00% of file) | 0 | 0 | 0 | 0 | 0 | 0 (0 B) | 0 | 0 | +| `Named.original` | 0 | 0 | 0 (0.00% of file) | 0 | 0 | 0 | 0 | 0 | 0 (0 B) | 0 | 0 | + +### ExprMeta arena structure: child deltas and duplication + +- Arenas: 67995 (2000 of them in `original` metadata); nodes 16335501; node bytes 82945079 (42.45% of the file; the per-arena count prefixes are not included). Children that do not point strictly backward (any slot): 0. +- Node bytes equal the per-kind arena bytes above (82945079): **yes**. + +Child deltas (parent index − child index) per child slot, and the child-field bytes today (`Tag0` of the absolute index) and as backward deltas with TagN-byte widths: + +| slot | children | Δ = 1 | 2–7 | 8–127 | 128–1023 | 1024–16383 | ≥ 16384 | not backward | bytes today | delta bytes | change | change, % of file | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| App function | 13192988 | 6716161 | 2198301 | 2233893 | 1297239 | 692238 | 55156 | 0 | 28639979 | 15292289 | -13347690 | −6.83% | +| App argument | 13192988 | 4137489 | 505150 | 3261280 | 3520080 | 1647312 | 121677 | 0 | 25039972 | 18602695 | -6437277 | −3.29% | +| Binder type | 1225695 | 30202 | 111850 | 654997 | 328127 | 98743 | 1776 | 0 | 1739233 | 1656053 | -83180 | −0.04% | +| Binder body | 1225695 | 1128360 | 8574 | 43903 | 32571 | 12223 | 64 | 0 | 2245843 | 1270616 | -975227 | −0.50% | +| Let type | 19459 | 45 | 857 | 6473 | 9437 | 2423 | 224 | 0 | 33938 | 31766 | -2172 | −0.00% | +| Let value | 19459 | 504 | 654 | 8468 | 8396 | 1354 | 83 | 0 | 38599 | 29374 | -9225 | −0.00% | +| Let body | 19459 | 18276 | 128 | 465 | 430 | 160 | 0 | 0 | 48176 | 20049 | -28127 | −0.01% | +| Prj child | 5942 | 3182 | 347 | 1287 | 1002 | 124 | 0 | 0 | 10907 | 7068 | -3839 | −0.00% | +| Mdata child | 12450 | 10660 | 343 | 944 | 451 | 52 | 0 | 0 | 26662 | 12953 | -13709 | −0.01% | +| **all slots** | 28914135 | 12044879 | 2826204 | 6211710 | 5197733 | 2454629 | 178980 | 0 | 57823309 | 36922863 | -20900446 | −10.70% | +| App slots only | 26385976 | 10853650 | 2703451 | 5495173 | 4817319 | 2339550 | 176833 | 0 | 53679951 | 33894984 | -19784967 | −10.13% | + +- Children that are exactly the immediately preceding node (Δ = 1): 12044879 of 28914135 (41.66%); App children: 10853650 of 26385976. + +Duplication within each arena (bottom-up hash-consing on kind, payload and canonical child IDs; a duplicate is a node whose canonical ID occurred earlier in the same arena): + +| nodes | total | duplicates | duplicate bytes | % of file | maximal duplicate subtrees | duplicate nodes in them | bytes in them | % of file | +|---|---:|---:|---:|---:|---:|---:|---:|---:| +| all kinds | 16335501 | 7348183 | 37063057 | 18.97% | 1490676 | 7348183 | 37063057 | 18.97% | +| App nodes (subtrees rooted at an App) | 13192988 | 6610293 | 34390613 | 17.60% | 1293632 | 6319823 | 31940216 | 16.35% | + +- Distinct nodes per arena summed: 8987318 of 16335501 (55.02%); distinct App nodes: 6582695 of 13192988. +- Maximal duplicate subtree sizes (duplicate nodes): 1: 570319, 2–7: 751744, 8–63: 158973, 64–1023: 9590, ≥ 1024: 50. +- Independent check on arenas of at most 256 nodes (duplicates recounted by comparing full subtree strings): agree for 52699 arenas, **differ for 0**; 15296 arenas not checked (more than 256 nodes, or a subtree string over 100,000 characters). +- Split: primary arenas 16179975 nodes, 7294537 duplicates (36903588 B); `original` arenas 155526 nodes, 53646 duplicates (159469 B). + +--- + +Metadata study output (`--meta`) for Mathlib: + +## Metadata study: `$S/mathlib.ixe` + +- File: 3343271273 bytes; blobs 341233; anonymous constants 679499; names 4811656; Named entries 778344 (22265 with `original`); comms 0. Scan time 520978 ms. +- Byte categories sum to 3343271273 bytes: **equal to the file size**. + +| component | bytes | % of file | +|---|---:|---:| +| header: version, consts Merkle root, main, assumptions | 35 | 0.00% | +| §1 blobs: count, addresses, length prefixes | 11264011 | 0.34% | +| §1 blobs: payload | 15945558 | 0.48% | +| §2 constants: count, addresses, length prefixes | 23697505 | 0.71% | +| §2 constants: bodies (the anonymous constants) | 1468890902 | 43.94% | +| §3 anonymous hints | 1304352 | 0.04% | +| §4 names: count and addresses | 153972996 | 4.61% | +| §4 names: components (tag, parent address, string/number bytes) | 190199903 | 5.69% | +| §5 Named: count, name and constant keys | 6146192 | 0.18% | +| §5 Named: per-name hints | 778344 | 0.02% | +| §5 Named: metadata blob length prefixes | 2063780 | 0.06% | +| §5 ConstantMeta info (variant fields, name indices, root indices) | 19467468 | 0.58% | +| §5 ExprMeta arena | 1419908472 | 42.47% | +| §5 metaSharing expressions (with count) | 821273 | 0.02% | +| §5 metaRefs (with count) | 778344 | 0.02% | +| §5 metaUnivs (with count) | 3185897 | 0.10% | +| §5 univPatches (with count) | 5842782 | 0.17% | +| §5 original: tag and address | 1490824 | 0.04% | +| §5 original ConstantMeta info | 649300 | 0.02% | +| §5 original ExprMeta arena | 16702816 | 0.50% | +| §5 original metaSharing expressions | 22265 | 0.00% | +| §5 original metaRefs | 22265 | 0.00% | +| §5 original metaUnivs | 49569 | 0.00% | +| §5 original univPatches | 66419 | 0.00% | +| §6 comms | 1 | 0.00% | + +- Section totals: §2 constants 1492588407 (44.64%); §5 Named 1477996010 (44.21%); §4 names 344172899 (10.29%); §1 blobs 27209569 (0.81%). + +ExprMeta arena by node kind (primary metadata; `original` metadata in the last two columns): + +| node kind | nodes | bytes | % of file | original nodes | original bytes | +|---|---:|---:|---:|---:|---:| +| leaf | 8211930 | 8211930 | 0.25% | 252288 | 252288 | +| app | 219151448 | 1153185700 | 34.49% | 2376746 | 10230751 | +| binder | 17838297 | 138855710 | 4.15% | 621887 | 4679226 | +| letBinder | 313517 | 3757214 | 0.11% | 643 | 5488 | +| ref | 23053693 | 112639845 | 3.37% | 308953 | 1493213 | +| prj | 54934 | 358710 | 0.01% | 1120 | 7556 | +| mdata | 113930 | 1465345 | 0.04% | 40 | 1059 | +| callSite | 320 | 45304 | 0.00% | 0 | 0 | +| etaCallSite | 0 | 0 | 0.00% | 0 | 0 | + +### metaSharing + +- Named entries with non-empty `metaSharing`: 7 of 778344; with non-empty `original` metaSharing: 0. Entries per non-empty table: min 30, median 61, p90 114, p99 114, max 114. +- metaRefs entries: 0; metaUnivs entries: 413181. + +| Named entry | §2 rank | metaSharing entries | bytes | +|---|---:|---:|---:| +| `Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_6` | 240625 | 61 | 4970 | +| `Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_5` | 225718 | 61 | 4970 | +| `Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_1` | 36564 | 30 | 2342 | +| `Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_4` | 299841 | 114 | 9435 | +| `Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_3` | 212626 | 114 | 9435 | +| `Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_2` | 563607 | 30 | 2342 | +| `Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_7` | 195384 | 114 | 9435 | + +- Analysis errors (constants not analysed): 0. + +| metadata | constants | entries | current bytes | unshared bytes | re-encoded against the primary table | distinct entries | current, deduplicated | re-encoded, deduplicated | entries equal to a primary subterm | equal to a primary table entry | Share nodes in entries | +|---|---:|---:|---|---:|---:|---:|---:|---:|---|---:|---:| +| primary `ConstantMeta` | 7 | 524 | 42929 (0.00% of file) | 42929 | 5495 | 203 | 14599 | 2586 | 412 (34613 B) | 288 | 0 | +| `Named.original` | 0 | 0 | 0 (0.00% of file) | 0 | 0 | 0 | 0 | 0 | 0 (0 B) | 0 | 0 | + +### ExprMeta arena structure: child deltas and duplication + +- Arenas: 793394 (22265 of them in `original` metadata); nodes 272299746; node bytes 1435189339 (42.93% of the file; the per-arena count prefixes are not included). Children that do not point strictly backward (any slot): 0. +- Node bytes equal the per-kind arena bytes above (1435189339): **yes**. + +Child deltas (parent index − child index) per child slot, and the child-field bytes today (`Tag0` of the absolute index) and as backward deltas with TagN-byte widths: + +| slot | children | Δ = 1 | 2–7 | 8–127 | 128–1023 | 1024–16383 | ≥ 16384 | not backward | bytes today | delta bytes | change | change, % of file | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| App function | 221528194 | 125476650 | 32455208 | 33541131 | 18672878 | 10680790 | 701537 | 0 | 504120517 | 252407009 | -251713508 | −7.53% | +| App argument | 221528194 | 62949362 | 9202542 | 55524334 | 61885626 | 30072227 | 1894103 | 0 | 437767740 | 317603186 | -120164554 | −3.59% | +| Binder type | 18460184 | 307946 | 1064520 | 8141823 | 7195535 | 1700678 | 49682 | 0 | 26989432 | 27463509 | 474077 | +0.01% | +| Binder body | 18460184 | 16933583 | 124523 | 655804 | 537254 | 201706 | 7314 | 0 | 38310222 | 19214547 | -19095675 | −0.57% | +| Let type | 314160 | 315 | 2942 | 45287 | 164730 | 95088 | 5798 | 0 | 684256 | 585939 | -98317 | −0.00% | +| Let value | 314160 | 8016 | 6416 | 75713 | 148902 | 71919 | 3194 | 0 | 762502 | 541527 | -220975 | −0.01% | +| Let body | 314160 | 299268 | 1244 | 5213 | 5065 | 3285 | 85 | 0 | 869164 | 322680 | -546484 | −0.02% | +| Prj child | 56054 | 27687 | 3901 | 14249 | 8206 | 1984 | 27 | 0 | 103251 | 66298 | -36953 | −0.00% | +| Mdata child | 113970 | 101758 | 937 | 5843 | 4104 | 1276 | 52 | 0 | 286605 | 119471 | -167134 | −0.00% | +| **all slots** | 481089260 | 206104585 | 42862233 | 98009397 | 88622300 | 42828953 | 2661792 | 0 | 1009893689 | 618324166 | -391569523 | −11.71% | +| App slots only | 443056388 | 188426012 | 41657750 | 89065465 | 80558504 | 40753017 | 2595640 | 0 | 941888257 | 570010195 | -371878062 | −11.12% | + +- Children that are exactly the immediately preceding node (Δ = 1): 206104585 of 481089260 (42.84%); App children: 188426012 of 443056388. + +Duplication within each arena (bottom-up hash-consing on kind, payload and canonical child IDs; a duplicate is a node whose canonical ID occurred earlier in the same arena): + +| nodes | total | duplicates | duplicate bytes | % of file | maximal duplicate subtrees | duplicate nodes in them | bytes in them | % of file | +|---|---:|---:|---:|---:|---:|---:|---:|---:| +| all kinds | 272299746 | 133235031 | 708442761 | 21.19% | 17821128 | 133235031 | 708442761 | 21.19% | +| App nodes (subtrees rooted at an App) | 221528194 | 119976692 | 662307925 | 19.81% | 14629275 | 118532355 | 633508953 | 18.95% | + +- Distinct nodes per arena summed: 139064715 of 272299746 (51.07%); distinct App nodes: 101551502 of 221528194. +- Maximal duplicate subtree sizes (duplicate nodes): 1: 5968305, 2–7: 8635747, 8–63: 2931610, 64–1023: 283802, ≥ 1024: 1664. +- Independent check on arenas of at most 256 nodes (duplicates recounted by comparing full subtree strings): agree for 539729 arenas, **differ for 0**; 253665 arenas not checked (more than 256 nodes, or a subtree string over 100,000 characters). +- Split: primary arenas 268738069 nodes, 131681330 duplicates (701777859 B); `original` arenas 3561677 nodes, 1553701 duplicates (6664902 B). diff --git a/docs/sharing-minimum-performance.md b/docs/sharing-minimum-performance.md new file mode 100644 index 000000000..b04ea4c4c --- /dev/null +++ b/docs/sharing-minimum-performance.md @@ -0,0 +1,5207 @@ +# Exact sharing: production performance (plan P4) + +This document is the P4 deliverable of [`sharing-minimum.md`](sharing-minimum.md), "Production viability +measurements". It gathers in one place, for a PR reviewer, what has been measured on two corpora: + +- `Init`, with the corpus harness, in [`sharing-minimum-measurements.md`](sharing-minimum-measurements.md); +- Mathlib, with the same harness, in [`sharing-minimum-measurements-mathlib.md`](sharing-minimum-measurements-mathlib.md); +- both corpora, in this document: the canonical tiered construction in Rust under both Share + layouts, and the Lean/Rust differential. + +The document reports measurements. The design decisions it refers to are recorded in the plan (§12). + +**Status.** Most sections were measured on the format-v3 corpora (`Tag0`/`Tag2`/`Tag4` integers, +heuristic sharing tables written by the compiler of that time), with the canonical construction run +under two Share layouts: Tag4 (v3's code) and TagN, priced but not serialized. [Format v4: the TagN-only +wire with six rungs](#format-v4-the-tagn-only-wire-with-six-rungs) repeats the Rust construction and the +Lean/Rust differential on corpora with TagN integers everywhere (still heuristic tables, header `0xE3`). +In v4 the canonical construction (best of three, Kahn order, TagN only) is the only compiler sharing +route in both implementations; the heuristic and the Tag4 layout are removed. +[Final route: compile time and the optimized construction](#final-route-compile-time-and-the-optimized-construction) +measures `ix compile` and both constructions after their optimizations, on the final route. + +**Canonical construction.** Since plan §12.11, phase 1 runs at each width w ∈ {1, 2, 3}. Each run goes +through phases 2 and 3, and the result with the fewest real layout bytes is kept ("best of three"). The +canonical numbers below are that rule's. + +They were measured through the experiment hook `normalize_constant_sharing_tiered_at_width` +(*width-hook*). That hook runs exactly the three candidate constructions the rule compares. The Lean and +Rust canonical entry points adopted the rule afterwards (*b3-lean*, *b3-rust*). + +The experiment hooks named in this document were removed after the experiments: the best-of-four +candidate `Phase1Choice::AllCandidates`, the MSS inspector and the runner modes `--width-experiment`, +`--mss-diff`, `--mss-compare`, `--mss-ties` and `--layout`. The forced-width entry point +`normalize_constant_sharing_tiered_at_width` remains only as a crate-private test helper. The data keeps +their names; reproducing it needs the commits in the Sources table. + +Numbers for the earlier rule, which chose the width from the candidate count `K` ("K-based"), are marked +**superseded**. They are kept because they are what led to §12.11 and because the Lean/Rust parity and +timing runs used that rule. + +**Pointers.** Every number carries a pointer in square brackets to the log or document it comes from; +the keys are listed under [Sources](#sources). A number derived from two sources, for example by a CSV +join, cites both. + +## Contents + +- [Summary](#summary) +- [Sources](#sources) +- [Corpora](#corpora) +- [What is measured](#what-is-measured) +- [Bytes](#bytes) +- [Certification and resource limits](#certification-and-resource-limits) +- [Wall time and memory](#wall-time-and-memory) +- [Phase statistics](#phase-statistics) +- [Slowest constants](#slowest-constants) +- [Lean/Rust parity](#leanrust-parity) +- [The phase-1 width experiment](#the-phase-1-width-experiment) +- [Format v4: the TagN-only wire with six rungs](#format-v4-the-tagn-only-wire-with-six-rungs) +- [Final route: compile time and the optimized construction](#final-route-compile-time-and-the-optimized-construction) +- [What is not covered](#what-is-not-covered) +- [Reproduction](#reproduction) +- [Appendix A: runner reports and joins](#appendix-a-runner-reports-and-joins) +- [Appendix B: differential tallies](#appendix-b-differential-tallies) + +## Summary + +- **Corpora.** Init has 56,622 constants and 80,208,288 stored bytes [Init]. Mathlib (the whole + `import Mathlib` environment) has 679,499 constants and 1,468,890,902 stored bytes [ML]. +- **Bytes, canonical (best of three), rooted constants** [X1] [X2]: + + | layout | corpus | vs heuristic | vs MSS at the same widths | + |---|---|---:|---:| + | TagN | Init | −16.92% | −1.41% | + | TagN | Mathlib | −23.64% | −0.82% | + | Tag4 | Init | −16.10% | −1.88% | + | Tag4 | Mathlib | −22.70% | −1.15% | + + - **Never larger than unshared** on either corpus. + - **Larger than MSS** for 5 Init and 903 Mathlib constants (TagN), and for 3 and 861 (Tag4). + - **The largest loss** is one Mathlib outlier at +1,485 bytes (TagN; +1,468 with the Kahn order). It + is a tie-break artifact of the Kahn order: MSS with the construction's tie rule (structural ID) + gives the same 67,367 bytes as storing MSS's set, and over all of Mathlib storing every candidate is + never larger than MSS under the same tie rule [X5] [X6] [P §12.15]. +- **Rejected alternatives.** + - The K-based width rule: on Mathlib it was larger than MSS in total (+0.46% TagN, +0.21% Tag4), + larger on about a third of constants [J2]. This led to §12.11. + - A fourth candidate storing every candidate ("best of four") saves only 2,896 bytes over Mathlib + (TagN) [X4] [P §12.14]. +- **Certification.** + - Rust, with the reclassifying branch and bound: every constant of both corpora certifies at every + width under both layouts with the default limits [X1] [X2]. + - The old subset enumeration failed `States` in phase 1 on 25 Init and 342 Mathlib constants [R1] [R2]. + - Lean and Rust, best of three: no exhaustion on any Init constant [D7]. +- **Time and memory (Rust, best of three, TagN layout)** [X1] [X3]: + - Init: 43.2 s on 8 threads, 414.9 s on 1 thread. + - Mathlib: 1,094 s on 8 threads, peak RSS 4.8 GB. + - For comparison, one K-based construction per constant took 184 s over Mathlib on 20 threads [R3]. + - The machine was shared, so these timings are indicative. +- **Lean/Rust parity:** + - Best of three: identical bytes for all 56,622 Init constants under both layouts [D7]. + The Mathlib-sample run under the best of three [D8] was aborted without a result: it used the + phase-2 order that §12.14 replaces. + - K-based (superseded): 0 byte disagreements on all of Init, on a 20,263-constant Mathlib sample, and + on half of Mathlib (339,749 constants) [D1]–[D6]. + - Every one-sided exhaustion was Lean's, and every one gave Rust's bytes once its limit was raised. + With `maxMaterializeWork` = 2^36 (*work-limit*) there are none. +- **Format v4** (TagN-only wire, six rungs; regenerated corpora at *six-rung*) [R10] [D10] [D11]: + - The Rust canonical output is 14.81% below the stored v4 bytes on Init and 21.16% below on Mathlib. + - One Mathlib constant hit a limit. *knapsack-limit* gave the table-count knapsack its own limit, after + which that constant certifies. + - Lean/Rust parity: all 56,622 Init constants are identical. Of the 20,265-constant Mathlib sample, + 20,264 are identical and one (`CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite`) + fails with a resource-limit error on both sides, the case *knapsack-limit* addresses; 0 disagreements. + The final differential at this PR's head supersedes these runs: 56,622 Init and 20,284 + Mathlib-sample constants, identical bytes, no exhaustion on either side. +- **Final route** (the canonical construction as the compiler's only route, after the Rust + optimizations) [C2] [C3] [R11] [R12] [L1] [M1]: + - `ix compile` of Mathlib takes 1.13–1.26× the heuristic route's wall time in the final + back-to-back runs at this PR's head (2:08.8–2:09.9 against 1:42.0–1:54.8; 1.24–1.30× in + earlier pairs); before the Rust optimizations it took 8:56.6. Init takes 10.9 s against 8.6 s. + - The output is 2,318,833,546 bytes for Mathlib and 143,680,738 for Init, against 2,620,063,965 and + 155,259,078 with heuristic sharing (−11.50% and −7.46%). + - The Rust construction alone, summed per constant: Mathlib 9,685 s → 940 s, Init 379 s → 50 s, + byte-identical. The checked mode, which builds and verifies all three candidates, agrees with the + default mode on every constant of both corpora. + - The Lean construction is 8.3–15.4× slower than Rust single-threaded on Init samples (about 61× + before its own optimizations). The 2–4× target is not met. + - The merge-queue compile partition (Lean and Rust compile the same test environment and are + compared) takes 11:51, against 15:30 before the route switch. +- **Not covered:** + - distance to the true minimum, because the width-state oracle runs on small inputs only; + - serialized unshared sizes for 619 Mathlib constants; + - serialized TagN bytes on the v3 corpora (the v4 section serializes them); + - Lean on all of Mathlib; + - best-of-three byte totals with the Kahn order beyond the first tier on the v3 corpora (the totals + above predate it; see [X6] for the outlier, and the v4 section for Kahn-order totals and parity). + +## Sources + +The outputs named in the table are not tracked. Each report and join this document cites is +reproduced unedited in Appendix A, and each differential tally in Appendix B; [Reproduction](#reproduction) +gives the commands that regenerate them. In the appendices and commands, `$S` stands for the directory +holding the corpora and the outputs. + +Terms used in the table: + +- **runner:** the Rust example `crates/ixon/examples/sharing_corpus.rs`, release build; +- **differential:** the Lean/Rust suite `exact-sharing-ffi` (`Tests/Ix/SharingExactFFI.lean`) in corpus + mode; +- **search, old:** phase 1's uniform search used the subset enumeration; +- **search, new:** phase 1 used the reclassifying branch and bound (Lean *bb-lean*, Rust *bb-rust*). + +**Builds.** The code column and the text name development builds of this work, which are not +commits of the repository. In order: + +| build | what it added | +|---|---| +| *ml-harness* | the corpus harness version of the Mathlib measurements | +| *diff-1* | the first Lean/Rust differential test | +| *runner-1* | the first version of the Rust corpus runner | +| *diag* | corpus selection and the Lean limit diagnosis in the differential | +| *bb-lean* | the reclassifying branch and bound, Lean | +| *bb-rust* | the reclassifying branch and bound, Rust | +| *k-bb* | branch and bound against subset-enumeration tests (K-based width rule) | +| *work-split* | a separate materialization-work limit in Lean | +| *work-limit* | that limit in the differential diagnosis (`maxMaterializeWork` 2^36) | +| *parity-record* | documentation only: parity and speed results | +| *width-hook* | the forced phase-1 width hook and the width experiment | +| *b3-record* | documentation only: the best-of-three rule | +| *b3-lean* | the best-of-three width rule, Lean | +| *best-of-four* | the all-candidates hook and the best-of-four runner mode | +| *b3-rust* | the best-of-three width rule, Rust | +| *plan-b4* | documentation only: the plan with the best-of-four record | +| *kahn-lean* | the Kahn order beyond the first tier, Lean | +| *par* | deterministic parallelism inside one construction | +| *tagn-only* | TagN as the only integer code | +| *kahn-rust* | the Kahn order beyond the first tier, Rust | +| *mss-hooks* | the MSS and encoding-inspector hooks | +| *kahn* | documentation only: the outlier explained (code as *kahn-rust*) | +| *serial-mode* | the runner mode `--serial-constants` | +| *rung4* | the 4-byte TagN rung | +| *six-rung* | the six TagN rungs in the construction; the last heuristic-route compiler used below (corpora with header `0xE3`) | +| *knapsack-lean* | the knapsack-cell limit, Lean | +| *knapsack-limit* | the telescope-spine guard and the knapsack-cell limit, Rust | +| *v4-flip* | format version 4 (canonical route, before any optimization) | +| *pre-opt* | the canonical route before the Rust optimizations | +| *dry-run* | the phase-1 dry run, during the Rust optimizations | +| *optimized* | the end of the Rust optimizations | +| *optimized-main* | *optimized* merged with `main` | +| *candidate-fix* | the candidate count no longer limits the canonical route | +| *review-fixes* | the Rust review fixes (checked mode) | +| *lean-optimized* | the Lean fast implementations | + +| key | what | code | search | outputs (untracked) | +|---|---|---|---|---| +| [P] | the plan, §0 and §12 | *plan-b4* | | `docs/sharing-minimum.md` | +| [Init] | Init corpus harness (`sharing-study`), tenth run | see the doc | | `docs/sharing-minimum-measurements.md` | +| [ML] | Mathlib corpus harness (`sharing-study`) | *ml-harness* | | `docs/sharing-minimum-measurements-mathlib.md` | +| [X1] | **best of three**, TagN layout, Init and Mathlib, 8 threads | *width-hook* | new | `wx_{init,ml}_tagN.{md,err,csv}`, `wx_*_tagN_{join,best}.txt` | +| [X2] | **best of three**, Tag4 layout, Init and Mathlib, 8 threads | *width-hook* | new | `wx_{init,ml}_tag4.{md,err,csv}`, `wx_*_tag4_{join,best}.txt` | +| [X3] | best of three, TagN layout, Init, 1 thread | *width-hook* | new | `wx_init_tagN_t1.{md,err,csv}` | +| [X4] | best of four (w = 1, 2, 3 and all candidates), both layouts, Init and Mathlib, 12 threads | *best-of-four* | new | `wx4_{init,ml}_{tagN,tag4}.{md,err,csv}`, `wx4_*_{join,best}.txt` | +| [X5] | MSS (ties by structural ID and by blake3) against "all", all of Mathlib; entry-level diffs | *mss-hooks* | new | `cmp_{id,blake3}.{md,err,csv}`, `outlier_diff2.md`, `diff_up7_blake3.md`, `diff_sample13_id.md` | +| [X6] | the outlier with the Kahn order, per width and "all", both layouts | *kahn-rust* | new | `outlier_kahn_{tagN,tag4}.csv` | +| [X7] | parallelism timings on Mathlib: whole corpus (a), (b), (c) at 20 threads, and per-constant latency (`--serial-constants`) | *mss-hooks*, *serial-mode* | new | `ml_{a,b,c}.{md,err,csv,load,loadlog}`, `serial_{a,b,c}.{md,err,csv,loadlog}` | +| [X8] | parallel against sequential, all of Init, four budgets (`--check-sequential`) | *par* | new | `init_check_*.{md,err}` | +| [R1] | K-based, runner, Init, TagN layout, 16 threads | *runner-1* | old | `init_tiered.{md,err,csv}` | +| [R2] | K-based, runner, Mathlib, TagN layout, 20 threads | *runner-1* | old | `mathlib_tiered.{md,err,csv}` | +| [R3] | K-based, runner, Mathlib, TagN layout, 20 threads | *k-bb* | new | `mathlib_tiered_bb.{md,err,csv}` | +| [R4] | K-based, runner, Init, TagN layout, 20 threads | *k-bb* | new | `init_tagN_t20.{md,err,csv}` | +| [R5] | K-based, runner, Init, Tag4 layout, 20 threads | *k-bb* | new | `init_tag4_t20.{md,err,csv}` | +| [R6] | K-based, runner, Init, TagN layout, 1 thread | *k-bb* | new | `init_tagN_t1.{md,err,csv}` | +| [R7] | K-based, runner, Mathlib, Tag4 layout, 20 threads | *k-bb* | new | `ml_tag4_t20.{md,err,csv}` | +| [J1] | K-based, join of [Init]'s CSV with [R4] and [R5] | | | `init_join.txt`, `init_byw.txt` | +| [J2] | K-based, join of [ML]'s CSV with [R3] and [R7] | | | `ml_join.txt`, `ml_byw.txt` | +| [D0] | differential, Init, the 10 Lean-only constants, limit diagnosis | *diag* | old | `diag_init.log` | +| [D1] | differential, Init, all constants, 1 process | *diff-1* | old | `corpus_full.log` | +| [D2] | differential, Init, all constants, 6 processes | *k-bb* | new | `init_bb_s{0..5}.log` | +| [D3] | differential, Mathlib sample, 2 processes | *diag* | old | `mathlib_diff_{a,b}.log` | +| [D4] | differential, Mathlib sample, 4 processes | *k-bb* | new | `ml_bb_s{0..3}.log` | +| [D5] | differential, the Lean-only constants of [D2]/[D4] | *work-limit* | new | `lo_s{0..3}.log`, `lo_init.log` | +| [D6] | differential, K-based, Mathlib, all constants in 6 address shards; 3 shards (339,749 constants) completed | *work-limit* | new | `lf_s{0,3,4}.log` (and the empty `lf_s{1,2,5}.log`) | +| [D7] | differential, **best of three**, Init, all constants, tiered-TagN and tiered-Tag4, 6 processes | *b3-rust* | new | `b3_init_s{0..5}.log` | +| [D8] | differential, **best of three**, Mathlib sample, tiered-TagN and tiered-Tag4, 4 processes; aborted, no tallies | *b3-rust* | new | `b3_ml_s{0..3}.log` | +| [D9] | differential, **best of three with the Kahn order**, Init, all constants, tiered-TagN and tiered-Tag4, 6 processes | *kahn* | new | `init_s{0..5}.log` | +| [D10] | differential, best of three with the Kahn order, **v4 Init corpus**, all constants, tiered-TagN, 6 processes | *six-rung* | new | `init_s{0..5}.log` | +| [D11] | differential, same build, **v4 Mathlib sample** (20,265 constants), tiered-TagN, 8 processes | *six-rung* | new | `ml_s{0..7}.log` | +| [R10] | Rust canonical runner over the v4 corpora, 20 threads (also writes the address lists and the sample) | *six-rung* | new | `{init,ml}_rust.{md,err,csv}`, `init_all.txt`, `ml_select.txt` | +| [C1] | v4 corpus compiles | *six-rung* | | `compile_{init,mathlib}.log` | +| [X9] | `IsDenseSubsite…` per width on the v4 corpus: defaults at *six-rung*, `--max-states 2^26`, and defaults with the knapsack limit | *six-rung*, *knapsack-limit* | new | `dense_widths{,_26,_knap}.csv` | +| [C2] | `ix compile` of Mathlib and Init back to back: heuristic route (binary built at *six-rung*), then canonical route | *six-rung*, *optimized-main* | | `run_{mathlib,init}_verify_{heur,final}.log`, the two `.ixe` outputs | +| [C3] | `ix compile` back-to-back pairs on a quieter machine, and the canonical route before the Rust optimizations | *six-rung*, *optimized*, *dry-run*, *pre-opt* | | `run_mathlib_{heur_final,final,heur_c,i4_a,base_a}.log`, `run_init_{heur_final,final,base_final}.log` | +| [R11] | Rust runner, 20 threads, at the start and at the end of the Rust optimization work, over the patched Mathlib corpus and the canonical-route Init file | | new | `{ml,init}_base.{md,csv}`, `{ml,init}_i4.{md,csv}` | +| [R12] | Rust runner, 12 threads, default mode, checked mode (`--full-check`) and `--check-sequential`, over the canonical-route files | *review-fixes* | new | `{init,mathlib}_f2{,full,seq}.{md,csv,log}` and the CSV comparison | +| [L1] | Lean (`exact-sharing-ffi` corpus mode, `LEAN_NUM_THREADS=1` and default) against the Rust runner (1 thread, default mode) on three Init samples | *lean-optimized* | new | `ffi_{bulk,p99,slow}_{1,default}.log`, `rust1.{csv,log}` | +| [M1] | merge-queue partition `lake test --wfail -- --ignored compile` | *lean-optimized* | | `ignored_compile.log` | + +Notes on the sources: + +- **Code identity.** No file under `crates/` changed between *k-bb* and *parity-record*. The runner binary + for [R4]–[R7] was built at *k-bb*. The binary for [X1]–[X3] was built from *width-hook*'s source + before two lint-only edits to the runner; *width-hook* itself refactors the canonical path into + `tiered_at(…, None)` without changing it. The Lean side of [D5]/[D6] was built at *work-limit*; later + commits change only documentation and Rust. [X4] used a copy of the runner built at *best-of-four*. [X5] and [X6] used runner binaries + built from the sources of *mss-hooks* and *kahn-rust* before those were committed; only lint and + documentation edits followed. [D7] and [D8] + used `IxTests` built at *b3-rust*, whose Lean side is the best of three of *b3-lean*. +- **The Mathlib sample** used by [D3]/[D4] has 20,263 constants: every 50th constant in address order, + plus every constant with more than 2,000 R1/R2 candidates. It was written by the runner's + `--select-out` during [R2]. +- **The joins** ([J1], [J2], and the `*_join.txt` and `*_best.txt` files of [X1] and [X2]): + - They match rows on the 16-hex-digit address prefix, as [ML] does, and are restricted to rooted + constants. + - They price MSS at TagN widths per constant as + `mss_bytes − (lt8 + 2·[8,256) + 3·≥256) + (lt8f + 2·[8,1032) + 3·≥1032)`, using [Init]'s and [ML]'s + reference counts (scheme F). + - Their checks: 0 stored-bytes mismatches and 0 unshared-size mismatches between the study CSV and the + runner CSV. The heuristic, MSS, scheme-F and unshared totals they compute equal those printed in [Init] + and [ML]. + - They were computed by gawk scripts (`join.awk`, `byw.awk`, `wxjoin.awk`, `bestjoin.awk`, + `slowest.awk`) that are not tracked; the matching and pricing rules above define them. +- **Percentiles.** The runner and the joins use the nearest rank, rounded down (`xs[⌊(n−1)·p⌋]`). [Init] and + [ML] use their own convention. +- **Machine.** All runs used one machine, an AMD Ryzen AI 9 HX 370 (12 cores, 24 hardware threads) with + 93.6 GiB of RAM, shared throughout with other builds and tests. Timings are therefore indicative, and + no two runs had the same background load. + +## Corpora + +| | Init | Mathlib | +|---|---:|---:| +| file | `init.ixe` | `mathlib.ixe` | +| size | 195,387,870 B [Init §Results] | 3,343,271,273 B [ML §Corpus] | +| stored constants (distinct addresses) | 56,622 [Init §Results] | 679,499 [ML §Corpus] | +| names | 66,621 [Init §Results] | 778,344 [ML §Corpus] | +| constants with at least one root | 55,386 [Init §Results] | 663,254 [ML §Headline] | +| stored (heuristic) bytes, all constants | 80,208,288 [Init §Results] | 1,468,890,902 [ML §Results] | +| stored bytes, rooted constants | 80,161,846 [Init §MSS] | 1,468,281,356 [ML §MSS vs heuristic] | +| distinct subterms `N`: median / p99 / max | 86 / 2,015 / 27,628 [Init §Headline] | 147 / 3,052 / 95,110 [ML §Headline] | +| R1/R2 candidates: median / p90 / p99 / max | 34 / 232 / 1,187 / 22,458 [Init §Headline] | 69 / 432 / 2,029 / 81,833 [ML §Headline] | +| rooted constants with ≤ 8 candidates | 17.2% [Init §Headline] | 10.1% [ML §Headline] | + +- **Init** is the production Lean compiler's output for `Benchmarks/CompileInit.lean`. Regenerate it with + `lake exe ix compile Benchmarks/CompileInit.lean --out ` [P §0]. The production rebuild check + reproduces all 56,622 stored constants byte for byte [Init §Verification]. These v3 corpora come from v3 + commits; at a v4 commit the same commands write v4 files with canonical sharing tables. +- **Mathlib** comes from `lake exe ix compile Benchmarks/Compile/CompileMathlib.lean --out `, which + does `import Mathlib` and so compiles the whole import environment [ML §Corpus]: + - exit 0, 7 min 29 s end to end, of which the compile itself took 152.42 s; + - peak RSS 19,107,692 kB; 0 ungrounded constants. + + The production rebuild reproduces all 679,499 constants [ML §Verification]. The corpus contains Init: + 56,621 of the 56,622 Init rows, all but `main` [ML §Corpus]. + +## What is measured + +- **Heuristic:** the stored bytes (`rawBytes`) written by the compiler of the time: `Ix.Sharing.applySharing` + in Lean and its Rust twin (both removed in v4). +- **MSS:** store every compact-DAG node with in-degree ≥ 2 and standalone size > 1, reference every + occurrence, and order the table by priority topological order [Init §MSS follow-up]. It is priced two + ways: + - in v3's Tag4 format (scheme A: its real serialized length); + - at TagN widths (scheme F: 1 byte below index 8, 2 below 1,032 and 3 beyond). For tables below 66,568 + entries this equals TagN [ML §Share-width schemes]. +- **Canonical tiered:** `canonicalSharingTiered` (Lean, `Ix/Sharing/Exact/Tiered.lean`) and + `normalize_constant_sharing_tiered` (Rust) [P §12.8]. It has three phases: + 1. the exact uniform-model optimum at a width `w`; + 2. an exact maximum-reference first tier of 8 slots, then the pinned order; + 3. per-entry re-materialization under the layout's real widths. + + The two rules for `w` differ as follows: + - **Best of three** [P §12.11]: run phases 1–3 at each `w ∈ {1, 2, 3}` and keep the result with the + fewest layout bytes. Ties go to the lower `w`, then `setPrec`. Since each width yields one result, + `setPrec` never decided in these runs. + - **K-based (superseded)** [P §12.8]: `w = 1` if `K ≤ 8`, `2` if `K ≤ 256` (Tag4) or `K ≤ 1,032` + (TagN), else `3`. Here `K` is the number of terms with in-degree ≥ 2 and unshared length ≥ 2. + + The construction runs under two layouts: + - **Tag4:** v3's Share encoding. Bytes are the real serialized length. + - **TagN:** the nibble-bootstrapped Share code [P §12.7]. No serializer wrote it at the time, so bytes are + the output priced with TagN Shares (`layout_bytes`); everything else is serialized exactly. +- **Unshared:** every root fully expanded, with an empty table, computed compositionally. Serialization + confirmed it for all but 7 Init and 619 Mathlib constants, whose unshared roots exceed 16 MiB + [Init §Verification] [ML §Verification]. + +## Bytes + +### Canonical (best of three): totals over rooted constants + +| encoding | Init | vs heuristic | Mathlib | vs heuristic | +|---|---:|---:|---:|---:| +| heuristic (stored) | 80,161,846 | | 1,468,281,356 | | +| MSS, Tag4 (scheme A) | 68,547,873 | −14.49% | 1,148,195,956 | −21.80% | +| MSS at TagN widths (scheme F) | 67,556,587 | −15.72% | 1,130,381,317 | −23.01% | +| **canonical, Tag4 layout** | **67,255,886** | **−16.10%** | **1,135,005,370** | **−22.70%** | +| **canonical, TagN layout** | **66,602,235** | **−16.92%** | **1,121,167,486** | **−23.64%** | +| unshared | 1,069,954,757 | | 214,351,801,952,039 | | + +Sources: [X1] [X2]. The heuristic, MSS and unshared totals equal [Init §MSS] and [ML §MSS vs heuristic]. +The scheme-F Mathlib total equals [ML §Share-width schemes]. The Mathlib unshared total is dominated by a +few constants (the largest is 2.1·10^14 bytes) and is not meaningful as a total [ML §Limits and coverage]. + +**Canonical against MSS at the same widths** [X1] [X2]: + +| | Init | Mathlib | +|---|---:|---:| +| Tag4 layout − MSS (scheme A) | −1,291,987 (−1.88%) | −13,190,586 (−1.15%) | +| TagN layout − MSS (scheme F) | −954,352 (−1.41%) | −9,213,831 (−0.82%) | + +**All constants**, including the rootless ones, which come out byte-identical to the stored bytes +(1,236 Init and 16,245 Mathlib constants) [X1] [X2]: + +| | Init | Mathlib | +|---|---:|---:| +| stored | 80,208,288 | 1,468,890,902 | +| canonical, Tag4 layout | 67,302,328 (−16.09%) | 1,135,614,916 (−22.69%) | +| canonical, TagN layout | 66,648,677 (−16.91%) | 1,121,777,032 (−23.63%) | + +### Canonical (best of three): per-constant distributions (rooted constants) + +These are signed byte differences with nearest-rank percentiles [X1] [X2]. "TagN − heuristic" compares +TagN-priced bytes with the stored Tag4 bytes, so it includes the format change. + +| difference | corpus | smaller / equal / larger | min | p1 | p10 | p50 | p90 | p99 | p99.9 | max | +|---|---|---|---:|---:|---:|---:|---:|---:|---:|---:| +| Tag4 − heuristic | Init | 50,406 / 4,933 / 47 | −69,549 | −3,313 | −383 | −51 | −1 | 0 | 0 | 7 | +| | Mathlib | 627,129 / 35,622 / 503 | −262,502 | −6,433 | −1,031 | −125 | −4 | 0 | 0 | 36 | +| TagN − heuristic | Init | 50,406 / 4,933 / 47 | −74,928 | −3,566 | −383 | −51 | −1 | 0 | 0 | 7 | +| | Mathlib | 627,129 / 35,622 / 503 | −270,911 | −7,015 | −1,031 | −125 | −4 | 0 | 0 | 36 | +| Tag4 − MSS (A) | Init | 32,239 / 23,144 / 3 | −6,588 | −437 | −42 | −3 | 0 | 0 | 0 | 6 | +| | Mathlib | 405,933 / 256,460 / 861 | −22,505 | −361 | −31 | −3 | 0 | 0 | 1 | 266 | +| TagN − MSS (F) | Init | 32,236 / 23,145 / 5 | −7,794 | −150 | −41 | −3 | 0 | 0 | 0 | 6 | +| | Mathlib | 405,832 / 256,519 / 903 | −16,508 | −118 | −30 | −3 | 0 | 0 | 1 | 1,485 | + +- **Never larger than unshared.** The canonical construction is not larger than the unshared encoding for + any rooted constant of either corpus, under either layout [X1] [X2]. MSS is larger for 26 Mathlib + constants [ML §MSS larger than unshared]. The heuristic is larger for 600 Init and 20,237 Mathlib + constants [Init §Headline] [ML §Headline]. +- **Against MSS**, the remaining losses are few and small, except for one Mathlib constant (+1,485 bytes, + TagN). It is described with its statistics in [The phase-1 width experiment](#the-phase-1-width-experiment). + +### Superseded: the K-based width rule + +These were the canonical numbers until §12.11. They are kept because they motivated the change [J1] [J2]. + +| encoding (rooted constants) | Init | vs MSS at the same widths | Mathlib | vs MSS at the same widths | +|---|---:|---:|---:|---:| +| K-based, Tag4 layout | 67,701,399 | −846,474 (−1.23%) | 1,150,611,314 | **+2,415,358 (+0.21%)** | +| K-based, TagN layout | 66,990,376 | −566,211 (−0.84%) | 1,135,611,532 | **+5,230,215 (+0.46%)** | + +- **Per constant against MSS** [J1] [J2]: + + | layout | corpus | smaller / equal / larger | p99 | max | + |---|---|---|---:|---:| + | Tag4 | Init | 23,157 / 22,616 / 9,613 | 58 | 1,521 | + | Tag4 | Mathlib | 244,165 / 199,801 / 219,288 | 261 | 9,103 | + | TagN | Init | 23,132 / 22,616 / 9,638 | 59 | 1,293 | + | TagN | Mathlib | 242,375 / 199,829 / 221,050 | 277 | 10,505 | +- **The excess sat in the constants whose K-based width was 2** [J1] [J2]. Mathlib under TagN against + scheme F, by width: + - w = 1: 181,437 constants, −2,905 B in total, 0 larger; + - w = 2: 480,001 constants, **+5,841,564 B**, 220,221 larger; + - w = 3: 1,816 constants, −608,444 B, 829 larger. + + The Tag4 split, against scheme A: w = 1 −2,905 B; w = 2 +3,521,148 B with 207,107 larger; w = 3 + −1,102,885 B over 23,301 constants. On Init the w = 2 class was still net smaller than MSS: −464,153 B + (TagN), with 9,596 constants larger. +- **The K-based Tag4 layout did not even minimize Tag4 bytes** [J1] [J2] [R4] [R5] [R3] [R7]. + - The K-based TagN-layout construction, serialized in v3's Tag4 format, was smaller than the + K-based Tag4-layout construction: by 79,522 B on Init (67,621,877 vs 67,701,399) and by 2,582,709 B + on Mathlib (1,148,028,605 vs 1,150,611,314). + - Under Tag4, `K > 256` gave `w = 3` for 1,352 Init and 23,301 Mathlib constants; under TagN, + `K > 1,032` gave it for 108 and 1,816. +- **Against the heuristic**, the K-based construction was larger on 438 Init and 3,722 Mathlib constants + (Tag4 layout, at most 70 and 248 bytes) [J1] [J2]. The best of three is larger on 47 and 503, + by at most 7 and 36 bytes [X2]. +- **All constants** (K-based runner totals): Init Tag4 67,747,841 [R5], TagN 67,036,818 [R4]; Mathlib + Tag4 1,151,220,860 [R7], TagN 1,136,221,078 [R3]. + +## Certification and resource limits + +### Limits + +**Rust** limits were `ExactSharingLimits::default()` in `crates/ixon/src/sharing_exact.rs` at the commits +of these runs, used by every runner run: + +| limit | value | +|---|---:| +| `max_input_nodes` | 2^26 | +| `max_distinct_nodes` | 2^24 | +| `max_height` | 2^24 | +| `max_candidates` (width-state DP only) | 2^16 | +| `max_states` | 2^20 | +| `max_layer_states` | 2^18 | +| `max_transitions` | 2^28 | +| `max_work` | 2^36 | +| `max_output_bytes` | 2^32 | + +**Lean** limits were `Ix.Sharing.Exact.Limits` in `Ix/Sharing/Exact/Basic.lean`, defaults at *b3-record*: + +| limit | value | +|---|---:| +| `maxExprVisits` | 2^26 | +| `maxDepth` | 2^14 | +| `maxNodes` | 2^20 | +| `maxStates` | 2^20 | +| `maxTransitions` | 2^24 | +| `maxCostEvals` | 2^30 | +| `maxOutputBytes` | 2^28 | +| `maxMaterialize` (predicted output size) | 2^26 | +| `maxMaterializeWork` | 2^36 | + +`maxMaterializeWork` was added in *work-split*. Before it, the per-entry materialization work was +checked against `maxMaterialize`. + +After the v4 runs, the table-count knapsack got its own limit, 2^28 cells (`max_knapsack_cells` in Rust, +*knapsack-limit*; `maxKnapsackCells` in Lean; see the Format v4 section). The compiler defaults were later raised far above all of these +values, as a safety net with a `--sharing-limits` override ([`Ixon.md`, "Sharing System"](Ixon.md#sharing-system)). +On the canonical (tiered) path neither language limits the candidate count or meters `transitions`: +Rust's `candidates` limit and both languages' `transitions` limits bound only the width-state test +oracle ([Limits and numeric domains](#limits-and-numeric-domains)). + +Exhausting a limit is an error, and limits never change the bytes of a success (the docstrings of both +limit types). + +### Rust certification + +| corpus | layout | old search, K-based | new search, K-based | new search, best of three (each of w = 1, 2, 3) | +|---|---|---|---|---| +| Init | TagN | 56,597 / 56,622; 25 `resource:States` [R1] | 56,622 / 56,622 [R4] [R6] | **56,622 / 56,622 at every w** [X1] | +| Init | Tag4 | not run | 56,622 / 56,622 [R5] | **56,622 / 56,622 at every w** [X2] | +| Mathlib | TagN | 679,157 / 679,499; 342 `resource:States` [R2] | 679,499 / 679,499 [R3] | **679,499 / 679,499 at every w** [X1] | +| Mathlib | Tag4 | not run | 679,499 / 679,499 [R7] | **679,499 / 679,499 at every w** [X2] | + +- **The old failures were all in phase 1.** Between [R2] and [R3] only the uniform search changed. The new + search returns the subset enumeration's set (Rust test + `uniform_branch_and_bound_matches_subset_enumeration`), so phase 2 received the same input in both runs. + On all 679,157 constants certified by both runs, the Tag4 and TagN bytes are identical. +- **Size of the old failures** [R1] [R2], from the CSV `status` column: + - Init: 109–2,107 candidates (median 461); `N` 226–3,608. + - Mathlib: 79–35,702 candidates (median 752); `N` 196–60,092. + - Examples on Init: `Lean.Grind.Config.mk.injEq`, `Lean.Meta.Simp.Config.mk.injEq`. + - Examples on Mathlib: `WeierstrassCurve.addSubMapCoeff_condition`, + `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_decl_eq._mutual`. All 342 are named in [R2]. + +### Lean certification + +- **Old search, uniform optimizer alone** (Init corpus harness, `maxStates` 2^20): + - certified 55,294 / 55,358 / 55,338 of 55,386 rooted constants at w = 1 / 2 / 3; + - failures were `states` (90 / 26 / 46) and `costEvals` (2 at each width); + - the limit sat at a largest component of 20–21 [Init §Certification and failures]. +- **New search, uniform at w = 2:** no exhaustion in Lean or Rust on any of the 56,622 Init or 20,263 + sampled Mathlib constants [D2] [D4]. +- **New search, K-based tiered-TagN, before `maxMaterializeWork`:** Lean exhausted on 10 Init constants + [D2] and 120 sampled Mathlib constants [D4]. + - Every one hit the cumulative materialization work check (`maxMaterialize` 2^26). + - With the limit doubled until success, every one gave Rust's bytes. + - Init needed 2^27–2^29 [D0]. + - Mathlib needed 2^27 (62 constants), 2^28 (29), 2^29 (16), 2^30 (7), 2^31 (5) and 2^32 (1, + `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite`) [D4]. + - The needed limit grows with `k·N` (stored entries × DAG nodes), about 1.95·k·N on Init [D0] [R1]. +- **At *work-limit*** (`maxMaterializeWork` 2^36, all other limits at defaults), all 120 Mathlib and all 10 + Init constants succeed with Rust's bytes, the Init ones under both layouts [D5]. +- **Old search, sample** [D3] [D4]. Two kinds of exhaustion in [D3] do not occur with the new search: + - the 2 `maxCostEvals` cases (`mpullback_mulInvariantVectorField` and + `mpullback_addInvariantVectorField`, in both modes); + - 200 exhaustions on both sides (101 tiered-TagN, 99 uniform-w2). +- **K-based, half of Mathlib at *work-limit*:** no exhaustion on either side in 339,749 constants [D6]. +- **Best of three** (Lean *b3-lean*, Rust *b3-rust*, default limits): no exhaustion on either side + for any of the 56,622 Init constants under either layout [D7]. The Mathlib sample run [D8] was stopped after 2 h 5 min, before it had written any tally (its output is + buffered); see [Lean/Rust parity](#leanrust-parity). + +## Wall time and memory + +### Rust runner + +Column meanings: + +- **processing:** the runner's own timer around the parallel loop; +- **wall:** GNU `time` for the whole process, including index parse, name table, CSV and report; +- **peak RSS:** GNU `time`'s maximum resident set size. + +**Canonical, best of three** (three constructions per constant): + +| corpus | layout | threads | processing | wall | peak RSS | source | +|---|---|---:|---:|---:|---:|---| +| Init | TagN | **1** | 414.9 s | 419.2 s | 311,764 kB | [X3] | +| Init | TagN | 8 | 43.2 s | 47.6 s | 485,008 kB | [X1] | +| Init | Tag4 | 8 | 44.8 s | 50.0 s | 460,272 kB | [X2] | +| Mathlib | TagN | **1** | not measured | | | | +| Mathlib | TagN | 8 | 1,094.1 s | 1,277.9 s | 4,838,516 kB | [X1] | +| Mathlib | Tag4 | 8 | 1,031.8 s | 1,176.3 s | 4,853,268 kB | [X2] | + +**Superseded, K-based** (one construction per constant): + +| corpus | layout | search | threads | processing | wall | peak RSS | source | +|---|---|---|---:|---:|---:|---:|---| +| Init | TagN | new | **1** | 83.1 s | 85.4 s | 307,708 kB | [R6] | +| Init | TagN | new | 20 | 7.7 s | 10.2 s | 619,440 kB | [R4] | +| Init | Tag4 | new | 20 | 7.8 s | 10.2 s | 618,880 kB | [R5] | +| Init | TagN | old | 16 | 30.6 s | 32.9 s | 571,680 kB | [R1] | +| Mathlib | TagN | new | 20 | 184.3 s | 315.9 s | 5,300,268 kB | [R3] | +| Mathlib | Tag4 | new | 20 | 209.6 s | 347.7 s | 5,263,200 kB | [R7] | +| Mathlib | TagN | old | 20 | 293.2 s | 424.7 s | 4,794,008 kB | [R2] | + +A single-threaded K-based run over Mathlib was started and then stopped when §12.11 superseded the rule, +so it has no result. No single-threaded best-of-three run over Mathlib was made. + +Both single-threaded Init runs shared the machine with other jobs. The best-of-three one also overlapped +the 8-thread Mathlib Tag4 experiment, which inflates its times (see [Slowest constants](#slowest-constants)). +The ratio between the two Init runs is therefore not a clean measurement of what the extra widths +cost. + +Per-constant milliseconds, single-threaded: + +| run | p50 | p90 | p99 | p99.9 | max | +|---|---:|---:|---:|---:|---:| +| Init, K-based [R6] | 0 | 2 | 13 | 90 | 2,261 | +| Init, best of three (sum of the three widths) [X3] | 1 | 10 | 77 | 570 | 8,801 | +| Mathlib, best of three | not measured | | | | | + +### Lean and Rust in the differential + +Each differential process is single-threaded and runs both implementations on every selected constant. + +- **Lean Σ, Rust Σ:** sums of the per-call times the suite measures (the normalize call only). +- **Wall, peak RSS:** GNU `time` for each process. They cover both implementations, the loaded corpus, + and any limit-diagnosis reruns. + +**Best of three** (three constructions per constant and mode). These runs overlapped the 12-thread +best-of-four experiments and other jobs; the load average was 23.8 on 24 hardware threads when they +started. Their times are therefore not directly comparable with the K-based rows below. + +| corpus | constants | mode | Lean Σ | Rust Σ | processes, wall each | peak RSS each | source | +|---|---:|---|---:|---:|---|---:|---| +| Init | 56,622 | tiered-TagN | 5,415.2 s | 381.5 s | 6, 22:45–38:41 for both modes | 824,832–829,636 kB | [D7] | +| Init | 56,622 | tiered-Tag4 | 4,757.4 s | 384.6 s | (same processes) | | [D7] | +| Init, Kahn order | 56,622 | tiered-TagN | 3,045.6 s | 360.2 s | 6, 14:06–26:00 for both modes | 838,816–839,728 kB | [D9] | +| Init, Kahn order | 56,622 | tiered-Tag4 | 2,907.5 s | 360.9 s | (same processes) | | [D9] | + +**K-based (superseded):** + +| corpus | constants | mode | search | Lean Σ | Rust Σ | processes, wall each | peak RSS each | source | +|---|---:|---|---|---:|---:|---|---:|---| +| Init | 56,622 | tiered-TagN | old | 1,380.3 s | 137.1 s | 1, 4,536.4 s for 3 modes | not recorded | [D1] | +| Init | 56,622 | tiered-Tag4 | old | 1,560.2 s | 146.5 s | (same process) | | [D1] | +| Init | 56,622 | uniform-w2 | old | 1,207.0 s | 100.4 s | (same process) | | [D1] | +| Init | 56,622 | tiered-TagN | new | 435.7 s | 75.4 s | 6, 1:52–4:31 for both modes | 834,832–835,248 kB | [D2] | +| Init | 56,622 | uniform-w2 | new | 151.1 s | 31.2 s | (same processes) | | [D2] | +| Mathlib sample | 20,263 | tiered-TagN | old | 8,121.6 s | 925.0 s | 2, 3:08:16 and 3:23:14 for both modes | 4,723,896 and 4,729,316 kB | [D3] | +| Mathlib sample | 20,263 | uniform-w2 | old | 4,879.5 s | 399.7 s | (same processes) | | [D3] | +| Mathlib sample | 20,263 | tiered-TagN | new | 5,092.5 s | 703.4 s | 4, 1:01:54–1:37:49 for both modes | 4,704,176–4,717,480 kB | [D4] | +| Mathlib sample | 20,263 | uniform-w2 | new | 1,379.8 s | 89.3 s | (same processes) | | [D4] | +| Mathlib, the 120 Lean-only constants | 120 | tiered-TagN | new, *work-limit* | 5,128.7 s | 257.6 s | 4, 17:20–28:39 | 4,732,112–4,735,896 kB | [D5] | +| Mathlib, half the corpus | 339,749 | tiered-TagN | new, *work-limit* | 8,563.0 s | 1,091.0 s | 3, 53:12–55:03 | 4,724,964–4,731,392 kB | [D6] | + +- The sample is heavy by construction (it includes every constant with more than 2,000 candidates), so + its per-constant times are not corpus averages. +- **For context; these are not optimizer timings:** + - The Lean uniform optimizer run by the Init corpus harness (old search, w = 1, 2 and 3, + single-threaded) took 6,875,358 ms + over 166,158 calls, a median of 179–249 µs per call and a maximum of 108 s [Init §Wall time]. + - The single-threaded `sharing-study` harness, which runs no optimizer, measured Mathlib in 4,101.8 s + with 4,709,872 kB peak RSS [ML §Reproduction]. + +### Parallelism inside one constant (Rust) [X7] [X8] + +`normalize_constant_sharing_tiered_par` (*par*) runs the canonical construction with thread budgets +`Parallelism { widths, components, materialize }` on the current rayon pool. Budgets of 1 give the +sequential reference path, which every other entry point uses. + +- **Widths.** The three phase-1 widths run as separate tasks, each under its own meter, and are compared + by the same rule. An error fails the call with the error of the lowest failing width. (Since the + later optimizations, the checks on built expressions run only for the returned candidate in the + default mode; see [Checks](#checks-default-and-checked-mode-r12).) +- **Components.** Phase 1's uncertain components are searched as separate tasks, each on its own meter, + and their counts are added in component order. + - The totals equal the sequential ones, and the call fails exactly when the sequential call fails. + - The documented exception: if both `states_created` and `work` reach their limits within one + component, the reported resource can differ. +- **Phase 3.** Entry `j` depends only on `order[..j]`, so entries and roots run as contiguous-range + tasks. Work is charged in entry order afterwards, so counters, errors and output equal the sequential + loop's. This describes the per-prefix phase 3 measured here. The one-pass phase 3 that replaced it, + and that every order of Init and Mathlib takes, has no tasks to split; the budget now applies only to + the per-prefix path. + +**Identical output.** + +- Tests `parallel_tiered_matches_sequential` and `parallel_tiered_limits_fail_closed` (180 generated + constants plus the §2 fixtures, 6 budgets) compare bytes and the full result, counters included. +- All 56,622 Init constants under budgets (3, 20, 20), (3, 1, 1), (1, 20, 1) and (1, 1, 20): 56,622 / + 56,622 identical bytes and results in each (`--check-sequential`) [X8]. +- On Mathlib, the three runs below produce the same totals, and the eleven constants of the latency + runs give identical bytes under all three budgets [X7]. + +**Whole-corpus throughput, Mathlib, 20 threads, best of three with the Kahn order** [X7]: + +| run | budgets (widths, components, materialize) | processing | GNU `time` elapsed | peak RSS | 1-min load average during the run (min / median / max) | +|---|---|---:|---:|---:|---| +| (a) constant-level only | 1, 1, 1 | 658.8 s | 13:29 | 5,599,052 kB | 12.7 / 34.6 / 44.6 | +| (b) + widths | 3, 1, 1 | 697.3 s | 56:53 (the runner's own total was 956.0 s; not explained) | 5,560,880 kB | 26.7 / 39.4 / 59.0 | +| (c) + components and phase 3 | 3, 20, 20 | 691.2 s | 14:58 | 5,643,528 kB | 20.1 / 41.9 / 52.8 | + +- All three certify all 679,499 constants. The total is 1,121,762,443 bytes under TagN prices; it was + 1,121,777,032 before the Kahn order. +- **With the pool saturated by constant-level work, the extra levels do not raise throughput** on this + shared machine. The load average was 35–42 on 24 hardware threads, so these runs cannot resolve + differences of this size. +- **Per-constant times in corpus mode are not meaningful under (c).** `SimplexCategory.δ₀Iter_δ'` + (N 865) shows 648,944 ms in (c). A thread waiting on a nested join executes other constants' tasks in + the meantime, and the wait is counted against this constant. + +**Per-constant latency** (`--serial-constants`: one constant at a time on a 20-thread pool), for the ten +slowest constants of (a) plus `SimplexCategory.δ₀Iter_δ'` [X7]: + +| constant | N | cand | (a) 1, 1, 1 | (b) 3, 1, 1 | (c) 3, 20, 20 | +|---|---:|---:|---:|---:|---:| +| `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` | 95,110 | 81,833 | 128.4 s | 30.1 s | 20.7 s | +| `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux` | 64,047 | 41,872 | 59.2 s | 8.4 s | 6.4 s | +| `AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective` | 66,025 | 52,066 | 50.2 s | 14.2 s | 6.8 s | +| `…WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three` | 50,027 | 26,233 | 48.5 s | 9.2 s | 5.8 s | +| `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` | 78,913 | 59,202 | 47.8 s | 24.7 s | 6.3 s | +| `WeierstrassCurve.variableChange_Δ` | 63,501 | 18,995 | 44.4 s | 17.7 s | 4.1 s | +| `…RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1` | 70,414 | 61,641 | 40.2 s | 14.0 s | 4.8 s | +| `AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq` | 53,511 | 44,632 | 39.7 s | 13.1 s | 4.5 s | +| `…Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq'` | 53,222 | 38,483 | 28.1 s | 8.1 s | 2.6 s | +| `WeierstrassCurve.isHomogeneous_addSubMapCoeff` | 60,092 | 31,902 | 25.2 s | 7.1 s | 4.7 s | +| `SimplexCategory.δ₀Iter_δ'` | 865 | 450 | 81 ms | 40 ms | 9 ms | +| **sum** | | | **511.8 s** | **146.6 s** | **66.8 s** | +| median 1-min load average during the run | | | 30.7 | 26.9 | 16.9 | + +- (b) runs the three widths together, so its speedup over (a) is about 3.5× for the sum. (c) adds about + 2.2× on top of (b). +- The load average fell between the runs, so the ratios mix the speedup with the change in load. +- Peak RSS was 4.49, 4.51 and 4.64 GB (most of it the loaded corpus). + +## Phase statistics + +The runner reports these statistics only for the K-based construction. The best-of-three runs record +bytes and stored counts per width, not search statistics, and that rule runs phase 1 three times, so the +table below describes one phase-1 run per constant. + +The table covers all certified constants (rootless constants contribute zeros), with nearest-rank +percentiles: + +- **uniform states:** the uniform search's states. Under the old search these are subsets evaluated by + the enumeration; under the new search, branch-and-bound states. +- **first-tier states:** phase 2's branch and bound. +- **Uncertain terms and largest component** cannot be compared one to one between the searches. The new + rules also changed the certain-stored threshold (θ = 1 when no table-count bracket is within reach). + +| statistic | corpus, run | p50 | p90 | p99 | p99.9 | max | +|---|---|---:|---:|---:|---:|---:| +| uncertain terms | Init, old [R1] | 4 | 32 | 143 | 406 | 1,509 | +| | Init, new [R6] | 3 | 22 | 113 | 267 | 978 | +| | Mathlib, old [R2] | 6 | 37 | 147 | 418 | 5,756 | +| | Mathlib, new [R3] | 4 | 25 | 112 | 296 | 3,077 | +| largest component | Init, old [R1] | 2 | 5 | 10 | 16 | 20 | +| | Init, new [R6] | 1 | 3 | 7 | 13 | 57 | +| | Mathlib, old [R2] | 1 | 4 | 9 | 15 | 21 | +| | Mathlib, new [R3] | 1 | 3 | 6 | 13 | 57 | +| uniform states | Init, old [R1] | 15 | 168 | 3,233 | 79,914 | 776,614 | +| | Init, new [R6] | 12 | 90 | 486 | 1,094 | 5,503 | +| | Mathlib, old [R2] | 21 | 157 | 1,729 | 47,638 | 1,046,337 | +| | Mathlib, new [R3] | 16 | 102 | 475 | 1,231 | 12,358 | +| first-tier states | Init, new [R6] | 15 | 91 | 618 | 1,871 | 17,727 | +| | Mathlib, new [R3] | 20 | 128 | 789 | 2,673 | 30,126 | +| R1/R2 candidates | Init [R6] | 33 | 227 | 1,168 | 4,843 | 22,458 | +| | Mathlib [R3] | 66 | 424 | 2,004 | 6,370 | 81,833 | + +- The old-search maxima cover certified constants only, so they exclude the failing constants, which are + the ones with the largest components. +- **Phase-1 width under the K-based rule:** + - TagN layout: Init {1: 23,506, 2: 33,008, 3: 108} [R6]; Mathlib {1: 197,682, 2: 480,001, 3: 1,816} [R3]. + - Tag4 layout: Init {1: 23,506, 2: 31,764, 3: 1,352} [R5]; Mathlib {1: 197,682, 2: 458,516, 3: 23,301} + [R7]. +- **Width chosen by the best of three** (rooted constants), see the experiment section: TagN w = 1 / 2 / 3 + wins 44,046 / 11,156 / 184 on Init and 505,671 / 156,170 / 1,413 on Mathlib [X1]. +- **Uniform-model classes**, from the harness's own classification of the MSS candidate set: + - certain-stored 80.5 / 64.1 / 54.4% on Init and 88.4 / 71.0 / 57.9% on Mathlib, at w = 1 / 2 / 3; + - largest uncertain component ≤ 8 for 99.7–99.9% of constants, max 45 + [Init §Uniform-reference-width classification] [ML §Uniform-reference-width classification and + components]. + +## Slowest constants + +All tables use the TagN layout. Column meanings: + +- `N`: distinct subterms; +- `cand`: R1/R2 candidates; +- `K`: the tiered candidate count; +- `w`: the phase-1 width. + +**Mathlib, best of three** [X1] [R3]. Times are the sum of the three widths' times, measured in the +8-thread run with the machine shared, so they are inflated relative to an idle single thread. + +| ms (sum of 3) | constant | N | cand | K | K-based w | best w | stored at w = 1 / 2 / 3 | ms at w = 1 / 2 / 3 | +|---:|---|---:|---:|---:|---:|---:|---|---| +| 163,721 | `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` | 95,110 | 81,833 | 21,461 | 3 | 2 | 18,653 / 18,877 / 18,440 | 74,674 / 44,791 / 44,256 | +| 84,389 | `WeierstrassCurve.variableChange_Δ` | 63,501 | 18,995 | 9,233 | 3 | 3 | 8,259 / 8,564 / 8,525 | 21,488 / 27,008 / 35,893 | +| 77,150 | `CategoryTheory.Bicategory.mateEquiv_vcomp` | 50,497 | 32,338 | 8,940 | 3 | 2 | 6,947 / 7,533 / 7,367 | 32,773 / 23,864 / 20,512 | +| 68,373 | `Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux` | 64,047 | 41,872 | 8,745 | 3 | 1 | 7,165 / 7,335 / 7,006 | 13,860 / 22,620 / 31,893 | +| 52,355 | `AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective` | 66,025 | 52,066 | 10,555 | 3 | 3 | 8,980 / 9,284 / 8,981 | 9,839 / 22,778 / 19,738 | +| 49,194 | `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` | 78,913 | 59,202 | 13,054 | 3 | 1 | 10,696 / 11,065 / 10,482 | 15,014 / 17,136 / 17,043 | +| 37,653 | `_private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three` | 50,027 | 26,233 | 10,413 | 3 | 3 | 8,545 / 8,943 / 8,673 | 10,723 / 14,022 / 12,908 | +| 37,075 | `_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1` | 70,414 | 61,641 | 11,700 | 3 | 3 | 9,464 / 10,262 / 10,024 | 11,838 / 12,668 / 12,569 | +| 37,029 | `WeierstrassCurve.isHomogeneous_addSubMapCoeff` | 60,092 | 31,902 | 10,150 | 3 | 2 | 7,846 / 8,152 / 8,031 | 6,283 / 13,954 / 16,792 | +| 33,626 | `WeierstrassCurve.Affine.addPolynomial_slope` | 35,899 | 20,245 | 5,956 | 3 | 3 | 5,150 / 5,361 / 5,253 | 8,689 / 11,987 / 12,951 | + + +**Init, best of three, single thread** [X3] [R6]. This run overlapped the 8-thread Mathlib Tag4 experiment, so the per-width times are higher than [R6]'s for the same constant at its K-based width. For example, `…Vector.extract_append._proof_1` at w = 3 took 3,031 ms here and 1,133 ms in [R6]. + +| ms (sum of 3) | constant | N | cand | K | K-based w | best w | stored at w = 1 / 2 / 3 | ms at w = 1 / 2 / 3 | +|---:|---|---:|---:|---:|---:|---:|---|---| +| 8,801 | `_private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1` | 26,943 | 19,283 | 5,136 | 3 | 2 | 4,280 / 4,474 / 4,427 | 2,847 / 2,923 / 3,031 | +| 8,644 | `_private.Init.Data.Array.Extract.0.Array.extract_append._proof_1_1` | 26,754 | 19,091 | 5,146 | 3 | 2 | 4,247 / 4,454 / 4,403 | 2,901 / 2,828 / 2,915 | +| 8,028 | `_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | 27,628 | 22,458 | 4,874 | 3 | 2 | 4,076 / 4,067 / 3,785 | 2,654 / 2,806 / 2,569 | +| 6,252 | `_private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1` | 24,507 | 17,140 | 4,678 | 3 | 3 | 3,939 / 4,107 / 4,059 | 1,980 / 2,267 / 2,005 | +| 5,975 | `Lean.Grind.Config.mk.injEq` | 3,512 | 551 | 360 | 2 | 1 | 281 / 192 / 187 | 4,450 / 873 / 652 | +| 5,167 | `_private.Init.Data.Vector.Extract.0.Vector.extract_append_extract._proof_1` | 24,658 | 17,290 | 4,703 | 3 | 3 | 3,981 / 4,143 / 4,097 | 1,616 / 1,719 / 1,831 | +| 5,165 | `_private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1` | 26,494 | 19,017 | 4,919 | 3 | 3 | 4,127 / 4,303 / 4,279 | 1,375 / 1,644 / 2,146 | +| 4,215 | `_private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1` | 19,523 | 11,454 | 3,640 | 3 | 3 | 3,108 / 3,135 / 3,121 | 1,420 / 1,363 / 1,432 | +| 2,631 | `_private.Init.Data.Int.DivMod.Lemmas.0.Int.add_one_tdiv._proof_1_1` | 18,802 | 13,281 | 3,236 | 3 | 3 | 2,782 / 2,793 / 2,740 | 740 / 782 / 1,109 | +| 2,469 | `_private.Init.Data.Vector.Extract.0.Vector.extract_add_left._proof_1` | 14,521 | 8,259 | 2,854 | 3 | 3 | 2,412 / 2,494 / 2,464 | 830 / 823 / 816 | + + +**Init, K-based (superseded), single thread** [R6]: + +| ms | constant | N | cand | K | w | uncertain | components (largest) | uniform / first-tier states | +|---:|---|---:|---:|---:|---:|---:|---|---| +| 2,261 | `_private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1` | 26,494 | 19,017 | 4,919 | 3 | 587 | 555 (3) | 2,351 / 8,577 | +| 1,431 | `_private.Init.Data.Array.Extract.0.Array.extract_append._proof_1_1` | 26,754 | 19,091 | 5,146 | 3 | 687 | 651 (3) | 2,721 / 13,228 | +| 1,133 | `_private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1` | 26,943 | 19,283 | 5,136 | 3 | 660 | 621 (3) | 2,609 / 17,727 | +| 1,039 | `_private.Init.Data.Vector.Extract.0.Vector.extract_append_extract._proof_1` | 24,658 | 17,290 | 4,703 | 3 | 557 | 517 (4) | 2,193 / 4,104 | +| 968 | `…ForwardSliceSearcher.Invariants.isValidSearchFrom_toList` | 27,628 | 22,458 | 4,874 | 3 | 978 | 826 (6) | 3,826 / 3,793 | +| 884 | `_private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1` | 24,507 | 17,140 | 4,678 | 3 | 571 | 530 (4) | 2,247 / 4,066 | +| 636 | `Lean.Grind.Config.mk.injEq` | 3,512 | 551 | 360 | 2 | 185 | 14 (44) | 4,177 / 199 | +| 593 | `…Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'` | 16,156 | 11,692 | 2,712 | 3 | 349 | 299 (4) | 1,375 / 9,252 | +| 503 | `_private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1` | 19,523 | 11,454 | 3,640 | 3 | 454 | 435 (4) | 1,816 / 3,143 | +| 436 | `_private.Init.Data.Vector.Extract.0.Vector.extract_add_left._proof_1` | 14,521 | 8,259 | 2,854 | 3 | 332 | 310 (3) | 1,310 / 4,936 | + +## Lean/Rust parity + +How the differential counts: + +- For each mode it compares the complete serialized constant from Lean and from Rust. +- A resource exhaustion on both sides counts as agreement of the error category. +- A one-sided exhaustion is reported. `diagnose` then reruns Lean with the limit that fired doubled, at + most 12 times. + +**Best of three** (the canonical rule, Lean *b3-lean* and Rust *b3-rust*): + +| corpus | build | mode | same bytes | same error | Lean-only exhaustion | Rust-only | disagreements | source | +|---|---|---|---:|---:|---:|---:|---:|---| +| fixtures (§2), 7 modes | *b3-rust* | | 89 | 0 | 0 | 0 | 0 | [D7] | +| 350 generated inputs × modes | *b3-rust* | | 2,398 | 0 | 0 | 0 | 0 | [D7] | +| Init, all | *b3-rust* | tiered-TagN | **56,622** | 0 | 0 | 0 | **0** | [D7] | +| | | tiered-Tag4 | **56,622** | 0 | 0 | 0 | **0** | [D7] | +| Init, all, **Kahn order** | *kahn* | tiered-TagN | **56,622** | 0 | 0 | 0 | **0** | [D9] | +| | | tiered-Tag4 | **56,622** | 0 | 0 | 0 | **0** | [D9] | +| Mathlib sample | *b3-rust* | tiered-TagN, tiered-Tag4 | aborted, no tallies | | | | | [D8] | + +**K-based (superseded):** + +| corpus | build | mode | same bytes | same error | Lean-only exhaustion | Rust-only | disagreements | source | +|---|---|---|---:|---:|---:|---:|---:|---| +| fixtures (§2), 7 modes | every build | | 89 | 0 | 0 | 0 | 0 | [D1]–[D6] | +| 350 generated inputs × modes | every build | | 2,398 | 0 | 0 | 0 | 0 | [D1]–[D6] | +| Init, all | old (*diff-1*) | tiered-TagN | 56,587 | 25 | 10 | 0 | **0** | [D1] | +| | | tiered-Tag4 | 56,583 | 29 | 10 | 0 | **0** | [D1] | +| | | uniform-w2 | 56,594 | 28 | 0 | 0 | **0** | [D1] | +| Init, all | new (*k-bb*) | tiered-TagN | 56,612 | 0 | 10 | 0 | **0** | [D2] | +| | | uniform-w2 | 56,622 | 0 | 0 | 0 | **0** | [D2] | +| Mathlib sample | old (*diag*) | tiered-TagN | 20,056 | 101 | 106 | 0 | **0** | [D3] | +| | | uniform-w2 | 20,162 | 99 | 2 | 0 | **0** | [D3] | +| Mathlib sample | new (*k-bb*) | tiered-TagN | 20,143 | 0 | 120 | 0 | **0** | [D4] | +| | | uniform-w2 | 20,263 | 0 | 0 | 0 | **0** | [D4] | +| the 120 + 10 Lean-only constants | *work-limit* | tiered-TagN (and Tag4 for the 10 Init) | 120 + 10 (+ 10) | 0 | 0 | 0 | **0** | [D5] | +| **Mathlib, half the corpus** (3 of 6 address shards) | *work-limit* | tiered-TagN | **339,749** | 0 | 0 | 0 | **0** | [D6] | + +- **One-sided exhaustions.** After `diagnose` raised the limit that fired, every Lean-only exhaustion in + every run gave bytes equal to Rust's [D0] [D3] [D4]. With `maxMaterializeWork` (*work-limit* onwards) + there were none in [D5]–[D7]. +- **The aborted run [D8].** The best-of-three Mathlib-sample differential was stopped + after 2 h 5 min, at 07:23 on 2026-10-01. It used the phase-2 order that §12.14 replaces, so the + Kahn-order rerun would supersede it, and the CPU was needed for other builds. Each + process buffers its output until the end, so no tally was written. Each log ends with GNU `time`'s "Command terminated by signal 15", an + elapsed time of 2:04:51–2:04:57 and the wrapper's `exit=143`. +- **The half-corpus run [D6].** The constants were split round-robin into 6 address shards, one process + each. Three processes ended without writing anything beyond the build warnings and without the + wrapper's exit line; the cause is unexplained. The other three covered 113,249 + 113,250 + 113,250 + constants (every constant whose position in the address list is 0, 3 or 4 mod 6). +- **Exit status of [D3].** Its two processes exited with status 1 after all groups had passed. The test + driver then failed to spawn `lean`, which was not on their `PATH` [D3]. +- **Rust-only tests.** `cargo test -p ixon` passes 392 tests at *b3-rust*. Among them are the comparison + of the branch and bound against the enumeration on 600 generated inputs, and the best-of-three selection + rule against the forced-width candidates (`tiered_at_width_hook`, now + `tiered_selects_the_best_width_candidate`). + +## The phase-1 width experiment + +This experiment led to plan §12.11. It was run with an experiment hook, before either implementation's +canonical entry point adopted the rule. The best-of-three figures in [Bytes](#bytes) come from it. + +The hook and the runner mode were removed after the experiment (the forced-width entry point remains as a +crate-private test helper), so reproducing this section needs the commits in the Sources table. + +**Hypothesis.** The K-based rule picks the nominal width from `K`, but the optimum stores far fewer terms +than `K`, so the real references are narrower than modelled. With `K = 100`, for example, TagN gives +`w = 2`. If only 6 terms are stored, every reference costs 1 byte, and the `w = 2` model may have +excluded terms that pay at width 1. + +**Method.** + +- **The hook.** `normalize_constant_sharing_tiered_at_width` (*width-hook*) runs phases 1–3 with the + phase-1 width forced to `w`. Phases 2 and 3 are unchanged. At the K-based width it reproduces the + canonical construction (test `tiered_at_width_hook` at that commit; it is now + `tiered_selects_the_best_width_candidate`, which checks that the canonical construction is the best of + the three forced-width candidates). +- **The runner.** `--width-experiment` (removed after the experiment) ran the hook at `w = 1, 2, 3` for + every constant and recorded the layout bytes of each width. +- **The choices compared:** + - K-based (superseded); + - best of three; + - re-solve: take `w = uniform_width(stored count of the K-based run)` (the K-based width function, + since removed) and solve once at that width; + - one fixed `w` for every constant. +- **Pricing.** MSS is priced at the same widths, scheme F for TagN and scheme A for Tag4, over rooted + constants. +- **Certification.** Every width certified every constant on both corpora under both layouts: 0 failures + at `w = 1`, 2 and 3 [X1] [X2]. + +### TagN layout [X1] + +| | Init bytes | vs MSS (F) | Mathlib bytes | vs MSS (F) | +|---|---:|---:|---:|---:| +| MSS (F) | 67,556,587 | | 1,130,381,317 | | +| K-based (superseded) | 66,990,376 | −566,211 (−0.84%) | 1,135,611,532 | +5,230,215 (+0.46%) | +| **best of three** | **66,602,235** | **−954,352 (−1.41%)** | **1,121,167,486** | **−9,213,831 (−0.82%)** | +| re-solve | 66,913,395 | −643,192 (−0.95%) | 1,134,824,013 | +4,442,696 (+0.39%) | +| `w = 1` for every constant | 66,771,574 | −785,013 (−1.16%) | 1,122,848,598 | −7,532,719 (−0.67%) | +| `w = 2` for every constant | 67,050,223 | −506,364 | 1,135,414,511 | +5,033,194 | +| `w = 3` for every constant | 67,791,486 | +234,899 | 1,151,346,211 | +20,964,894 | + +Against the K-based rule, the best of three saves 388,141 B (−0.58%) on Init and 14,444,046 B (−1.27%) on +Mathlib. + +| per constant | Init | Mathlib | +|---|---|---| +| best-of-three width (rooted): w = 1 / 2 / 3 | 44,046 / 11,156 / 184 | 505,671 / 156,170 / 1,413 | +| best of three vs K-based (all constants): better / equal | 20,651 / 35,971 | 297,121 / 382,378 | +| re-solve vs K-based (all constants): better / equal / worse | 7,339 / 48,569 / 714 | 64,033 / 600,933 / 14,533 | +| K-based vs MSS: smaller / equal / larger | 23,132 / 22,616 / 9,638 | 242,375 / 199,829 / 221,050 | +| **best of three vs MSS: smaller / equal / larger** | **32,236 / 23,145 / 5** | **405,832 / 256,519 / 903** | +| re-solve vs MSS: smaller / equal / larger | 27,370 / 23,365 / 4,651 | 263,473 / 225,637 / 174,144 | + +**Remaining losses of the best of three against MSS (TagN)** [X1]: + +- **Init**, all 5 losses, all with best `w = 1`: + - +6: `…Std.Iterators.Types.FilterMap.instFinitenessRelation._proof_2` (K 241); + - +4: `instLawfulMonadAttachStateTOfLawfulMonad` (K 178); + - +3: `…ULiftIterator.instFinitenessRelation._proof_2` (K 246); + - +1: `Std.IterM.length_uLift` (K 856); + - +1: `Std.Iter.all_filterMap` (K 324). +- **Mathlib**, the ten largest of 903: + - +1,485: the outlier below; + - the other nine, all with best `w = 1`: `equalizerCondition_yonedaPresheaf` +37 (K 894), + `SheafOfModules.Presentation.mk.injEq` +32 (K 553), + `SheafOfModules.relationsOfIsCokernelFree._proof_2` +29 (K 822), + `Algebra.Extension.CotangentSpace.map_comp` +26 (K 1,457), `SheafOfModules.Presentation.mk.inj` +25 + (K 487), `SheafOfModules.Presentation.noConfusionType` +23 (K 351), + `AlgebraicGeometry.SheafedSpace.IsOpenImmersion.image_preimage_is_empty` +21 (K 949), + `CategoryTheory.MonoidalCategory.externalProductFlip._proof_8` +20 (K 340) and + `Std.DTreeMap.Internal.Impl.link2.fun_cases` +18 (K 241). + - 902 of the 903 losses are at most +37 bytes (p99.9 of best − MSS is +1). + +### The outlier + +`Affine.Triangle.dist_orthogonalProjectionSpan_faceOpposite_eq_iff_two_zsmul_oangle_eq`, address +`048653e65a77d222…`, a `defn`. + +| quantity | value | source | +|---|---:|---| +| distinct subterms `N` | 19,417 | [ML] CSV, [R3] | +| R1/R2 candidates | 8,801 | [ML] CSV, [R3] | +| `K` (in-degree ≥ 2, unshared length ≥ 2) = MSS table size | 2,230 | [X1], [ML] CSV `mss_table` | +| heuristic: stored bytes / table entries | 96,389 / 8,591 | [ML] CSV | +| unshared bytes | 13,329,184 | [ML] CSV | +| MSS: Tag4 bytes / TagN-priced bytes | 72,195 / 63,779 | [ML] CSV, join | +| MSS Share references at indices < 8 / 8–1,031 / ≥ 1,032 | 1,101 / 13,699 / 4,149 (Σ deg 18,949) | [ML] CSV | +| tiered TagN at w = 1: stored / bytes | 1,924 / 65,444 | [X1] CSV | +| tiered TagN at w = 2: stored / bytes (best) | 1,895 / **65,264** | [X1] CSV | +| tiered TagN at w = 3 (= K-based): stored / bytes | 1,755 / 65,325 | [X1] CSV, [R3] | +| best of three − MSS (TagN) | **+1,485** | [X1] | +| K-based run: uncertain terms / components (largest) / uniform states / first-tier states | 421 / 347 (5) / 1,604 / 1,760 | [R3] | +| K-based run: Tag4-serialized bytes | 70,451 | [R3] | +| old search (K-based) | `resource:States` | [R2] | +| tiered TagN times at w = 1 / 2 / 3 (8 threads, shared) | 2,018 / 1,979 / 1,703 ms | [X1] CSV | +| Tag4 layout: bytes at w = 1 / 2 / 3, MSS (A) | 72,606 / **70,422** / 70,451; MSS 72,195 (best − MSS = −1,773) | [X2] CSV | + +All three widths store 1,755–1,924 terms, fewer than MSS's 2,230, and all three end at least 1,485 bytes +above MSS. The best-of-four experiment below stores MSS's exact set as a fourth candidate. + +### Tag4 layout [X2] + +| | Init bytes | vs MSS (A) | Mathlib bytes | vs MSS (A) | +|---|---:|---:|---:|---:| +| MSS (A) | 68,547,873 | | 1,148,195,956 | | +| K-based (superseded) | 67,701,399 | −846,474 (−1.23%) | 1,150,611,314 | +2,415,358 (+0.21%) | +| **best of three** | **67,255,886** | **−1,291,987 (−1.88%)** | **1,135,005,370** | **−13,190,586 (−1.15%)** | +| re-solve | 67,592,721 | −955,152 (−1.39%) | 1,148,702,659 | +506,703 (+0.04%) | +| `w = 1` for every constant | 67,528,222 | −1,019,651 (−1.49%) | 1,138,024,409 | −10,171,547 (−0.89%) | +| `w = 2` for every constant | 67,694,849 | −853,024 | 1,148,160,385 | −35,571 | +| `w = 3` for every constant | 68,358,800 | −189,073 | 1,161,814,219 | +13,618,263 | + +| per constant | Init | Mathlib | +|---|---|---| +| best-of-three width (rooted): w = 1 / 2 / 3 | 43,904 / 10,981 / 501 | 501,851 / 157,708 / 3,695 | +| best of three vs K-based (all constants): better / equal | 20,985 / 35,637 | 299,934 / 379,565 | +| re-solve vs K-based (all constants): better / equal / worse | 7,902 / 47,974 / 746 | 73,526 / 591,110 / 14,863 | +| **best of three vs MSS: smaller / equal / larger** | **32,239 / 23,144 / 3** | **405,933 / 256,460 / 861** | + +**Remaining losses of the best of three against MSS (Tag4)** [X2]: + +- **Init:** 3 losses, the same constants as the top three under TagN: +6, +4 and +3. +- **Mathlib:** 861 losses. The largest is +266, `Algebra.Extension.Cotangent.map_toInfinitesimal_bijective` + (K 730, best `w = 1`). The next nine are +98 to +156: `Module.isBaseChange_map_of_finite_free` +156, + `VectorField.DifferentiableWithinAt.pullbackWithin` +135, `LinearEquiv.image_closure_of_convex'` +129, + `IsBaseChange.end` +125, `…Algebra.Generators.H1Cotangent.auxMemKer` +123, `TensorProduct.adjoint_map` + +113, `RingHom.Flat.tensorProductMap` +109 (the only one with best `w = 3`), + `LinearMap.tensorEqLocusEquiv._proof_3` +100 and + `instOrderIsoClassContinuousLinearMapIdOfNonUnitalAlgEquivClassOfStarHomClassOfContinuousMapClass` +98. + For all ten the K-based width was 3. +- **The TagN outlier** above is 1,773 bytes *smaller* than MSS under Tag4. + +### Best of four (rejected, plan §12.14) [X4] + +**Method.** A fourth phase-1 candidate, "all", stores every candidate: compact in-degree ≥ 2 and +unshared length ≥ 2, which is exactly MSS's set. Its bodies are materialized at uniform width 1 and +carried through phases 2 and 3 like the others (hook `Phase1Choice::AllCandidates`, *best-of-four*, removed after the experiment). The best +of four takes the fewest layout bytes, with ties going to w = 1, 2, 3 and then "all". No candidate failed +on any constant of either corpus under either layout. + +| | Init, TagN | Mathlib, TagN | Init, Tag4 | Mathlib, Tag4 | +|---|---:|---:|---:|---:| +| best of four, rooted bytes | 66,602,218 | 1,121,164,590 | 67,255,871 | 1,135,003,221 | +| change vs best of three (all constants) | −17 | −2,896 | −15 | −2,149 | +| constants where "all" wins | 7 | 1,131 | 5 | 992 | +| best of four vs MSS: smaller / equal / larger | 32,237 / 23,149 / **0** | 405,889 / 257,363 / **2** | 32,240 / 23,146 / **0** | 405,989 / 257,170 / **95** | +| best of four − MSS, max | 0 | +1,485 | 0 | +266 | + +- **The remaining losses.** + - Mathlib TagN: the outlier (+1,485) and `Algebra.Extension.CotangentSpace.map_comp` (+26). + - Mathlib Tag4: the ten largest are the same ten constants, with the same losses (+266 to +98), as + under the best of three; for each of them the best candidate is still a uniform width. +- **Decision.** Not adopted [P §12.14]: 2,896 bytes over all of Mathlib (TagN) does not justify a fourth + pass. +- **Cost.** Four candidates per constant took 1,021.8 s (TagN) and 1,141.4 s (Tag4) of processing over + Mathlib on 12 threads, with peak RSS 4.87 and 5.02 GB [X4]. + +**The outlier, diagnosed (plan §12.14, resolved in §12.15).** + +- Under "all", the outlier stores MSS's exact set (2,230 entries), yet ends at 67,367 bytes under TagN. + That is worse than its own `w = 2` candidate (65,264) and 3,588 bytes worse than MSS (63,779) [X4] CSV. + Under Tag4 "all" gives 72,065. +- §12.14 first attributed the gap to phase 2's pinned order beyond the first tier. Phase 2 now uses the + Kahn priority order by reference count there (Lean *kahn-lean*, Rust *kahn-rust*), and this does not + close the gap [X6]: + - TagN bytes at w = 1 / 2 / 3: 65,444 / 65,264 / **65,247**; "all" 67,367 (unchanged). + - The best of three is now 65,247, +1,468 over MSS (was +1,485). + - Tag4 at w = 1 / 2 / 3: 72,405 / **70,422** / 70,623; "all" 72,065. +- The cause is the **tie-break inside the Kahn order** [X5] [P §12.15]. Re-implemented in Rust, MSS + (every candidate stored, Kahn order by in-degree, every occurrence a Share) gives on the outlier: + + | encoding | TagN bytes | Tag4 bytes | Shares at TagN widths 1 / 2 / 3 bytes | + |---|---:|---:|---| + | MSS, ties by blake3 hash (the harness's `mssBuild` rule) | **63,779** | **72,195** | 1,101 / 13,699 / 4,149 | + | MSS, ties by structural ID | 67,367 | 72,071 | 1,101 / 10,111 / 7,737 | + | "all" (tiered phases 2 and 3 on MSS's set) | 67,367 | | 1,101 / 7,891 / 7,737 | + + - The blake3-tie MSS reproduces the Mathlib harness's MSS bytes and scheme-F price exactly [ML]. + - The ID-tie MSS and "all" have the same table order (no entry at a different index) and the same + total entry and root lengths (28,683 and 32,421). + - "all" writes 2,220 occurrences of size-2 stored terms inline. A 2-byte Share and a 2-byte inline + write cost the same, so the total is unchanged. + - The two MSS orders differ for 2,175 of the 2,230 entries. With the table straddling the TagN 1,032 + boundary, the tie order decides which entries become available early and so reach the 2-byte rung. + - Under Tag4 the ID order is the better of the two, by 124 bytes. + +### Store-all against MSS under both tie rules (plan §12.15) [X5] + +All 679,499 Mathlib constants, TagN prices. "all" is the all-candidates construction with the Kahn order. +The comparison ran with the runner modes `--mss-compare` and `--mss-ties` at *mss-hooks*; those modes, the +MSS inspector and the blake3 tie rule were removed after the experiment, and the Rust MSS encoding +(`mss.rs`) is now a test-only reference encoding. + +| comparison | "all" larger | "all" smaller | equal | total difference | +|---|---:|---:|---:|---:| +| "all" − MSS with structural-ID ties | **0** | 157,438 | 522,061 | −1,227,943 B | +| "all" − MSS with blake3 ties | 206 (+22,185 B, max +3,588) | 166,865 | 512,428 | −1,602,326 B | + +- **Totals:** + - MSS with ID ties: 1,130,616,480 B. + - MSS with blake3 ties: 1,130,990,863 B. This equals [ML]'s scheme-F rooted total plus the 609,546 + rootless bytes. Its Share bytes, 280,471,878, equal [ML]'s scheme-F reference bytes. + - "all": 1,129,388,537 B. +- **Shares:** both MSS variants write 159,110,515 Shares; "all" writes 145,331,762. "all" writes + 13,778,893 occurrences of stored terms inline, in 239,559 constants. +- **Every "all" loss is a tie-break effect.** For each of the 206 constants where "all" is larger than + blake3-tie MSS, ID-tie MSS is at least as large as "all". +- **The tie rule itself:** + - ID ties are better than blake3 ties overall, by 374,383 B. + - ID ties win on 36,846 constants, blake3 ties on 23,605, and 619,048 are equal. + - The largest ID advantage is 6,980 B (`CartanMatrix.E₈_det`); the largest blake3 advantage is the + outlier's 3,588 B. + - Taking the better rule per constant would gain 119,735 B (0.011%). +- **Twenty constants examined entry by entry** (`--mss-diff`, a runner mode removed after the experiment) where "all" and MSS differ by more than 1%: + - The 7 where "all" exceeds blake3-tie MSS by more than 1%: in each, ID-tie MSS is at least as large as + "all", and blake3 ties beat ID ties under TagN. + - 13 random constants of the 8,440 where "all" is more than 1% below ID-tie MSS: "all" gains through + the exact first tier, which puts more references in the 1-byte slots (for example 198 → 239 in + `LinearMap.toMatrix₂`), and through phase 3 writing a stored term inline where its Share would cost + at least as much. +- **Decision.** No rule change; structural-ID ties stay pinned [P §12.15]. The order beyond the first + tier is a greedy rule. An exact maximum-weight closed set for the 1,032-entry second rung is a possible + refinement, not adopted. +- **Against the best of three.** The best of three (*width-hook*, before the Kahn order) is larger than + ID-tie MSS on 902 constants, by +2,504 B in total and at most +37 bytes [X1] [X5]. + +### What the experiment shows + +- **The hypothesis holds on these corpora.** The excess over MSS came from the nominal width. With the + best of the three widths, 5 Init and 903 Mathlib constants remain larger than MSS (TagN), against 9,638 + and 221,050 under the K-based rule. +- **`w = 1` wins most often**, for 76% of rooted Mathlib constants. +- **Re-solving once from the stored count is not enough.** On Mathlib it stays above MSS (+0.39%) and is + worse than the K-based rule on 14,533 constants. +- **Cost.** Three constructions per constant instead of one; see + [Wall time and memory](#wall-time-and-memory). + +## Format v4: the TagN-only wire with six rungs + +These results come from the code as of *six-rung* and *knapsack-limit*. Those corpora still have the header +byte `0xE3` and heuristic sharing tables: the version flip to 4 (`0xE4`) and the canonical compiler route +came later. + +**What changed.** Ixon now writes TagN for every integer (*tagn-only*), and the TagN code gained a +4-byte rung (*rung4*): the widths are 1, 2, 3, 4, 5 and 9 bytes [P §12.12] [P §12.16]. The v3 +corpora above can no longer be read; this is by design. The tiered construction now uses TagN only +(*six-rung*). + +### Corpora + +The corpora were regenerated at *six-rung* and are named after that commit [C1]: + +| | Init | Mathlib | +|---|---:|---:| +| file | `$S/init_v4r_six-rung.ixe` | `$S/mathlib_v4r_six-rung.ixe` | +| size | 155,259,078 B | 2,620,063,965 B | +| compile time (GNU `time`, wall; under load) | 0:51.10 | 3:51.09 | +| compile peak RSS | 2,945,116 kB | 18,726,024 kB | +| stored constants | 56,622 | 679,499 | +| stored (heuristic) bytes, all constants | 78,231,552 | 1,422,321,971 | + +- The Init corpus was produced with `lake exe ix compile Benchmarks/CompileInit.lean`. +- The Mathlib corpus was produced with `lake exe ix compile Benchmarks/Compile/CompileMathlib.lean`, + using the dependency build of the v3 Mathlib corpus (`Benchmarks/Compile/.lake`) copied read-only. +- Both used the compiler's heuristic sharing route, since the route switch had not landed. The + compile times were taken under heavy load: back to back on a quieter machine, the same binary + compiles Mathlib in 1:46.6–1:55.4 and Init in 0:09.2 [C2] [C3]. +- **With the canonical route and version 4** (*v4-flip*), `lake exe ix compile Benchmarks/CompileInit.lean` + writes 143,680,738 bytes (`Total constants: 65995`); the compile step took 51.6 s, GNU `time` 0:55.74 + wall and 2,963,976 kB peak RSS, on a loaded machine, so the times are indicative. The Mathlib compile at + that commit was not completed; [Final route](#final-route-compile-time-and-the-optimized-construction) + measures both compiles at later commits. + +### Rust canonical construction (best of three, Kahn order), 20 threads [R10] + +| | Init | Mathlib | +|---|---:|---:| +| certified | 56,622 / 56,622 | 679,498 / 679,499 (see below) | +| serialized output, certified constants | 66,644,219 B (−14.81%) | 1,121,360,414 B (−21.16%) | +| per constant against stored: smaller / equal / larger | 50,400 / 6,174 / 48 | 627,142 / 51,871 / 485 | +| largest per-constant loss against stored | +7 B | +28 B | +| processing | 32.6 s | 772.3 s | +| wall (GNU `time`) | 0:39.93 | 16:52.30 | +| peak RSS | 754,936 kB | 4,713,784 kB | + +- The serialized length and the TagN price coincide now that TagN is the wire code. +- **Tables are far below the new rung.** No canonical table reaches 66,568 entries: a stored set is + part of the `K` candidates, and the largest `K` is 21,461. So the 4-byte rung does not change any + Share width in these outputs. +- Integers of 66,568 or more in other fields now take 4 bytes instead of 5 in both the stored and the + canonical encodings. The construction's decisions before and after the rung + change were not compared on the same input, since no old-rung reader exists for the v4 corpus. +- **The one failure, and its fix** [X9]. + - The failing constant was `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite`, + which hit `resource:States` at every width. + - Under TagN (f = 0) the table-count bracket starts at 16,512, which this constant's roughly 18.5k + stored entries cross. The knapsack over its roughly 2,550 components therefore needed about 6 + million cells, which were charged to `max_states` (2^20). + - *knapsack-limit* gives the knapsack its own limit, `max_knapsack_cells` (default 2^28), with resource + `KnapsackCells`. The rule is unchanged [P]. + - At default limits the constant now certifies: + + | width | stored | bytes | time (width experiment, 4 threads) | + |---|---:|---:|---:| + | w = 1 | 18,653 | 338,539 | 89.6 s | + | w = 2 | 18,877 | **337,241** (best of three) | 48.6 s | + | w = 3 | 18,440 | 340,770 | 38.0 s | + +### Lean/Rust parity on the v4 corpora (IxTests at *six-rung*) + +| corpus | mode | constants | same bytes | same error | Lean-only | Rust-only | disagreements | Lean Σ | Rust Σ | source | +|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---| +| Init, all | tiered-TagN | 56,622 | **56,622** | 0 | 0 | 0 | **0** | 3,438.0 s | 350.0 s | [D10] | +| Mathlib sample | tiered-TagN | 20,265 | **20,264** | 1 | 0 | 0 | **0** | 35,494.4 s | 2,687.7 s | [D11] | + +- The Init run used 6 processes, each taking 7:04–13:06 with a peak RSS of about 839 MB. +- In every process, the §2 fixtures (76), the generated inputs (2,048) and the 124 Share-bearing + constants agree [D10] [D11]. +- **The Mathlib sample** has 20,265 constants: every 50th of the v4 corpus plus every constant with + more than 2,000 candidates, selected by the runner [R10]. The run used 8 processes, one per address + shard (the sample split round-robin), with IxTests built at *six-rung*. Each process took + 1:01:52–1:40:01, with a peak RSS of about 4.0 GB. +- **The one same-error constant** is `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` + (address `ca5b91d8…`). Lean and Rust both fail with a resource-limit error (the differential's error + category `resource`), which counts as agreement of the error category, not as a one-sided exhaustion. + The differential does not record which limit fired; the runner at the same commit reports Rust's as + `resource:States` at every width [X9]. It is the table-count knapsack case above: with the separate + knapsack-cell limit of *knapsack-limit* the constant certifies. +- **Reproduction.** Build `IxTests`, write the sample with the runner's `--select-out` (as in [R10]), + split it round-robin into 8 address files, and run one process per file: + + ```text + nix develop --command bash -c 'lake build IxTests' + for i in 0 1 2 3 4 5 6 7; do + IX_SHARING_CORPUS=$S/mathlib_v4r_six-rung.ixe IX_SHARING_CORPUS_MODES=tiered-tagN \ + IX_SHARING_CORPUS_SELECT=$S/ml_shards/s$i.txt \ + ./.lake/build/bin/IxTests exact-sharing-ffi > $S/ml_s$i.log 2>&1 & + done + ``` + + A build at or after *knapsack-limit* needs the matching Lean knapsack-cell limit (`maxKnapsackCells`, + *knapsack-lean*; both implementations have it from then on). Without it + `CategoryTheory.Functor.IsDenseSubsite…` can be exhausted on one side only. From *review-fixes* on, the + differential's Rust side runs in the checked mode ([Checks](#checks-default-and-checked-mode-r12)), + so its Rust Σ is not the compiler's time. +- **Superseded.** These runs predate the route switch and the optimizations of both constructions. + The final differential below, at this PR's head on corpora compiled there with the canonical + route, replaces them. + +### Final Lean/Rust differential (this PR's head) + +The tree is this PR's head, and the corpora are compiled with `ix compile` at that head (the +canonical route). The differential runs in corpus mode, `tiered-tagN`, with the Rust side in the +checked mode, so every Rust candidate is built and verified. + +| corpus | constants | same bytes | same error | Lean-only | Rust-only | disagreements | Lean Σ | Rust Σ (checked) | processes | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---| +| Init, all | 56,622 | **56,622** | 0 | 0 | 0 | **0** | 204 s | 63 s | 6, about 50 s wall each | +| Mathlib sample | 20,284 | **20,284** | 0 | 0 | 0 | **0** | 944 s | 346 s | 8, about 3 min wall and 3.8 GB each | + +- The Mathlib sample is every 50th constant plus every constant with more than 2,000 candidates. + `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite`, which failed + identically on both sides in [D11], succeeds on both. +- **Rust over the whole corpora** (`sharing_corpus`, 20 threads): all 56,622 Init and + all 679,499 Mathlib constants succeed. Re-running the construction on each stored constant + reproduces the stored bytes for every constant of both files (0 smaller, 0 larger): the compiled + output is a fixed point of the construction. No candidate took the per-prefix phase 3. + Processing took 3.1 s (Init) and 54.4 s (Mathlib) of wall time; the stored constant bytes are + 66,653,874 (Init) and 1,121,703,681 (Mathlib). +- **Rust in the default mode**, for comparison: all of Init single-threaded in 24.4 s; summed + per-constant times at 20 threads 48.7 s (Init), 824.0 s (Mathlib) and 183.4 s (the Mathlib + sample). +- The merge-queue suite `lake test -- --ignored compile` (the Lean and the Rust compiler on every + constant of its test environment, 237,295 constants, with exact equality of the serialized + environments) also passes. + +## Final route: compile time and the optimized construction + +After the measurements above, the canonical construction became the compilers' only sharing route. +The Rust construction was then made faster without changing a byte: an incremental and then a +one-pass phase 3 (behind a run-time check that the phase-2 order is closed under stored descendants, +with the per-prefix path as fallback), width-independent tables shared by the three widths, a +rank-based table-count knapsack, a phase-1 dry run that builds no expression trees for the +intermediate result, and smaller changes. The Lean construction gained fast implementations, each +proved equal to its specification (`docs/sharing-minimum-integration.md`, §4). + +**Machine.** AMD Ryzen AI 9 HX 370 (12 cores, 24 hardware threads), 93.6 GiB of RAM. Other jobs ran +on it during every measurement below, so the figures are indicative; the 1-minute load average at the +start of each run is given where it was recorded. + +### `ix compile`: heuristic route against canonical route [C2] [C3] + +The heuristic route is the `ix` binary built at *six-rung*, before the route switch, when the compiler +still used the heuristic: it writes the same environments with heuristic sharing tables (TagN integers, implicit arenas, +header `0xE3`). Each pair ran back to back, heuristic first, so the load at the start of a canonical +run includes the heuristic compile that had just ended. + +| Mathlib | binary | wall | user CPU | peak RSS | load at start | +|---|---|---:|---:|---:|---:| +| pair [C2], heuristic | *six-rung* | 1:55.43 | 1,653.3 s | 19,157,400 kB | 7.8 | +| pair [C2], canonical | *optimized-main* | 2:29.81 | 2,293.8 s | 18,659,548 kB | 19.0 | +| pair [C3] a, heuristic | *six-rung* | 1:50.86 | 1,628.0 s | 18,827,240 kB | 3.0 | +| pair [C3] a, canonical | *optimized* | 2:17.84 | 2,213.1 s | 18,765,916 kB | 15.9 | +| pair [C3] b, heuristic | *six-rung* | 1:46.62 | 1,599.5 s | 19,027,544 kB | 5.3 | +| pair [C3] b, canonical | *dry-run* | 2:14.51 | 2,203.8 s | 18,497,872 kB | 16.1 | +| canonical before the Rust optimizations [C3] | *pre-opt* | 8:56.56 | 10,528.6 s | 18,722,136 kB | 17.8 | + +- **Ratio.** The canonical route takes 1.30× the heuristic route's wall time in [C2] (+34.4 s) and + 1.24× and 1.26× in the two [C3] pairs. Before the Rust optimizations it took about 4.8×. +- **Same bytes.** Every canonical-route compile in the table, *pre-opt*'s included, wrote the same + 2,318,833,546-byte file (sha256 `a893a449…917bfc`). Every heuristic-route compile wrote 2,620,063,965 + bytes. +- **The heuristic baseline under load.** The 3:51.09 of the corpus table above is the same heuristic + binary on a much busier machine; the quieter runs here take 1:46.6–1:55.4. + +| Init | binary | wall | user CPU | peak RSS | load at start | +|---|---|---:|---:|---:|---:| +| heuristic | *six-rung* | 0:09.23 | 49.3 s | 2,863,148 kB | 20.7 | +| canonical | *optimized* | 0:11.28 | 68.4 s | 2,869,828 kB | 19.6 | +| canonical | *optimized-main* | 0:11.95 | 73.6 s | 2,930,720 kB | 23.4 | +| canonical before the Rust optimizations | *pre-opt* | 0:32.39 | 357.8 s | 3,019,744 kB | 18.2 | + +The canonical Init file is 143,680,738 bytes (sha256 `317d63bb…873363`, also written at *v4-flip* +and *pre-opt*); the heuristic one is 155,259,078 bytes. + +### Final back-to-back runs (this PR's head) + +On a quiet machine (1-minute load 2.1 at the start of the series), GNU `time`. The heuristic route is +an `ix` binary built at the last commit that still compiled with the heuristic; the canonical route +is this PR's head. The compile step is the compiler's own timing inside the run. + +| Mathlib | wall | CPU | peak RSS | compile step | ratio | +|---|---:|---:|---:|---:|---:| +| pair a, heuristic | 1:54.8 | 1,577 s | 19.0 GB | 94.4 s | | +| pair a, canonical | 2:09.9 | 2,127 s | 18.8 GB | 117.4 s | 1.13× (+15 s) | +| pair b, heuristic | 1:42.0 | 1,551 s | 18.9 GB | 92.6 s | | +| pair b, canonical | 2:08.8 | 2,134 s | 18.8 GB | 117.7 s | 1.26× (+27 s) | + +| Init | wall | CPU | +|---|---:|---:| +| heuristic | 8.6 s | 45 s | +| canonical | 10.9 s | 65 s | + +- The outputs are the Mathlib `.ixe` of 2,318,833,546 bytes (sha256 + `a893a4498335267cf92fbbff8b9e228658829d2856ab460314b296b059917bfc`) and the Init `.ixe` of + 143,680,738 bytes (sha256 `317d63bb3cbcd49cb77d602d796276ca7de234bb92dd4455a02c482374873363`), + identical in every canonical run, including the runs of the binary from before the Rust + optimizations. +- These runs supersede the pairs above as the final figures: the canonical route takes 1.13–1.26× + the heuristic route's wall time on Mathlib. A run made while another job was using the machine + (heuristic 2:23.6, canonical 3:28.0) is not counted. + +### The Rust construction alone [R11] + +The runner, 20 threads, at the start and at the end of the Rust optimization work. The Mathlib corpus +is the heuristic-route file of *six-rung* with its header byte set to `0xE4` (otherwise byte-identical, +so a v4 reader accepts it); the Init corpus is the canonical-route file. + +| | Mathlib, start | Mathlib, end | Init, start | Init, end | +|---|---:|---:|---:|---:| +| processing | 563.3 s | 64.4 s | 20.8 s | 3.5 s | +| per-constant times, summed | 9,685.0 s | 939.8 s | 378.8 s | 50.4 s | +| slowest constant | 211.3 s | 1.6 s | 9.9 s | 1.0 s | +| peak RSS | 4,604,276 kB | 4,291,480 kB | 785,876 kB | 567,976 kB | + +- **Same output.** Both runs certify every constant and write the same bytes. Mathlib: stored + 1,422,929,264 → 1,121,697,655 bytes (−21.17%); per constant 627,143 smaller, 51,871 equal, 485 larger, + the largest loss +28 bytes. The stored total includes + `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite` (607,293 bytes), which + failed in [R10] and is therefore missing from [R10]'s 1,422,321,971. Init: the corpus is the + canonical route's own output, and the runner reproduces all 56,622 constants (66,653,874 bytes). +- The slowest constant at the start is + `CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite`. Per-constant times are + taken with the pool full, so they are higher than on an idle thread. + +### Checks: default and checked mode [R12] + +From the module documentation of `crates/ixon/src/sharing_exact/tiered.rs` ("Checks"): + +- **Default mode (the compiler's).** Every limit and every length check of phases 1–3 applies to each + of the three candidates, and an error at any width fails the call with the lowest failing width's + error. The checks on the built expressions (the one-pass decisions and their `work`, the build of the + expressions, their layout price against the evaluated length, their re-expansion to the DAG and the + stored terms with the counted number of expression nodes, and their serialized length) run only for + the returned candidate. A wrong length of another candidate would change the selection without an + error; the checked mode exists to show that this does not happen. +- **Checked mode** (`ExactSharingLimits::full_check`: on in the unit tests, in the Lean/Rust FFI + parity hooks and with `sharing_corpus --full-check`; off in the compiler). Every candidate also + builds its phase-1 expressions and compares them with the dry run, a one-pass candidate is also + evaluated per prefix and compared, and the checks on the built expressions run for every candidate. + The output, the statistics and the outcome of every limit are those of the default mode; any + discrepancy is an internal error. + +At *review-fixes*, over the canonical-route files (12 threads): + +| | Init, default | Init, checked | Mathlib, default | Mathlib, checked | +|---|---:|---:|---:|---:| +| certified | 56,622 / 56,622 | 56,622 / 56,622 | 679,499 / 679,499 | 679,499 / 679,499 | +| processing | 3.7 s | 7.8 s | 73.3 s | 174.3 s | + +- The per-constant CSVs of the two modes are identical apart from the timing column. +- With `--check-sequential` (budgets 3, 4, 4 against the sequential path) every constant of both + corpora gives the same result. +- Every runner reproduces each constant of these files byte for byte (66,653,874 and 1,121,703,681 + bytes of constants). +- No candidate of either corpus needed the per-prefix phase 3, and the largest `work` charged to one + candidate is 25,996,430. + +**`work` in Rust.** The one-pass phase 3 charges one evaluation of the whole table; the per-prefix +path charges one evaluation per prefix, so the two paths charge different amounts for the same output. +The work of the one-pass decisions is charged to the returned candidate only. The per-prefix path is +reachable: it needs a telescope spine of at least 1,032 nodes. The fixture is an App spine of 1,288 +nodes ending in a stored term; its output is 7,105 bytes and its candidate lengths are (1, 7106), +(2, 7106) and (3, 7123), equal in Lean and Rust (`Tests/Ix/SharingTiered.lean`, +`crates/ixon/src/sharing_exact/tests.rs`). + +### Limits and numeric domains + +- **Candidate count.** In both languages the canonical construction records its candidate count and + does not limit it. Rust's `candidates` limit (2^16) bounds only the width-state test oracle (an + earlier version also enforced it on the compiler path; *candidate-fix* removed that). +- **Knapsack cells.** The default `knapsack_cells` limit is 2^28. The largest table-count knapsacks + over all widths need 3,195 cells (Init) and 9,959,424 cells (Mathlib), 27× below the default. A + constructed constant of 25,000 candidates exceeds it and fails identically in both languages. +- **128-bit lengths in Rust.** Rust's phase 1 computes lengths and bounds in 128 bits and fails with + `format bound: LengthOverflow` when a value leaves that range; Lean computes with `Nat`. So doubling + chains (`App(e, e)` repeated) of depth 127 or more fail in Rust and succeed in Lean; at depth 126 both + give the same bytes. Rust fails closed, and no Init or Mathlib constant comes near this. This is a + documented divergence. + +### The Lean construction [L1] [M1] + +Single-threaded comparison on three samples of the canonical-route Init file at *lean-optimized*: Lean +through the `exact-sharing-ffi` corpus mode with `LEAN_NUM_THREADS=1`, Rust through the runner with +1 thread in the default mode (the differential's own Rust times are in the checked mode). The load +average was 6–9. + +| sample | constants | Lean | Rust | Lean / Rust | Lean with the width tasks | +|---|---:|---:|---:|---:|---:| +| bulk (random; median `N` 83) | 373 | 1,239 ms | 150 ms | 8.3× | 885 ms | +| p99 (random, `N` ≥ 1,993) | 66 | 5,853 ms | 558 ms | 10.5× | 5,656 ms | +| slowest 15 by Rust time (`N` 2k–28k) | 15 | 18,985 ms | 1,229 ms | 15.4× | 9,209 ms | + +- All 454 constants give the same bytes in both languages. +- **Before the Lean optimizations** (*optimized-main*) the same samples gave 29×, 151× and 453×, about 61× + overall. +- **The 2–4× target set for the Lean construction is not met.** The remaining gap is structural: the + specification's phase-1 cost model evaluates the whole closure of a component, where Rust evaluates + only the component's area under a truncated model, and the data representations differ. Closing it + means changing the specification and its proofs; that is follow-up work. +- **The width tasks.** From 1,024 DAG terms on, the three widths run as parallel tasks + (`tieredCandidates`, proved to give the same result and error order as the sequential form). +- **Profiler.** `lake exe lean-sharing-prof full|split|hash [select-file]` + (`Benchmarks/LeanSharingProf.lean`) times the Lean construction, per phase with `split`, on a corpus + compiled with the canonical route, and checks that every output equals the stored bytes. + +**The merge-queue compile partition** [M1] (`lake test --wfail -- --ignored compile`: Lean and Rust +compile the same test environment and the results are compared), at *lean-optimized*, load 8.5 at the +start: exit 0; all 237,295 constants, their metadata and their full `ConstantMeta` match; the +serialized environments match exactly (428.4 MB each). The Lean step took 237.7 s, against 176.6 s +before the route switch and 3,683.7 s right after it; the Rust step took 62.3 s. The whole run took +11:50.73 wall (3,349.6 s user, 27,743,256 kB peak RSS), against 15:30 before the route switch. + +## What is not covered + +- **The exact width-state DP oracle beyond small inputs.** The §6 search, the full-key minimum over all + tables in the real Tag4 widths, is only an oracle. + - It is checked against exhaustive enumeration on small generated inputs and on the §2 fixtures (suite + `exact-sharing`; Rust `optimizer_matches_exhaustive_oracle` and the tests around it). + - It was not run over either corpus; Mathlib's median candidate count (69) is far beyond its reach + [P §12.1] [ML §Headline]. + - So no corpus number here is a distance to the true minimum. + - The only proved lower bound measured on a corpus is the w = 1 uniform-model optimum on Init, computed + by the Init corpus harness under the old search. The best of the encodings measured there, per + constant, is 11.72% above it + [Init §Lower-bound gap]. That bound was not recomputed for the best of three. +- **Unshared sizes of 619 Mathlib constants (and 7 Init) were not serialized**, only computed + compositionally, because their unshared roots exceed 16 MiB [ML §Limits and coverage] + [Init §Verification]. The runner's unshared sizes are compositional too, and they agree with the + harness's for every row [J1] [J2]. +- **The heuristic's own `occ` counts** were not brute-force checked for 31,049 Mathlib and 1,232 Init + constants [ML §Verification] [Init §Verification]. +- **On the v3 corpora, TagN Shares are not serialized.** TagN-layout bytes there are prices + (`layout_bytes`), not measured serializations: those runs predate the TagN wire codec [P §12.8], and + TagN for all integers [P §12.12] is not priced in them. The Format v4 section serializes TagN. +- **Best of three, beyond the byte totals.** + - The Rust byte figures come from the experiment hook, which runs the same three candidates that the + canonical path (*b3-rust*) compares. No full-corpus run of the canonical runner mode was repeated on + the v3 corpora; [R10], [R11] and [R12] are runs on the v4 corpora. + - On the v3 corpora, Lean/Rust parity under the best of three covers Init only [D7]; the + Mathlib-sample run [D8] was aborted. On the v4 corpora (Kahn order) it covers Init and the Mathlib + sample [D10] [D11]. + - The phase statistics above are for one phase-1 run (the K-based width). Per-width search statistics + (states, components) were not recorded. +- **The Kahn order beyond the first tier** (Lean *kahn-lean*, Rust *kahn-rust*) is measured on the v3 corpora + only on the outlier [X6] and in the store-all comparison [X5] (the best-of-three byte totals above + predate it), and on the v4 corpora in [R10] [D10] [D11]. +- **Lean on all of Mathlib.** The K-based tiered-TagN differential over all 679,499 constants ran in 6 + address shards [D6]. Three shards (339,749 constants) completed with 0 disagreements. The other three + processes ended without output, for reasons not explained. No best-of-three Lean run over all of + Mathlib was made. +- **Lean wall time and memory.** Lean's single-threaded wall time per corpus is available only as the sum + of per-call times inside the differential, whose processes also run Rust and the diagnosis reruns. + Lean-only peak memory was not separated from the differential process. After the Lean optimizations, + Lean is measured on three Init samples [L1] and in the Lean step of the merge-queue compile partition + [M1], not on whole corpora. +- **Other corpora.** The 9 other `Benchmarks/Compile` targets, project fixtures, and synthetic families + beyond the test generators were not measured [ML §Limits and coverage]. +- **Proofs.** Nothing here measures or checks optimality claims. Phase 1's uniform optimum is proved + minimal and `setPrec`-least in Lean (`optimizeUniform_minimum`, `optimizeUniform_least`). Phases 2 and + 3 and the width selection have machine-checked specifications of their own (`allocate_spec`, + `firstTier_spec`, `materializeTable_min`, `rematerialize_spec`, `canonicalTieredCore_select`), and the + reported length of the output is its serialized length (`canonicalSharingTiered_serialized`); their + composition is not claimed to be a global minimum, and the Rust implementation is held to Lean by the + differential [P §12.13] ([`Ixon.md`, "Sharing System"](Ixon.md#sharing-system)). + +## Reproduction + +Run from the repository root, with `$S` as above. + +- **At the current head** the runner runs only the canonical construction (best of three, Kahn order, + TagN) and keeps the flags `--threads`, `--limit`, `--csv`, `--select-out`, `--select-stride`, + `--select-min-cand`, `--only`, `--par-widths`/`--par-components`/`--par-materialize`, + `--serial-constants`, `--check-sequential` (which compares under the run's own limits) and + `--max-states`, and adds `--full-check` (the checked mode) and `--sharing-limits SPEC` (the grammar of + `ix compile --sharing-limits`). Building `ixon` with the cargo feature `ixon/sharing-profile` adds + phase timers (off by default). Its corpus must be compiled at the same commit, since a reader accepts + only its own format version. The first block below is the [R10] run in that form, followed by the + final-route runs. +- **Historical runs** need the commit named in the Sources table. `--layout` (and the Tag4 layout) and + `--width-experiment` existed only up to the experiment-hook cleanup and are not available at the current + head; the K-based rule of [R3]–[R7] exists only at its commits; the best-of-four columns of [X4] only at + *best-of-four*. + +```text +# Rust runner, current head: canonical construction over corpora compiled at the same commit [R10] +nix develop --command bash -c 'cargo build --release -p ixon --example sharing_corpus' +R=./target/release/examples/sharing_corpus +time -v $R $S/init_v4.ixe --threads 20 --csv $S/init_rust.csv --select-out $S/init_all.txt --select-stride 1 +time -v $R $S/mathlib_v4.ixe --threads 20 --csv $S/ml_rust.csv --select-out $S/ml_select.txt + +# Final route: ix compile back to back, heuristic route (an ix binary built at six_rung) first [C2] [C3] +time -v $IX_six_rung compile Benchmarks/Compile/CompileMathlib.lean --out $S/mathlib_heur.ixe +time -v lake exe ix compile Benchmarks/Compile/CompileMathlib.lean --out $S/mathlib_v4.ixe +time -v $IX_six_rung compile Benchmarks/CompileInit.lean --out $S/init_heur.ixe +time -v lake exe ix compile Benchmarks/CompileInit.lean --out $S/init_v4.ixe +# Default mode, checked mode and the sequential check over the canonical-route files [R12] +time -v $R $S/init_v4.ixe --threads 12 --csv $S/init_f2.csv --select-out $S/init_f2.sel +time -v $R $S/init_v4.ixe --threads 12 --csv $S/init_f2full.csv --select-out $S/init_f2full.sel --full-check +time -v $R $S/init_v4.ixe --threads 12 --csv $S/init_f2seq.csv --select-out $S/init_f2seq.sel \ + --check-sequential --par-widths 3 --par-components 4 --par-materialize 4 +# (the same three for $S/mathlib_v4.ixe; compare the CSVs without their last, timing, column) + +# Rust runner, historical: [X1]-[X3] at width_hook, [X4] at best_of_four (--layout and --width-experiment +# existed only at those commits) +time -v $R $S/init.ixe --layout tagN --threads 8 --width-experiment --csv $S/wx_init_tagN.csv # [X1] +time -v $R $S/mathlib.ixe --layout tagN --threads 8 --width-experiment --csv $S/wx_ml_tagN.csv # [X1] +time -v $R $S/init.ixe --layout tag4 --threads 8 --width-experiment --csv $S/wx_init_tag4.csv # [X2] +time -v $R $S/mathlib.ixe --layout tag4 --threads 8 --width-experiment --csv $S/wx_ml_tag4.csv # [X2] +time -v $R $S/init.ixe --layout tagN --threads 1 --width-experiment --csv $S/wx_init_tagN_t1.csv # [X3] +# best of four: the same mode at best_of_four, which adds the "all" candidate and the best4 columns # [X4] +time -v $R $S/mathlib.ixe --layout tagN --threads 12 --width-experiment --csv $S/wx4_ml_tagN.csv # [X4] +# Rust runner, historical: K-based rule at k_bb (--layout existed only up to the cleanup) +time -v $R $S/init.ixe --layout tagN --threads 1 --csv $S/init_tagN_t1.csv # [R6] +time -v $R $S/init.ixe --layout tagN --threads 20 --csv $S/init_tagN_t20.csv # [R4] +time -v $R $S/init.ixe --layout tag4 --threads 20 --csv $S/init_tag4_t20.csv # [R5] +time -v $R $S/mathlib.ixe --layout tagN --threads 20 --csv $S/mathlib_tiered_bb.csv # [R3] +time -v $R $S/mathlib.ixe --layout tag4 --threads 20 --csv $S/ml_tag4_t20.csv \ + --select-out $S/ml_all.txt --select-stride 1 # [R7] + +# Joins (untracked gawk scripts; see the notes on the sources). For Init use the Init harness's +# tenth-run CSV, $S/sharing-minimum-measurements.csv +gawk -v layout=tagN -f bestjoin.awk $S/mathlib-sharing.csv wx_ml_tagN.csv # [X1] +gawk -v layout=tagN -f wxjoin.awk $S/mathlib-sharing.csv wx_ml_tagN.csv # [X1] +gawk -f join.awk $S/mathlib-sharing.csv $S/mathlib_tiered_bb.csv ml_tag4_t20.csv # [J2] +gawk -f byw.awk $S/mathlib-sharing.csv $S/mathlib_tiered_bb.csv ml_tag4_t20.csv # [J2] +gawk -f slowest.awk $S/mathlib_tiered_bb.csv wx_ml_tagN.csv # [X1] +gawk -v layout=tagN -v bestcol=best4 -f wxjoin.awk $S/mathlib-sharing.csv wx4_ml_tagN.csv # [X4] + +# Lean/Rust differential (one process per address shard). The modes tiered-tagN and uniform-w +# exist at the current head; tiered-tag4 existed only at the commits of [D1]-[D9]. +nix develop --command bash -c 'lake build IxTests' +IX_SHARING_CORPUS=$S/mathlib.ixe IX_SHARING_CORPUS_MODES=tiered-tagN \ +IX_SHARING_CORPUS_SELECT= time -v ./.lake/build/bin/IxTests exact-sharing-ffi # [D2]-[D11] + +# Lean against Rust on three Init samples (address lists bulk.sel, p99.sel, slow.sel) [L1] +time -v $R $S/init_v4.ixe --threads 1 --csv $S/rust1.csv # Rust: sum the ms column over a sample +LEAN_NUM_THREADS=1 IX_SHARING_CORPUS=$S/init_v4.ixe IX_SHARING_CORPUS_MODES=tiered-tagN \ +IX_SHARING_CORPUS_SELECT=$S/bulk.sel ./.lake/build/bin/IxTests exact-sharing-ffi +# (again without LEAN_NUM_THREADS for the width tasks; the same for p99.sel and slow.sel) +# The merge-queue compile partition [M1] +time -v lake test --wfail -- --ignored compile +``` + +## Appendix A: runner reports and joins + +Each block is the runner's report file, unedited apart from local paths (written `$S/…`), followed by +the GNU `time` lines of its `.err` file. + +
[R6] Init, TagN layout, 1 thread, new search, K-based (init_tagN_t1.md) + +```text +# sharing_corpus report +- corpus: $S/init.ixe (56622 constants; 56622 processed); layout TagN +- wall: index 206 ms, processing 83.1 s with 1 threads; peak RSS 307508 KiB +- certified: 56622 / 56622; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 80208288 B; output under Tag4 67668319 B (-15.63%); under TagN 67036818 B (-16.42%) +- unshared (where it fits u64, 56622 constants): 1070001199 B; stored 80208288 B; Tag4 output 67668319 B +- Tag4 output - stored per constant: 49956 smaller, 6228 equal, 438 larger; min -67656 p1 -3220 p10 -363 p50 -46 p90 0 p99 0 p99.9 14 max 70 +- TagN price - stored per constant: min -72624 p1 -3425 p10 -363 p50 -46 p90 0 p99 0 p99.9 14 max 70 +- phase-1 width w: {1: 23506, 2: 33008, 3: 108} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 3 p90 22 p99 113 p99.9 267 max 978 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 13 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 12 p90 90 p99 486 p99.9 1094 max 5503 +- first-tier search states per constant: min 1 p1 1 p10 3 p50 15 p90 91 p99 618 p99.9 1871 max 17727 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 3 p50 33 p90 227 p99 1168 p99.9 4843 max 22458 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 0 p90 2 p99 13 p99.9 90 max 2261 +- slowest 10: + - 2261 ms _private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1 (89ed0e9889141575): defn ok, N 26494, cand 19017, k 4919, w 3, uncertain 587, components 555 (largest 3), states uniform 2351 first-tier 8577 + - 1431 ms _private.Init.Data.Array.Extract.0.Array.extract_append._proof_1_1 (e852d49c2b3a2ea7): defn ok, N 26754, cand 19091, k 5146, w 3, uncertain 687, components 651 (largest 3), states uniform 2721 first-tier 13228 + - 1133 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1 (d126ef57b21ab268): defn ok, N 26943, cand 19283, k 5136, w 3, uncertain 660, components 621 (largest 3), states uniform 2609 first-tier 17727 + - 1039 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append_extract._proof_1 (eed90987192d5160): defn ok, N 24658, cand 17290, k 4703, w 3, uncertain 557, components 517 (largest 4), states uniform 2193 first-tier 4104 + - 968 ms _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806a): defn ok, N 27628, cand 22458, k 4874, w 3, uncertain 978, components 826 (largest 6), states uniform 3826 first-tier 3793 + - 884 ms _private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514): defn ok, N 24507, cand 17140, k 4678, w 3, uncertain 571, components 530 (largest 4), states uniform 2247 first-tier 4066 + - 636 ms Lean.Grind.Config.mk.injEq (79a818e3bc347ced): defn ok, N 3512, cand 551, k 360, w 2, uncertain 185, components 14 (largest 44), states uniform 4177 first-tier 199 + - 593 ms _private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition' (f22512c397919b72): defn ok, N 16156, cand 11692, k 2712, w 3, uncertain 349, components 299 (largest 4), states uniform 1375 first-tier 9252 + - 503 ms _private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1 (b6be5c1a4db8c149): defn ok, N 19523, cand 11454, k 3640, w 3, uncertain 454, components 435 (largest 4), states uniform 1816 first-tier 3143 + - 436 ms _private.Init.Data.Vector.Extract.0.Vector.extract_add_left._proof_1 (5a362f9e99724cbf): defn ok, N 14521, cand 8259, k 2854, w 3, uncertain 332, components 310 (largest 3), states uniform 1310 first-tier 4936 +- total wall 85.4 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --layout tagN --threads 1 --csv $S/init_tagN_t1.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:25.43 + Maximum resident set size (kbytes): 307708 + Exit status: 0 +exit=0 +``` + +
+ +
[R4] Init, TagN layout, 20 threads, new search, K-based (init_tagN_t20.md) + +```text +# sharing_corpus report +- corpus: $S/init.ixe (56622 constants; 56622 processed); layout TagN +- wall: index 318 ms, processing 7.7 s with 20 threads; peak RSS 620324 KiB +- certified: 56622 / 56622; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 80208288 B; output under Tag4 67668319 B (-15.63%); under TagN 67036818 B (-16.42%) +- unshared (where it fits u64, 56622 constants): 1070001199 B; stored 80208288 B; Tag4 output 67668319 B +- Tag4 output - stored per constant: 49956 smaller, 6228 equal, 438 larger; min -67656 p1 -3220 p10 -363 p50 -46 p90 0 p99 0 p99.9 14 max 70 +- TagN price - stored per constant: min -72624 p1 -3425 p10 -363 p50 -46 p90 0 p99 0 p99.9 14 max 70 +- phase-1 width w: {1: 23506, 2: 33008, 3: 108} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 3 p90 22 p99 113 p99.9 267 max 978 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 13 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 12 p90 90 p99 486 p99.9 1094 max 5503 +- first-tier search states per constant: min 1 p1 1 p10 3 p50 15 p90 91 p99 618 p99.9 1871 max 17727 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 3 p50 33 p90 227 p99 1168 p99.9 4843 max 22458 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 0 p90 3 p99 26 p99.9 183 max 2963 +- slowest 10: + - 2963 ms _private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1 (89ed0e9889141575): defn ok, N 26494, cand 19017, k 4919, w 3, uncertain 587, components 555 (largest 3), states uniform 2351 first-tier 8577 + - 2419 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1 (d126ef57b21ab268): defn ok, N 26943, cand 19283, k 5136, w 3, uncertain 660, components 621 (largest 3), states uniform 2609 first-tier 17727 + - 2381 ms _private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514): defn ok, N 24507, cand 17140, k 4678, w 3, uncertain 571, components 530 (largest 4), states uniform 2247 first-tier 4066 + - 2168 ms _private.Init.Data.Array.Extract.0.Array.extract_append._proof_1_1 (e852d49c2b3a2ea7): defn ok, N 26754, cand 19091, k 5146, w 3, uncertain 687, components 651 (largest 3), states uniform 2721 first-tier 13228 + - 2062 ms _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806a): defn ok, N 27628, cand 22458, k 4874, w 3, uncertain 978, components 826 (largest 6), states uniform 3826 first-tier 3793 + - 1895 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append_extract._proof_1 (eed90987192d5160): defn ok, N 24658, cand 17290, k 4703, w 3, uncertain 557, components 517 (largest 4), states uniform 2193 first-tier 4104 + - 1216 ms _private.Init.Data.Int.DivMod.Lemmas.0.Int.add_one_tdiv._proof_1_1 (194bacb9fee23ecb): defn ok, N 18802, cand 13281, k 3236, w 3, uncertain 424, components 406 (largest 4), states uniform 1696 first-tier 2748 + - 1048 ms _private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition' (f22512c397919b72): defn ok, N 16156, cand 11692, k 2712, w 3, uncertain 349, components 299 (largest 4), states uniform 1375 first-tier 9252 + - 1001 ms _private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1 (b6be5c1a4db8c149): defn ok, N 19523, cand 11454, k 3640, w 3, uncertain 454, components 435 (largest 4), states uniform 1816 first-tier 3143 + - 890 ms _private.Init.Data.Array.Lemmas.0.Array.toList_reverse.go._unary (c6ad8cd851ef627b): defn ok, N 12884, cand 8661, k 2769, w 3, uncertain 563, components 440 (largest 6), states uniform 2262 first-tier 6387 +- total wall 10.2 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --layout tagN --threads 20 --csv $S/init_tagN_t20.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:10.24 + Maximum resident set size (kbytes): 619440 + Exit status: 0 +exit=0 +``` + +
+ +
[R5] Init, Tag4 layout, 20 threads, new search, K-based (init_tag4_t20.md) + +```text +# sharing_corpus report +- corpus: $S/init.ixe (56622 constants; 56622 processed); layout Tag4 +- wall: index 209 ms, processing 7.8 s with 20 threads; peak RSS 619272 KiB +- certified: 56622 / 56622; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 80208288 B; output under Tag4 67747841 B (-15.54%); under TagN 67180528 B (-16.24%) +- unshared (where it fits u64, 56622 constants): 1070001199 B; stored 80208288 B; Tag4 output 67747841 B +- Tag4 output - stored per constant: 49956 smaller, 6228 equal, 438 larger; min -67656 p1 -3153 p10 -363 p50 -46 p90 0 p99 0 p99.9 14 max 70 +- TagN price - stored per constant: min -72624 p1 -3344 p10 -363 p50 -46 p90 0 p99 0 p99.9 14 max 70 +- phase-1 width w: {1: 23506, 2: 31764, 3: 1352} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 3 p90 22 p99 120 p99.9 271 max 978 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 14 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 12 p90 90 p99 514 p99.9 1140 max 5503 +- first-tier search states per constant: min 1 p1 1 p10 3 p50 15 p90 91 p99 572 p99.9 1702 max 17727 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 3 p50 33 p90 227 p99 1168 p99.9 4843 max 22458 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 0 p90 3 p99 23 p99.9 184 max 2636 +- slowest 10: + - 2636 ms _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806a): defn ok, N 27628, cand 22458, k 4874, w 3, uncertain 978, components 826 (largest 6), states uniform 3826 first-tier 3793 + - 2582 ms _private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514): defn ok, N 24507, cand 17140, k 4678, w 3, uncertain 571, components 530 (largest 4), states uniform 2247 first-tier 4066 + - 2176 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1 (d126ef57b21ab268): defn ok, N 26943, cand 19283, k 5136, w 3, uncertain 660, components 621 (largest 3), states uniform 2609 first-tier 17727 + - 2153 ms _private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1 (89ed0e9889141575): defn ok, N 26494, cand 19017, k 4919, w 3, uncertain 587, components 555 (largest 3), states uniform 2351 first-tier 8577 + - 1265 ms _private.Init.Data.Int.DivMod.Lemmas.0.Int.add_one_tdiv._proof_1_1 (194bacb9fee23ecb): defn ok, N 18802, cand 13281, k 3236, w 3, uncertain 424, components 406 (largest 4), states uniform 1696 first-tier 2748 + - 1210 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append_extract._proof_1 (eed90987192d5160): defn ok, N 24658, cand 17290, k 4703, w 3, uncertain 557, components 517 (largest 4), states uniform 2193 first-tier 4104 + - 1176 ms _private.Init.Data.Array.Extract.0.Array.extract_append._proof_1_1 (e852d49c2b3a2ea7): defn ok, N 26754, cand 19091, k 5146, w 3, uncertain 687, components 651 (largest 3), states uniform 2721 first-tier 13228 + - 1132 ms _private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1 (b6be5c1a4db8c149): defn ok, N 19523, cand 11454, k 3640, w 3, uncertain 454, components 435 (largest 4), states uniform 1816 first-tier 3143 + - 927 ms Lean.Grind.Config.mk.injEq (79a818e3bc347ced): defn ok, N 3512, cand 551, k 360, w 3, uncertain 195, components 17 (largest 44), states uniform 4388 first-tier 196 + - 905 ms _private.Init.Data.Vector.Extract.0.Vector.extract_add_left._proof_1 (5a362f9e99724cbf): defn ok, N 14521, cand 8259, k 2854, w 3, uncertain 332, components 310 (largest 3), states uniform 1310 first-tier 4936 +- total wall 10.1 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --layout tag4 --threads 20 --csv $S/init_tag4_t20.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:10.15 + Maximum resident set size (kbytes): 618880 + Exit status: 0 +exit=0 +``` + +
+ +
[R3] Mathlib, TagN layout, 20 threads, new search, K-based (mathlib_tiered_bb.md) + +```text +# sharing_corpus report +- corpus: $S/mathlib.ixe (679499 constants; 679499 processed); layout TagN +- wall: index 10950 ms, processing 184.3 s with 20 threads; peak RSS 5282852 KiB +- certified: 679499 / 679499; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 1468890902 B; output under Tag4 1148638151 B (-21.80%); under TagN 1136221078 B (-22.65%) +- unshared (where it fits u64, 679499 constants): 214351802561585 B; stored 1468890902 B; Tag4 output 1148638151 B +- Tag4 output - stored per constant: 623331 smaller, 52448 equal, 3720 larger; min -258748 p1 -6169 p10 -952 p50 -114 p90 -1 p99 0 p99.9 12 max 248 +- TagN price - stored per constant: min -267397 p1 -6663 p10 -952 p50 -114 p90 -1 p99 0 p99.9 12 max 248 +- phase-1 width w: {1: 197682, 2: 480001, 3: 1816} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 4 p90 25 p99 112 p99.9 296 max 3077 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 6 p99.9 13 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 16 p90 102 p99 475 p99.9 1231 max 12358 +- first-tier search states per constant: min 1 p1 1 p10 5 p50 20 p90 128 p99 789 p99.9 2673 max 30126 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 6 p50 66 p90 424 p99 2004 p99.9 6370 max 81833 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 1 p90 6 p99 49 p99.9 347 max 55050 +- slowest 10: + - 55050 ms CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56): defn ok, N 95110, cand 81833, k 21461, w 3, uncertain 3077, components 2878 (largest 3), states uniform 12358 first-tier 18449 + - 26795 ms Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (2b0491741df2ce98): defn ok, N 78913, cand 59202, k 13054, w 3, uncertain 2682, components 2284 (largest 4), states uniform 10570 first-tier 20977 + - 25508 ms AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (4ece542b15e7b7a1): defn ok, N 66025, cand 52066, k 10555, w 3, uncertain 1707, components 1541 (largest 3), states uniform 6586 first-tier 8986 + - 22486 ms WeierstrassCurve.variableChange_Δ (0473473f736e639b): defn ok, N 63501, cand 18995, k 9233, w 3, uncertain 651, components 640 (largest 3), states uniform 2590 first-tier 25590 + - 19796 ms _private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three (67e377956e9a5e65): defn ok, N 50027, cand 26233, k 10413, w 3, uncertain 1611, components 1562 (largest 4), states uniform 6381 first-tier 8729 + - 19704 ms _private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1 (159e2b0d36d95a7f): defn ok, N 70414, cand 61641, k 11700, w 3, uncertain 1627, components 1537 (largest 4), states uniform 6464 first-tier 10045 + - 17288 ms Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux (83b417c6e46f08e2): defn ok, N 64047, cand 41872, k 8745, w 3, uncertain 1688, components 1492 (largest 4), states uniform 6809 first-tier 7020 + - 16213 ms CategoryTheory.Bicategory.mateEquiv_vcomp (9b20bc429f4cd038): defn ok, N 50497, cand 32338, k 8940, w 3, uncertain 1899, components 1431 (largest 14), states uniform 7942 first-tier 15083 + - 14088 ms WeierstrassCurve.isHomogeneous_addSubMapCoeff (f2ce788af955876c): defn ok, N 60092, cand 31902, k 10150, w 3, uncertain 2015, components 1944 (largest 3), states uniform 7948 first-tier 8037 + - 13408 ms AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq (2d33bfe7c13b87fd): defn ok, N 53511, cand 44632, k 12056, w 3, uncertain 2146, components 1866 (largest 5), states uniform 8344 first-tier 30126 +- total wall 314.6 s + + Command being timed: "./target/release/examples/sharing_corpus $S/mathlib.ixe --threads 20 --csv $S/mathlib_tiered_bb.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 5:15.88 + Maximum resident set size (kbytes): 5300268 + Exit status: 0 +exit=0 +``` + +
+ +
[R7] Mathlib, Tag4 layout, 20 threads, new search, K-based (ml_tag4_t20.md) + +```text +# sharing_corpus report +- corpus: $S/mathlib.ixe (679499 constants; 679499 processed); layout Tag4 +- wall: index 6355 ms, processing 209.6 s with 20 threads; peak RSS 5246368 KiB +- certified: 679499 / 679499; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 1468890902 B; output under Tag4 1151220860 B (-21.63%); under TagN 1140753366 B (-22.34%) +- unshared (where it fits u64, 679499 constants): 214351802561585 B; stored 1468890902 B; Tag4 output 1151220860 B +- Tag4 output - stored per constant: 623329 smaller, 52448 equal, 3722 larger; min -258748 p1 -6072 p10 -952 p50 -114 p90 -1 p99 0 p99.9 12 max 248 +- TagN price - stored per constant: min -267397 p1 -6426 p10 -952 p50 -114 p90 -1 p99 0 p99.9 12 max 248 +- phase-1 width w: {1: 197682, 2: 458516, 3: 23301} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 4 p90 25 p99 115 p99.9 299 max 3077 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 13 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 16 p90 102 p99 496 p99.9 1257 max 23682 +- first-tier search states per constant: min 1 p1 1 p10 5 p50 20 p90 128 p99 735 p99.9 2622 max 30126 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 6 p50 66 p90 424 p99 2004 p99.9 6370 max 81833 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 1 p90 7 p99 53 p99.9 385 max 47306 +- slowest 10: + - 47306 ms CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56): defn ok, N 95110, cand 81833, k 21461, w 3, uncertain 3077, components 2878 (largest 3), states uniform 12358 first-tier 18449 + - 43264 ms _private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1 (159e2b0d36d95a7f): defn ok, N 70414, cand 61641, k 11700, w 3, uncertain 1627, components 1537 (largest 4), states uniform 6464 first-tier 10045 + - 26452 ms Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (2b0491741df2ce98): defn ok, N 78913, cand 59202, k 13054, w 3, uncertain 2682, components 2284 (largest 4), states uniform 10570 first-tier 20977 + - 25777 ms AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (4ece542b15e7b7a1): defn ok, N 66025, cand 52066, k 10555, w 3, uncertain 1707, components 1541 (largest 3), states uniform 6586 first-tier 8986 + - 19717 ms WeierstrassCurve.variableChange_Δ (0473473f736e639b): defn ok, N 63501, cand 18995, k 9233, w 3, uncertain 651, components 640 (largest 3), states uniform 2590 first-tier 25590 + - 16886 ms WeierstrassCurve.Projective.negDblY_eq' (37cd1c7638fa9899): defn ok, N 45785, cand 14522, k 7073, w 3, uncertain 456, components 449 (largest 3), states uniform 1820 first-tier 13122 + - 16295 ms CategoryTheory.Bicategory.mateEquiv_vcomp (9b20bc429f4cd038): defn ok, N 50497, cand 32338, k 8940, w 3, uncertain 1899, components 1431 (largest 14), states uniform 7942 first-tier 15083 + - 15126 ms sum_eight_sq_mul_sum_eight_sq (0bd4b1175ac1d995): defn ok, N 49322, cand 10408, k 7281, w 3, uncertain 263, components 256 (largest 4), states uniform 1053 first-tier 7021 + - 14623 ms WeierstrassCurve.isHomogeneous_addSubMapCoeff (f2ce788af955876c): defn ok, N 60092, cand 31902, k 10150, w 3, uncertain 2015, components 1944 (largest 3), states uniform 7948 first-tier 8037 + - 14351 ms AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq (2d33bfe7c13b87fd): defn ok, N 53511, cand 44632, k 12056, w 3, uncertain 2146, components 1866 (largest 5), states uniform 8344 first-tier 30126 +- total wall 346.7 s + + Command being timed: "./target/release/examples/sharing_corpus $S/mathlib.ixe --layout tag4 --threads 20 --csv $S/ml_tag4_t20.csv --select-out $S/ml_all.txt --select-stride 1" + Elapsed (wall clock) time (h:mm:ss or m:ss): 5:47.70 + Maximum resident set size (kbytes): 5263200 + Exit status: 0 +exit=0 +``` + +
+ +
[R1] Init, TagN layout, 16 threads, old search, K-based (init_tiered.md) + +```text +# sharing_corpus report +- corpus: $S/init.ixe (56622 constants; 56622 processed); layout TagN +- wall: index 209 ms, processing 30.6 s with 16 threads; peak RSS 572040 KiB +- certified: 56597 / 56622; failed: 25 +- failures by status: {"resource:States": 25} + - FAILED Nat.Internal.Linear.ExprCnstr.denote_toNormPoly (069f4b6521a2da52): resource:States; N 525, cand 293, raw 3664 B, 4807 ms + - FAILED _private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.size_rco._proof_1_1 (1a9c503f0b3871c0): resource:States; N 2537, cand 1674, raw 14882 B, 2341 ms + - FAILED List.min_findIdx_findIdx (25482ede969f4d9e): resource:States; N 932, cand 461, raw 5351 B, 4458 ms + - FAILED List.cons_append_cons_perm (3ea9f1a9b25c2e70): resource:States; N 226, cand 109, raw 1300 B, 3780 ms + - FAILED List.zip_eq_append_iff (53ceab4c4d118b7e): resource:States; N 439, cand 248, raw 2316 B, 2676 ms + - FAILED Lean.Grind.Ring.OfSemiring.instOrderedRingQOfLawfulOrderLTOfExistsAddOfLT (63bcc228082342f2): resource:States; N 3608, cand 2003, raw 18781 B, 2193 ms + - FAILED Array.zip_eq_append_iff (69037dee155a0c78): resource:States; N 439, cand 248, raw 2308 B, 2048 ms + - FAILED Std.LinearPreorderPackage.ofOrd._proof_9 (74c94685bcbe1dbf): resource:States; N 401, cand 226, raw 2606 B, 2973 ms + - FAILED Int.fdiv_eq_ediv (790ad4904df2cf4c): resource:States; N 1262, cand 551, raw 6871 B, 3505 ms + - FAILED Lean.Grind.Config.mk.injEq (79a818e3bc347ced): resource:States; N 3512, cand 551, raw 8939 B, 16615 ms + - FAILED USize.toUInt64_shiftRight (7fa9ab3277164432): resource:States; N 822, cand 397, raw 5348 B, 1724 ms + - FAILED _private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.size_roo._proof_1_1 (87f5bd76e627d460): resource:States; N 3423, cand 2107, raw 18960 B, 2290 ms + - FAILED BitVec.getMsbD_setWidth (9ba8c88e4f376482): resource:States; N 1044, cand 580, raw 6292 B, 3333 ms + - FAILED _private.Init.Data.String.Decode.0.UInt8.utf8ByteSize_eq_utf8ByteSize_parseFirstByte (a60acec5ca548536): resource:States; N 1056, cand 569, raw 6019 B, 5094 ms + - FAILED Int.Internal.Linear.cooper_right (b3180268914b846b): resource:States; N 2365, cand 1160, raw 12378 B, 3176 ms + - FAILED Lean.Meta.DSimp.Config.mk.injEq (b886b7d44989227c): resource:States; N 746, cand 185, raw 2228 B, 3200 ms + - FAILED Lean.Grind.Ring.OfSemiring.right_distrib (c163676b7110408a): resource:States; N 1235, cand 668, raw 6747 B, 3260 ms + - FAILED Lean.Grind.Ring.OfSemiring.mul_assoc (cacd32ba6398d117): resource:States; N 1372, cand 763, raw 7527 B, 4291 ms + - FAILED _private.Init.Data.BitVec.Bitblast.0.BitVec.addRecAux_cpopTree._unary (cc0455870fa49978): resource:States; N 2614, cand 1427, raw 15542 B, 2561 ms + - FAILED Lean.Meta.Simp.Config.mk.injEq (cf72eed2b476eae8): resource:States; N 1994, cand 376, raw 5298 B, 10092 ms + - FAILED Int.cooper_resolution_dvd_right (d264fc7a3b27308f): resource:States; N 1138, cand 451, raw 5635 B, 3074 ms + - FAILED Std.LinearPreorderPackage.ofOrd._proof_1 (d6593f0cd64b97f6): resource:States; N 567, cand 297, raw 3329 B, 3318 ms + - FAILED Lean.Meta.ExtractLetsConfig.mk.injEq (d7c4aa4ea0c241f0): resource:States; N 457, cand 122, raw 1489 B, 2970 ms + - FAILED ISize.toInt_bmod_two_pow_numBits (e0027ad59db96616): resource:States; N 449, cand 265, raw 3290 B, 2016 ms + - FAILED _private.Init.Data.Nat.Internal.SOM.0.Nat.Internal.SOM.Poly.add_denote.go (f933e2efb97ec29d): resource:States; N 1474, cand 606, raw 7574 B, 3830 ms +- certified constants: stored (heuristic) 80033614 B; output under Tag4 67531603 B (-15.62%); under TagN 66903767 B (-16.41%) +- unshared (where it fits u64, 56597 constants): 1067313418 B; stored 80033614 B; Tag4 output 67531603 B +- Tag4 output - stored per constant: 49931 smaller, 6228 equal, 438 larger; min -67656 p1 -3200 p10 -362 p50 -45 p90 0 p99 0 p99.9 14 max 70 +- TagN price - stored per constant: min -72624 p1 -3407 p10 -362 p50 -45 p90 0 p99 0 p99.9 14 max 70 +- phase-1 width w: {1: 23506, 2: 32983, 3: 108} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 4 p90 32 p99 143 p99.9 406 max 1509 +- largest component per constant: min 0 p1 0 p10 0 p50 2 p90 5 p99 10 p99.9 16 max 20 +- uniform search states per constant: min 0 p1 0 p10 0 p50 15 p90 168 p99 3233 p99.9 79914 max 776614 +- first-tier search states per constant: min 1 p1 1 p10 3 p50 15 p90 91 p99 612 p99.9 1871 max 17727 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 3 p50 33 p90 227 p99 1169 p99.9 4843 max 22458 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 0 p90 2 p99 27 p99.9 375 max 2869 +- slowest 10: + - 16615 ms Lean.Grind.Config.mk.injEq (79a818e3bc347ced): defn resource:States, N 3512, cand 551, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 10092 ms Lean.Meta.Simp.Config.mk.injEq (cf72eed2b476eae8): defn resource:States, N 1994, cand 376, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 5094 ms _private.Init.Data.String.Decode.0.UInt8.utf8ByteSize_eq_utf8ByteSize_parseFirstByte (a60acec5ca548536): defn resource:States, N 1056, cand 569, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 4807 ms Nat.Internal.Linear.ExprCnstr.denote_toNormPoly (069f4b6521a2da52): defn resource:States, N 525, cand 293, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 4458 ms List.min_findIdx_findIdx (25482ede969f4d9e): defn resource:States, N 932, cand 461, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 4291 ms Lean.Grind.Ring.OfSemiring.mul_assoc (cacd32ba6398d117): defn resource:States, N 1372, cand 763, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 3830 ms _private.Init.Data.Nat.Internal.SOM.0.Nat.Internal.SOM.Poly.add_denote.go (f933e2efb97ec29d): defn resource:States, N 1474, cand 606, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 3780 ms List.cons_append_cons_perm (3ea9f1a9b25c2e70): defn resource:States, N 226, cand 109, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 3505 ms Int.fdiv_eq_ediv (790ad4904df2cf4c): defn resource:States, N 1262, cand 551, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 3333 ms BitVec.getMsbD_setWidth (9ba8c88e4f376482): defn resource:States, N 1044, cand 580, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 +- total wall 32.9 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --threads 16 --csv $S/init_tiered.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:32.92 + Maximum resident set size (kbytes): 571680 + Exit status: 0 +``` + +
+ +
[R2] Mathlib, TagN layout, 20 threads, old search, K-based (all 342 failures listed) (mathlib_tiered.md) + +```text +# sharing_corpus report +- corpus: $S/mathlib.ixe (679499 constants; 679499 processed); layout TagN +- wall: index 10735 ms, processing 293.2 s with 20 threads; peak RSS 4794008 KiB +- certified: 679157 / 679499; failed: 342 +- failures by status: {"resource:States": 342} + - FAILED Con.quotientQuotientEquivQuotient._proof_3 (0110da50b45f6d89): resource:States; N 691, cand 474, raw 3858 B, 2228 ms + - FAILED CategoryTheory.Oplax.OplaxTrans.whiskerRight_naturality_naturality (024193d1504bae0e): resource:States; N 850, cand 706, raw 5261 B, 4328 ms + - FAILED WeierstrassCurve.addSubMapCoeff_condition (02ae6cb3f3ccb488): resource:States; N 42875, cand 35702, raw 272192 B, 5346 ms + - FAILED WeierstrassCurve.Projective.map_polynomial (039278bb56e318cf): resource:States; N 1373, cand 800, raw 8545 B, 6663 ms + - FAILED Affine.Triangle.dist_orthogonalProjectionSpan_faceOpposite_eq_iff_two_zsmul_oangle_eq (048653e65a77d222): resource:States; N 19417, cand 8801, raw 96389 B, 4335 ms + - FAILED CategoryTheory.CartesianMonoidalCategory.preservesLimit_pair_of_isIso_prodComparison (05076104ef79d59c): resource:States; N 723, cand 456, raw 4909 B, 2139 ms + - FAILED CategoryTheory.Dial.associator_naturality (06625d954659cb4c): resource:States; N 3637, cand 2076, raw 20019 B, 3914 ms + - FAILED Nat.Internal.Linear.ExprCnstr.denote_toNormPoly (069f4b6521a2da52): resource:States; N 525, cand 293, raw 3664 B, 3967 ms + - FAILED Std.Tactic.BVDecide.BVExpr.bitblast.blastUmod.denote_go_eq_divRec_r (07629abd4b23b6b7): resource:States; N 2633, cand 1863, raw 15438 B, 5269 ms + - FAILED Std.DTreeMap.Internal.Impl.maxKey!_eq_iff_getKey?_eq_self_and_forall (07925884a6266444): resource:States; N 468, cand 259, raw 2969 B, 2427 ms + - FAILED mfderivWithin_projIcc_one (07c512baeb5f1c75): resource:States; N 5218, cand 1580, raw 21192 B, 51806 ms + - FAILED Fin.snocOrderIso._proof_4 (0885f2f02c71285c): resource:States; N 445, cand 254, raw 2780 B, 4564 ms + - FAILED CategoryTheory.OplaxFunctor.map₂_leftUnitor_app_assoc (08ac13e87cc8239f): resource:States; N 697, cand 516, raw 4346 B, 3089 ms + - FAILED skyscraperPresheafCoconeOfSpecializes._proof_1 (0987bedec3054478): resource:States; N 786, cand 619, raw 5723 B, 3581 ms + - FAILED CategoryTheory.Bicategory.rightZigzag_idempotent_of_left_triangle (09db0be7266c57e7): resource:States; N 9677, cand 5963, raw 50599 B, 7239 ms + - FAILED _private.Mathlib.Logic.Function.Basic.0.Function.update_comm._proof_1_2 (0ac91487b6da0615): resource:States; N 969, cand 596, raw 5360 B, 5763 ms + - FAILED List.prod_map_ite (0b2eb2da786365c1): resource:States; N 1156, cand 571, raw 6346 B, 3319 ms + - FAILED CategoryTheory.Limits.Concrete.colimit_no_zero_smul_divisor (0b86766f0a8777ca): resource:States; N 5328, cand 4211, raw 33045 B, 5049 ms + - FAILED WeierstrassCurve.Jacobian.negAddY_smul (0c1816c71ee7e564): resource:States; N 14839, cand 6369, raw 70068 B, 29478 ms + - FAILED CategoryTheory.Pseudofunctor.DescentData.iso._proof_6 (0ccbe0acfb8c01a0): resource:States; N 980, cand 716, raw 5913 B, 3784 ms + - FAILED RootPairing.GeckConstruction.ω_mul_h (0cdd7bd7ad88811d): resource:States; N 3391, cand 2117, raw 20844 B, 3585 ms + - FAILED Std.IO.Process.ResourceUsageStats.mk.injEq (0defcfa7db9298e3): resource:States; N 743, cand 183, raw 2236 B, 5117 ms + - FAILED List.nextOr_eq_nextOr_of_mem_dropLast (0fe361de030d820f): resource:States; N 726, cand 259, raw 3406 B, 3229 ms + - FAILED CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence._proof_5 (104ede10003f7b68): resource:States; N 708, cand 635, raw 5134 B, 2349 ms + - FAILED WeierstrassCurve.Affine.CoordinateRing.norm_smul_basis (10fd2472f34f75ee): resource:States; N 5675, cand 3434, raw 34984 B, 3360 ms + - FAILED WeierstrassCurve.Projective.nonsingular_some (14382a0aa25acb7d): resource:States; N 5131, cand 2608, raw 28344 B, 6243 ms + - FAILED CategoryTheory.Pseudofunctor.DescentData.Hom.comm_assoc (1463099f94aacfe0): resource:States; N 939, cand 765, raw 6074 B, 1921 ms + - FAILED _private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.0.WeierstrassCurve.natDegree_coeff_Φ_ofNat (14adbec3312d1ee7): resource:States; N 10152, cand 5547, raw 59028 B, 3838 ms + - FAILED _private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.mk.injEq (151105c7790e6da0): resource:States; N 2657, cand 586, raw 8232 B, 29808 ms + - FAILED Module.reflection_mul_reflection_pow_apply (15b19b23c225d5d4): resource:States; N 22807, cand 16190, raw 137496 B, 6815 ms + - FAILED Chebyshev.sum_PrimePow_eq_sum_sum' (15d35cc887b44e74): resource:States; N 5255, cand 2678, raw 32060 B, 3978 ms + - FAILED WeierstrassCurve.Jacobian.addX_smul (19c7000bbae96998): resource:States; N 7999, cand 3839, raw 39674 B, 9829 ms + - FAILED _private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.size_rco._proof_1_1 (1a9c503f0b3871c0): resource:States; N 2537, cand 1674, raw 14882 B, 1761 ms + - FAILED AddCon.quotientQuotientEquivQuotient._proof_3 (1c83d0129c48b84a): resource:States; N 691, cand 474, raw 3833 B, 2345 ms + - FAILED EuclideanGeometry.dist_le_of_wbtw_of_mem_perpBisector (1d53382ea7bed76e): resource:States; N 1764, cand 1126, raw 12062 B, 4254 ms + - FAILED complEDS₂_mul_b (1de35f2369510380): resource:States; N 2963, cand 1785, raw 17395 B, 4182 ms + - FAILED Std.Tactic.BVDecide.BVExpr.bitblast.goCache_decl_eq._mutual (1f13644c31ee2c19): resource:States; N 44737, cand 35231, raw 270991 B, 42764 ms + - FAILED CartanMatrix.C_off_diag_nonpos (2017e973fe83a45b): resource:States; N 525, cand 253, raw 2892 B, 3554 ms + - FAILED Zsqrtd.decompose (24d6b3cfc3809d01): resource:States; N 327, cand 150, raw 2295 B, 4708 ms + - FAILED List.min_findIdx_findIdx (25482ede969f4d9e): resource:States; N 932, cand 461, raw 5351 B, 4635 ms + - FAILED Set.monotoneOn_or_antitoneOn_iff_uIcc (264ab42cdbcaa5c6): resource:States; N 1344, cand 920, raw 7531 B, 3528 ms + - FAILED Polynomial.dvd_comp_X_sub_C_iff (273494d41fcaae3f): resource:States; N 602, cand 397, raw 4690 B, 2566 ms + - FAILED zpow_eq_zpow_iff_of_ne_zero₀ (28553e75283e9a61): resource:States; N 594, cand 336, raw 4454 B, 6299 ms + - FAILED CategoryTheory.Bicategory.Adjunction.isAbsoluteLeftKanLift._proof_4 (2909d930ae477950): resource:States; N 6847, cand 4708, raw 38796 B, 4953 ms + - FAILED Prod.Lex.sumLexProdLexDistrib._proof_1 (292d41e89a00a4fa): resource:States; N 2507, cand 1591, raw 14197 B, 10043 ms + - FAILED intervalIntegral.integral_comp_mul_right (2aada36dbd06cc8d): resource:States; N 1530, cand 929, raw 11444 B, 5194 ms + - FAILED Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.insertUnitInvariant_insertUnit (2ab0e669a71f1cee): resource:States; N 15224, cand 10198, raw 86345 B, 3954 ms + - FAILED CategoryTheory.Dial.braiding._proof_1 (2c26af64ab305430): resource:States; N 941, cand 594, raw 5979 B, 3398 ms + - FAILED Prod.card_box_succ (2d19429c790de96d): resource:States; N 1880, cand 1048, raw 10287 B, 4692 ms + - FAILED IsEllipticNet.atomRel_neg₄ (2d441e9a9d3af54a): resource:States; N 213, cand 113, raw 1561 B, 1973 ms + - FAILED Lean.Meta.Grind.Arith.Linear.Struct.mk.injEq (2f66fbe26af9d61a): resource:States; N 3259, cand 604, raw 9267 B, 28252 ms + - FAILED EReal.instPosMulMono (2fc524512bab92de): resource:States; N 628, cand 383, raw 4820 B, 3215 ms + - FAILED _private.Std.Time.Date.Unit.Month.0.Std.Time.Month.Ordinal.days_gt_27.match_1_1 (30cce42f1e4c4f83): resource:States; N 960, cand 404, raw 4698 B, 4061 ms + - FAILED Complex.one_div_sub_sq_sub_one_div_sq_hasFPowerSeriesOnBall_zero (31ee93ae3848d2f9): resource:States; N 8914, cand 5531, raw 51729 B, 2504 ms + - FAILED RelEmbedding.sumLexMap._proof_1 (32110f704abc33da): resource:States; N 665, cand 358, raw 3294 B, 3385 ms + - FAILED _private.Mathlib.Combinatorics.Enumerative.Catalan.Basic.0.gosper_trick (325b041e7ba326e5): resource:States; N 7619, cand 3365, raw 41127 B, 4182 ms + - FAILED WeierstrassCurve.Jacobian.map_polynomial (328ad9b48fc6ff72): resource:States; N 1379, cand 799, raw 8661 B, 6643 ms + - FAILED Finset.affineCombination_apply_eq_lineMap_sum (3441a23edd3120c2): resource:States; N 1720, cand 1037, raw 10298 B, 2880 ms + - FAILED CategoryTheory.Bicategory.Adjunction.isAbsoluteLeftKan._proof_5 (344e5652e6540022): resource:States; N 6756, cand 4715, raw 38383 B, 4881 ms + - FAILED _private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.relation_mul_id_pow_six_eventuallyEq (368b4890271c9406): resource:States; N 6847, cand 3217, raw 39824 B, 3353 ms + - FAILED WeierstrassCurve.Projective.map_addZ (37096382f74a4bd1): resource:States; N 1860, cand 974, raw 10302 B, 4963 ms + - FAILED CategoryTheory.MonoidalCategory.tensor_associativity (3771515bb921dcd5): resource:States; N 13842, cand 7979, raw 72675 B, 2958 ms + - FAILED Ordnode.Valid'.merge_aux (37cf400883f57aab): resource:States; N 1947, cand 809, raw 9546 B, 4491 ms + - FAILED convexOn_univ_piecewise_Iic_of_antitoneOn_Iic_monotoneOn_Ici (38fb1d954ee6758f): resource:States; N 3212, cand 2229, raw 18124 B, 3704 ms + - FAILED IsEllipticNet.atomRel_abs₄ (39deaf6bfcbb2e33): resource:States; N 215, cand 115, raw 1596 B, 1962 ms + - FAILED CategoryTheory.OplaxFunctor.casesOn (3b10a9dc9464ee19): resource:States; N 2052, cand 1589, raw 11070 B, 4081 ms + - FAILED Ordnode.size_balance' (3b9bb4520c80dc3d): resource:States; N 471, cand 252, raw 2677 B, 3374 ms + - FAILED WeierstrassCurve.Projective.map_negAddY (3c5b17d94e4c297e): resource:States; N 2850, cand 1426, raw 14727 B, 10894 ms + - FAILED CategoryTheory.Pseudofunctor.leftZigzag_map (3ce5d1a68f3a06a7): resource:States; N 2183, cand 1246, raw 11834 B, 5512 ms + - FAILED Std.Internal.UV.System.RUsage.mk.injEq (3d81b05e6de39948): resource:States; N 737, cand 177, raw 2159 B, 4901 ms + - FAILED Std.DTreeMap.Internal.Impl.maxKeyD_eq_iff_getKey?_eq_self_and_forall (3ddaef4a3f7ea95c): resource:States; N 474, cand 261, raw 2958 B, 2238 ms + - FAILED List.cons_append_cons_perm (3ea9f1a9b25c2e70): resource:States; N 226, cand 109, raw 1300 B, 3205 ms + - FAILED Lean.Meta.Grind.Arith.CommRing.Ring.mk.injEq (3f0132438e01d6f4): resource:States; N 859, cand 239, raw 2849 B, 4114 ms + - FAILED LinearIsometry.inner_map_map (3fc316ba4eddd12b): resource:States; N 1064, cand 818, raw 7655 B, 2973 ms + - FAILED Set.Countable.isPathConnected_compl_of_one_lt_rank (3feaa9164eb44d85): resource:States; N 6576, cand 3723, raw 42734 B, 4605 ms + - FAILED CategoryTheory.Pseudofunctor.DescentData'.descentDataEquivalence._proof_7 (41b6e77508113e16): resource:States; N 1659, cand 1318, raw 10447 B, 3099 ms + - FAILED Fin.partialProd_init (4400cf5c19bc4b7e): resource:States; N 290, cand 163, raw 1970 B, 2409 ms + - FAILED List.prod_map_ite_eq (44e27887a64d4b41): resource:States; N 1341, cand 668, raw 7497 B, 2249 ms + - FAILED CategoryTheory.Pseudofunctor.CoGrothendieck.Hom.mk.noConfusion (44eef3b46444bd28): resource:States; N 613, cand 530, raw 4218 B, 1656 ms + - FAILED NNReal.young_inequality_real (454dd605b1b8b067): resource:States; N 196, cand 103, raw 1698 B, 1728 ms + - FAILED CategoryTheory.Bicategory.adjointifyCounit_left_triangle (45577bdac27616ef): resource:States; N 8186, cand 4661, raw 42017 B, 4193 ms + - FAILED Polynomial.IsUnitTrinomial.irreducible_aux1 (464dd0e72bdf7500): resource:States; N 3207, cand 1453, raw 18983 B, 3209 ms + - FAILED PMF.bindOnSupport_comm (47adcca9aeb07114): resource:States; N 1589, cand 1011, raw 9669 B, 3848 ms + - FAILED Std.Http.Protocol.H1.Config.mk.injEq (48384b9de1b7b380): resource:States; N 946, cand 225, raw 2791 B, 6649 ms + - FAILED Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ (4838899f29ca9e49): resource:States; N 30996, cand 16594, raw 157655 B, 2917 ms + - FAILED _private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.0.WeierstrassCurve.expCoeff_rec (48ed6ea90d289946): resource:States; N 12101, cand 5735, raw 62490 B, 6282 ms + - FAILED Sum.instLocallyFiniteOrder._proof_2 (4a06e3c04cd028c9): resource:States; N 1499, cand 678, raw 7585 B, 3510 ms + - FAILED Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.denote_go_eq_divRec_q (4a2b19833f605648): resource:States; N 2631, cand 1861, raw 15449 B, 6338 ms + - FAILED _private.Mathlib.Order.CompleteLattice.MulticoequalizerDiagram.0.Lattice.BicartSq.multicoequalizerDiagram._proof_1_1 (4a571917cd4ac2b0): resource:States; N 932, cand 489, raw 5550 B, 4133 ms + - FAILED Int.bitwise_bit (4ad7a17ea5a63762): resource:States; N 1766, cand 773, raw 7970 B, 3936 ms + - FAILED Std.DTreeMap.Internal.Impl.Const.minKeyD_alter_eq_self (4b4390df2f17f5bc): resource:States; N 964, cand 497, raw 5501 B, 2870 ms + - FAILED Ordnode.dual_balanceL (4c69a982aae8a80d): resource:States; N 4830, cand 2058, raw 21823 B, 3876 ms + - FAILED _private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula.0.WeierstrassCurve.Affine.addPolynomial_slope._proof_1_1 (4c96fa973a83d04e): resource:States; N 2276, cand 1497, raw 14292 B, 2192 ms + - FAILED CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.Hom.mk.noConfusion (4de92a6ba54f9c55): resource:States; N 890, cand 759, raw 6048 B, 1794 ms + - FAILED Lean.Elab.Tactic.BVDecide.BVDecideConfig.mk.injEq (4f69cec71e94aba7): resource:States; N 580, cand 157, raw 1885 B, 3742 ms + - FAILED RatFunc.mk_eq_localization_mk (4fab4f81cd92c405): resource:States; N 595, cand 449, raw 4227 B, 4087 ms + - FAILED CategoryTheory.Cat.isLimitProdCone._proof_3 (5120c36d00a372fd): resource:States; N 694, cand 580, raw 4757 B, 3995 ms + - FAILED MonoidAlgebra.mapRingHom_comp (51e789d353944203): resource:States; N 988, cand 738, raw 5847 B, 2785 ms + - FAILED Real.rpow_eq_zero_iff_of_nonneg (523bb3d69d7c57ba): resource:States; N 515, cand 218, raw 3356 B, 2130 ms + - FAILED Polynomial.coeff_divModByMonicAux_mem_span_pow_mul_span._unary (5242c51e3d3c751c): resource:States; N 6927, cand 4815, raw 43384 B, 3524 ms + - FAILED SimpleGraph.completeBipartiteGraphCongr._proof_1 (52ade6ccdecf2bd7): resource:States; N 383, cand 205, raw 2264 B, 2891 ms + - FAILED WeierstrassCurve.Projective.addZ_smul (5340e389e05d7f07): resource:States; N 7026, cand 3253, raw 35205 B, 11329 ms + - FAILED Equiv.swapCore_swapCore (53ad081a101c55ff): resource:States; N 844, cand 339, raw 3167 B, 4476 ms + - FAILED List.zip_eq_append_iff (53ceab4c4d118b7e): resource:States; N 439, cand 248, raw 2316 B, 2452 ms + - FAILED QuaternionAlgebra.instRing._proof_1 (55446000b79f4511): resource:States; N 15545, cand 6985, raw 72343 B, 2854 ms + - FAILED WeierstrassCurve.Projective.dblX_smul (55c2d089702c5ef0): resource:States; N 27252, cand 11090, raw 123591 B, 32153 ms + - FAILED PFun.prodLift_fst_comp_snd_comp (57964025fca1850a): resource:States; N 545, cand 350, raw 3343 B, 3281 ms + - FAILED hasSum_mellin_pi_mul₀ (57e841a4f099d987): resource:States; N 1780, cand 798, raw 11635 B, 4920 ms + - FAILED Ix.584076a12b43fd689f05fe14444694fb4a065983980d5fe49e1ae1cc8c147d1b.CategoryTheory.FreeBicategory.Rel.below (584076a12b43fd68): resource:States; N 1598, cand 570, raw 6571 B, 3669 ms + - FAILED SimplexCategory.δ_comp_σ_succ (5a7686636459de20): resource:States; N 1286, cand 782, raw 8285 B, 3842 ms + - FAILED WithBot.instPreorder._proof_2 (5cfe4fad7787ca79): resource:States; N 1929, cand 829, raw 9020 B, 4728 ms + - FAILED CategoryTheory.Bicategory.Adjunction.homEquiv₁._proof_4 (5d5fa428efcbd711): resource:States; N 5120, cand 3335, raw 27892 B, 5002 ms + - FAILED WeierstrassCurve.Projective.addX_smul (5d6423d1dd0739d1): resource:States; N 9992, cand 4045, raw 46074 B, 13233 ms + - FAILED UniqueFactorizationMonoid.normalize_normalized_factor (5da2c274d4614024): resource:States; N 842, cand 446, raw 4718 B, 2281 ms + - FAILED CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.Hom.comm_assoc (5e94d03d6cb1eaef): resource:States; N 832, cand 688, raw 5705 B, 2647 ms + - FAILED Lean.Lsp.ServerCapabilities.mk.injEq (60123ffe2bd5e279): resource:States; N 995, cand 264, raw 3195 B, 5565 ms + - FAILED _private.Mathlib.Combinatorics.Additive.Corner.Roth.0.Corners.triangleIndices.instExplicitDisjoint (60c8412247e84115): resource:States; N 690, cand 279, raw 3458 B, 4467 ms + - FAILED _private.Mathlib.NumberTheory.EllipticDivisibilitySequence.0.IsEllipticNet.atomRel_avg_sub._proof_1_4 (6188ae350b203b04): resource:States; N 3185, cand 2008, raw 18490 B, 3439 ms + - FAILED CategoryTheory.GlueData.ofGlueData'._proof_7 (62166e0ed13f509c): resource:States; N 22638, cand 16419, raw 128142 B, 8276 ms + - FAILED CategoryTheory.InjectiveResolution.descHomotopy (62592cafa5427743): resource:States; N 541, cand 337, raw 3321 B, 2547 ms + - FAILED GaussianFourier.integral_cexp_neg_mul_sq_add_real_mul_I (62de409bc332fe35): resource:States; N 3723, cand 2011, raw 26250 B, 2861 ms + - FAILED Lean.Grind.Ring.OfSemiring.instOrderedRingQOfLawfulOrderLTOfExistsAddOfLT (63bcc228082342f2): resource:States; N 3608, cand 2003, raw 18781 B, 3253 ms + - FAILED AlgebraicGeometry.Scheme.Hom.appIso_inv_naturality_assoc (63beda518b4c3caf): resource:States; N 513, cand 379, raw 3483 B, 2158 ms + - FAILED iteratedDeriv_vcomp_three (6647aed377ffb0e3): resource:States; N 1192, cand 767, raw 8749 B, 3814 ms + - FAILED Int.strongNormalizationMonoid._proof_2 (6858a60214fe6666): resource:States; N 677, cand 428, raw 4940 B, 6303 ms + - FAILED Array.zip_eq_append_iff (69037dee155a0c78): resource:States; N 439, cand 248, raw 2308 B, 2757 ms + - FAILED AlgebraicGeometry.Scheme.Hom.appIso_hom_naturality_assoc (6a28b9864357fbfb): resource:States; N 501, cand 354, raw 3426 B, 2700 ms + - FAILED CategoryTheory.OplaxFunctor.rec (6ac688d5ae5f21ac): resource:States; N 2042, cand 1584, raw 10990 B, 4130 ms + - FAILED HomologicalComplex.biprodX_ext_to_iff (6be87f75e68863bd): resource:States; N 1299, cand 928, raw 7715 B, 3779 ms + - FAILED ordinaryHypergeometricSeries_norm_div_succ_norm (6c7883918290488f): resource:States; N 6112, cand 3405, raw 35193 B, 4233 ms + - FAILED Fin.cycleIcc.trans (6d1c00584b709bb1): resource:States; N 1091, cand 552, raw 5995 B, 4159 ms + - FAILED Matrix.SpecialLinearGroup.diag_commute (6ebe53dc928fdd31): resource:States; N 3441, cand 2341, raw 20367 B, 4741 ms + - FAILED Nat.pow_sub_one_mod_pow_sub_one (6ed252dbe1ca71c3): resource:States; N 2532, cand 1138, raw 14593 B, 4079 ms + - FAILED Std.Http.Config.mk.injEq (6f07788f8a1f5f3d): resource:States; N 1501, cand 338, raw 4414 B, 15590 ms + - FAILED WeierstrassCurve.map_preΨ₄ (6fdb27178066110b): resource:States; N 1953, cand 1050, raw 10793 B, 3908 ms + - FAILED EReal.toReal_mul (70454a29d4ab18ce): resource:States; N 432, cand 203, raw 2886 B, 3328 ms + - FAILED CategoryTheory.Pseudofunctor.CoGrothendieck.Hom.noConfusionType (71ad05661ab480b3): resource:States; N 693, cand 400, raw 3838 B, 2666 ms + - FAILED Ordnode.all_balance' (71dc41de18268698): resource:States; N 592, cand 313, raw 3337 B, 3307 ms + - FAILED complEDS'_odd (72a8bac9942cd02e): resource:States; N 1221, cand 959, raw 8592 B, 3526 ms + - FAILED CategoryTheory.Bicategory.postcomp₂._proof_2 (72f4feea510e0955): resource:States; N 946, cand 823, raw 6711 B, 1669 ms + - FAILED CategoryTheory.OplaxFunctor.mk.injEq (7421c4335aeed7f5): resource:States; N 6774, cand 4665, raw 34342 B, 4644 ms + - FAILED Std.LinearPreorderPackage.ofOrd._proof_9 (74c94685bcbe1dbf): resource:States; N 401, cand 226, raw 2606 B, 3442 ms + - FAILED RelEmbedding.sumLiftRelMap._proof_1 (74ec13bbbbd22446): resource:States; N 690, cand 363, raw 3399 B, 3482 ms + - FAILED QuadraticForm.tmul_comp_tensorComm (755b1be5631c5287): resource:States; N 6104, cand 5273, raw 38426 B, 3325 ms + - FAILED Fin.insertNthOrderIso._proof_1 (762b4c08bd68c305): resource:States; N 474, cand 263, raw 2860 B, 2615 ms + - FAILED Int.fdiv_eq_ediv (790ad4904df2cf4c): resource:States; N 1262, cand 551, raw 6871 B, 4768 ms + - FAILED Equiv.sumCompl._proof_2 (7983bf016f96b11b): resource:States; N 224, cand 140, raw 1359 B, 2024 ms + - FAILED Lean.Grind.Config.mk.injEq (79a818e3bc347ced): resource:States; N 3512, cand 551, raw 8939 B, 24075 ms + - FAILED WeierstrassCurve.Jacobian.map_addX (7a238a3b165c8b98): resource:States; N 1957, cand 974, raw 10508 B, 7348 ms + - FAILED ENNReal.zero_rpow_mul_self (7b060622585e6615): resource:States; N 338, cand 189, raw 2473 B, 3303 ms + - FAILED complEDS_odd (7b88a7a0758d63f8): resource:States; N 5602, cand 2814, raw 30541 B, 4171 ms + - FAILED WeierstrassCurve.Projective.negDblY_smul (7d2f95bea351a5d5): resource:States; N 34580, cand 13405, raw 157201 B, 20857 ms + - FAILED AddMonoidAlgebra.mapDomainRingHom_comp (7e815adb73c746c8): resource:States; N 1053, cand 752, raw 6251 B, 3204 ms + - FAILED Lean.Meta.Grind.Arith.Cutsat.State.mk.injEq (7ed8e8a1cfe80863): resource:States; N 1648, cand 470, raw 5927 B, 8226 ms + - FAILED CompositionSeries.Equivalent.symm (7ef7db76725b1a60): resource:States; N 607, cand 477, raw 3922 B, 2989 ms + - FAILED CategoryTheory.OplaxFunctor.mapComp_naturality_left_app_assoc (7f1bf500d933618e): resource:States; N 828, cand 647, raw 5140 B, 2959 ms + - FAILED Multiset.prod_X_sub_X_eq_sum_esymm (7f4e5b344f37104f): resource:States; N 1425, cand 723, raw 8966 B, 1917 ms + - FAILED USize.toUInt64_shiftRight (7fa9ab3277164432): resource:States; N 822, cand 397, raw 5348 B, 3004 ms + - FAILED WeierstrassCurve.exists_isIntegral (7fef0608befcf277): resource:States; N 7647, cand 4615, raw 48721 B, 2883 ms + - FAILED SimpleGraph.Walk.count_edges_takeUntil_le_one (805d1ef524524a07): resource:States; N 4032, cand 1683, raw 18086 B, 5986 ms + - FAILED CategoryTheory.Pseudofunctor.presheafHom (809d4c861f7b0420): resource:States; N 613, cand 479, raw 4066 B, 2048 ms + - FAILED CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence._proof_9 (80b23956e6c036a6): resource:States; N 810, cand 779, raw 6321 B, 1938 ms + - FAILED Sum.instLocallyFiniteOrder._proof_4 (818a88a6c0522b21): resource:States; N 1473, cand 668, raw 7370 B, 4394 ms + - FAILED CartanMatrix.B_off_diag_nonpos (81a6758ac9cb629b): resource:States; N 506, cand 246, raw 2837 B, 3428 ms + - FAILED CommRingCat.tensorProdIsoPushout._proof_1 (82360661527d0711): resource:States; N 2794, cand 2206, raw 19522 B, 3053 ms + - FAILED QuadraticForm.tmul_comp_tensorAssoc (824caddf19dcd99d): resource:States; N 12575, cand 10916, raw 78645 B, 7379 ms + - FAILED ordinaryHypergeometricSeries_radius_eq_one (8251ca1dd406b1bc): resource:States; N 11252, cand 7786, raw 67264 B, 2579 ms + - FAILED _private.Mathlib.Algebra.Jordan.Basic.0.aux2 (825a7f9d31cf57ef): resource:States; N 1095, cand 735, raw 7088 B, 2648 ms + - FAILED Ix.838918e4fa0df72973acb0540729e5e272cef5a708a29fafa16d1bdea2a2a360.CategoryTheory.FreeBicategory.Rel (838918e4fa0df729): resource:States; N 1155, cand 473, raw 4546 B, 5404 ms + - FAILED LinearIndependent.pair_add_smul_left_iff (83d7722edb43f607): resource:States; N 1250, cand 747, raw 7980 B, 6323 ms + - FAILED _private.Mathlib.Condensed.Light.Sequence.0.InternalProjectivityProof.cocone._proof_1 (844e1dc8428f7713): resource:States; N 7457, cand 5572, raw 47350 B, 4527 ms + - FAILED _private.Std.Http.Data.URI.Encoding.0.Std.Http.URI.hexDigit_isHexDigit (8497d40dd9ce756a): resource:States; N 1437, cand 631, raw 7923 B, 3736 ms + - FAILED preNormEDS'_even (84d91e862b60c351): resource:States; N 962, cand 745, raw 6731 B, 2741 ms + - FAILED Complex.integral_boundary_rect_of_hasFDerivAt_real_off_countable (85b5430e1902fb09): resource:States; N 4606, cand 2780, raw 28921 B, 5031 ms + - FAILED _private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.size_roo._proof_1_1 (87f5bd76e627d460): resource:States; N 3423, cand 2107, raw 18960 B, 3182 ms + - FAILED NNReal.toReal_liminf (886e58834b680832): resource:States; N 1121, cand 470, raw 6533 B, 3859 ms + - FAILED Lean.Meta.Config.mk.injEq (88a8fe1cee22f3a2): resource:States; N 953, cand 231, raw 2801 B, 7526 ms + - FAILED Nat.even_mul (88e2e61a254db53c): resource:States; N 458, cand 254, raw 2737 B, 5206 ms + - FAILED CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.Hom.rec (8954d7950abe8690): resource:States; N 750, cand 647, raw 5047 B, 2235 ms + - FAILED IsEllipticNet.rel_eq (8aa86f0cff06f689): resource:States; N 2767, cand 1004, raw 13190 B, 6485 ms + - FAILED Int.mul_mem_zero_one_two_three_four_iff (8c33c9187f000539): resource:States; N 17513, cand 7589, raw 80914 B, 4253 ms + - FAILED hasFPowerSeriesAt_clog_one (8cec083c886dd675): resource:States; N 8705, cand 5496, raw 51933 B, 2389 ms + - FAILED crossProduct._proof_5 (8e5bb3ed61584188): resource:States; N 767, cand 541, raw 5406 B, 2087 ms + - FAILED AlgHom.mulLeftRightMatrix.inv_comp (8f4148a124e01826): resource:States; N 9612, cand 8372, raw 61875 B, 4344 ms + - FAILED CategoryTheory.Pseudofunctor.DescentData.instCategory._proof_2 (91cadc0732eec323): resource:States; N 1187, cand 883, raw 7273 B, 4485 ms + - FAILED List.formPerm_apply_mem_of_mem (91d5657e420c6b08): resource:States; N 1072, cand 466, raw 5235 B, 3867 ms + - FAILED associator_cocycle (92335d6c3c2d1ce3): resource:States; N 229, cand 126, raw 1567 B, 2429 ms + - FAILED MonoidAlgebra.mapDomainRingHom_comp (962c3abe81315a60): resource:States; N 1052, cand 752, raw 6187 B, 2617 ms + - FAILED LieModule.Cohomology.d₂₃._proof_6 (96d50dfc59abe333): resource:States; N 3512, cand 2567, raw 22225 B, 2343 ms + - FAILED Std.DTreeMap.Internal.Impl.minKeyD_eq_iff_getKey?_eq_self_and_forall (9846ee4ba946bb09): resource:States; N 474, cand 261, raw 2961 B, 3127 ms + - FAILED CategoryTheory.Bicategory.Adjunction.comp_right_triangle_aux (9a985ef3da377623): resource:States; N 11168, cand 6655, raw 58092 B, 7730 ms + - FAILED List.permutations_take_two (9b5341fea812f904): resource:States; N 975, cand 442, raw 4623 B, 5758 ms + - FAILED BitVec.getMsbD_setWidth (9ba8c88e4f376482): resource:States; N 1044, cand 580, raw 6292 B, 4424 ms + - FAILED CategoryTheory.Pseudofunctor.CoGrothendieck.category._proof_2 (9d02d36fd8561096): resource:States; N 1615, cand 1206, raw 10852 B, 1344 ms + - FAILED Algebra.TensorProduct.assoc._proof_3 (9e8a255342cc5aa2): resource:States; N 11531, cand 10252, raw 71709 B, 4943 ms + - FAILED _private.Mathlib.Topology.Sheaves.Flasque.0.isFlasque_skyscraperSheaf_of_epi_from._proof_1_4 (9ee6d021052e769a): resource:States; N 763, cand 571, raw 5457 B, 3040 ms + - FAILED CategoryTheory.Mat_.lift_additive (9f271d1cfda1de5d): resource:States; N 1269, cand 866, raw 7632 B, 4056 ms + - FAILED ProbabilityTheory.IsRatStieltjesPoint.ite (9face6034105de96): resource:States; N 516, cand 274, raw 3281 B, 3229 ms + - FAILED SkyscraperPresheafFunctor.map'._proof_1 (a05c52d70a2c238b): resource:States; N 1467, cand 1032, raw 8892 B, 2963 ms + - FAILED RingCon.quotientQuotientEquivQuotient._proof_4 (a12d2e35e480f974): resource:States; N 629, cand 459, raw 3611 B, 2048 ms + - FAILED Sum.instLocallyFiniteOrder._proof_1 (a176103b8d631c29): resource:States; N 1473, cand 668, raw 7415 B, 3255 ms + - FAILED PosNum.cmp_swap (a265895219e25b2e): resource:States; N 622, cand 227, raw 2671 B, 4456 ms + - FAILED Std.DTreeMap.Internal.Impl.minKey!_eq_iff_getKey?_eq_self_and_forall (a434dbaf11f008e7): resource:States; N 468, cand 259, raw 2967 B, 2730 ms + - FAILED EisensteinSeries.D2_mul (a44779c68492889c): resource:States; N 4586, cand 2468, raw 31406 B, 3335 ms + - FAILED Matrix.adjugate_fin_three (a55d6767308a54cc): resource:States; N 18499, cand 11522, raw 102293 B, 7902 ms + - FAILED LinearIndependent.pair_add_smul_right_iff (a5e699aad818e70f): resource:States; N 1258, cand 749, raw 8072 B, 6233 ms + - FAILED _private.Init.Data.String.Decode.0.UInt8.utf8ByteSize_eq_utf8ByteSize_parseFirstByte (a60acec5ca548536): resource:States; N 1056, cand 569, raw 6019 B, 5242 ms + - FAILED PeriodPair.summable_weierstrassPExceptSummand (a6cd91e6b481b1ce): resource:States; N 10757, cand 5284, raw 71551 B, 3686 ms + - FAILED preNormEDS_even (a6dd2dcc70523304): resource:States; N 5003, cand 2317, raw 27237 B, 3549 ms + - FAILED SSet.Truncated.HomotopyCategory.homToNerveMk._proof_1 (ab9d7356862bfe33): resource:States; N 5673, cand 3628, raw 32402 B, 4502 ms + - FAILED Turing.PartrecToTM2.tr_ret_respects (ad02ebc1e8923bfd): resource:States; N 4304, cand 2073, raw 23846 B, 2615 ms + - FAILED HasMFDerivWithinAt.hcongr_24 (ad63aeb0a1436353): resource:States; N 6865, cand 1852, raw 23700 B, 39439 ms + - FAILED UpperHalfPlane.exists_SL2_smul_eq_of_apply_zero_one_ne_zero (adc2b066d2f6ba14): resource:States; N 1982, cand 1233, raw 14736 B, 3034 ms + - FAILED _private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss.0.Polynomial.Chebyshev.sum_exp._proof_1_3 (aefeac3931c5554c): resource:States; N 1517, cand 1213, raw 11863 B, 3626 ms + - FAILED _private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.relation_add_coe (af481bb774050c36): resource:States; N 643, cand 333, raw 4684 B, 1963 ms + - FAILED _private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Lemmas.0.RootPairing.chainBotCoeff_mul_chainTopCoeff.aux_1 (af609e9270f1ac5f): resource:States; N 7945, cand 4124, raw 46232 B, 4113 ms + - FAILED Interval.lattice._proof_3 (b06abafdc4498d03): resource:States; N 459, cand 250, raw 2829 B, 2895 ms + - FAILED WithOne.unoneD_eq_iff (b1847519022b7343): resource:States; N 261, cand 86, raw 1656 B, 3599 ms + - FAILED Polynomial.discr_of_degree_eq_two (b2338e6157a26a6a): resource:States; N 24649, cand 17277, raw 144709 B, 4915 ms + - FAILED Set.nonempty_Ico_sdiff (b25c95dc784482a0): resource:States; N 1006, cand 512, raw 6385 B, 3790 ms + - FAILED Int.Internal.Linear.cooper_right (b3180268914b846b): resource:States; N 2365, cand 1160, raw 12378 B, 5580 ms + - FAILED WeierstrassCurve.Jacobian.map_negAddY (b4fe31f265e5e253): resource:States; N 3377, cand 1582, raw 17199 B, 10993 ms + - FAILED ProbabilityTheory.hasFPowerSeriesAt_mgf (b674f4e1ebeeebef): resource:States; N 8228, cand 5286, raw 44888 B, 2720 ms + - FAILED AlgebraicGeometry.Scheme.Hom.appIso (b72a5a839fdda20b): resource:States; N 211, cand 137, raw 1837 B, 2271 ms + - FAILED WeierstrassCurve.Jacobian.nonsingular_some (b75b2fd142fe91ce): resource:States; N 5458, cand 2755, raw 30199 B, 4643 ms + - FAILED _private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.derivative_mul._proof_1_1 (b7a482017f422ce2): resource:States; N 625, cand 426, raw 4712 B, 1965 ms + - FAILED CategoryTheory.Pseudofunctor.CoGrothendieck.Hom.ext_iff (b827e40f63210cf9): resource:States; N 955, cand 820, raw 6656 B, 1780 ms + - FAILED CategoryTheory.Pseudofunctor.DescentData.isoMk._proof_3 (b8396b9a9da7ff22): resource:States; N 1468, cand 1127, raw 9302 B, 2707 ms + - FAILED Real.mul_rpow (b845aaf952f8f741): resource:States; N 954, cand 482, raw 5826 B, 4687 ms + - FAILED Lean.Meta.DSimp.Config.mk.injEq (b886b7d44989227c): resource:States; N 746, cand 185, raw 2228 B, 4610 ms + - FAILED RootPairing.root_sub_root_mem_of_pairingIn_pos (b8c4ef4cdee56456): resource:States; N 6270, cand 3537, raw 35598 B, 3554 ms + - FAILED Affine.Triangle.scalene_iff_dist_ne_and_dist_ne_and_dist_ne (b8c9578e19e2f25b): resource:States; N 9499, cand 2928, raw 39715 B, 3263 ms + - FAILED WeierstrassCurve.Ψ_even (ba713e6a6083c231): resource:States; N 3955, cand 2681, raw 25234 B, 4576 ms + - FAILED CategoryTheory.Bicategory.Adjunction.comp_left_triangle_aux (bb32cb6f221a5b09): resource:States; N 11254, cand 6637, raw 58366 B, 8380 ms + - FAILED Path.truncate._proof_3 (bb5b22e2cb712f24): resource:States; N 845, cand 431, raw 5310 B, 3083 ms + - FAILED List.sum_map_ite (bb9de0401d682b1c): resource:States; N 1248, cand 663, raw 7000 B, 3254 ms + - FAILED LinearMap.uncurryMid._proof_1 (bc2f74815a170488): resource:States; N 1670, cand 1166, raw 9867 B, 3554 ms + - FAILED Polynomial.hasseDeriv_comp (bc31dc5dbae349b7): resource:States; N 3271, cand 1656, raw 20269 B, 4298 ms + - FAILED WeierstrassCurve.Projective.map_dblX (bce37c4863c98968): resource:States; N 7729, cand 2988, raw 35732 B, 45285 ms + - FAILED Convex.isLittleO_alternate_sum_square (bd1f2c92a1695258): resource:States; N 9815, cand 6322, raw 59914 B, 6067 ms + - FAILED OrderIso.sumCongr._proof_2 (bd2a1de85b70ef48): resource:States; N 669, cand 337, raw 3482 B, 3271 ms + - FAILED WithBot.unbotD_eq_iff (bde54059d23daa38): resource:States; N 253, cand 79, raw 1564 B, 3993 ms + - FAILED Polynomial.isLeftCancelMulZero_iff (bde6335bb10fe6a8): resource:States; N 1821, cand 946, raw 11007 B, 3598 ms + - FAILED Matrix.diagonal_fin_three (bf8d4c6a163aab12): resource:States; N 1644, cand 798, raw 8680 B, 3312 ms + - FAILED _private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.insert (bfcbe4ebde3e47d5): resource:States; N 1250, cand 248, raw 6803 B, 29399 ms + - FAILED FirstOrder.Field.charP_iff_model_fieldOfChar (bfd93b81add0b86f): resource:States; N 1480, cand 874, raw 10017 B, 4309 ms + - FAILED CategoryTheory.Bicategory.LeftLift.IsKan.adjunction._proof_2 (c01ca73d6bb69fb7): resource:States; N 5580, cand 3926, raw 31730 B, 4639 ms + - FAILED _private.Std.Time.Date.Unit.Month.0.Std.Time.Month.Ordinal.cumulativeDays_le.match_1_1 (c0704b1f2bea457b): resource:States; N 961, cand 404, raw 4679 B, 5479 ms + - FAILED CategoryTheory.Pseudofunctor.CoGrothendieck.Hom.congr (c0f491950a0466c0): resource:States; N 671, cand 587, raw 4796 B, 1964 ms + - FAILED Lean.Grind.Ring.OfSemiring.right_distrib (c163676b7110408a): resource:States; N 1235, cand 668, raw 6747 B, 3710 ms + - FAILED Std.Time.DateFormatSymbols.mk.injEq (c173daf6bbd1887d): resource:States; N 1429, cand 335, raw 4256 B, 14042 ms + - FAILED Std.Time.Month.Ordinal.difference_eq (c46a7632603ee8d6): resource:States; N 5269, cand 2903, raw 28842 B, 5054 ms + - FAILED CategoryTheory.FreeBicategory.liftHom₂_congr (c539f83b65f53ec1): resource:States; N 3526, cand 1881, raw 17748 B, 4323 ms + - FAILED CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_unitIso_inv_naturality_assoc (c56b24e1dad10ac3): resource:States; N 477, cand 341, raw 3149 B, 1501 ms + - FAILED Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.rupAdd_result (c5e6fa6fd60b1721): resource:States; N 2370, cand 1269, raw 12344 B, 3588 ms + - FAILED WeierstrassCurve.Projective.map_addX (c779138c95a72602): resource:States; N 2604, cand 1290, raw 13513 B, 10220 ms + - FAILED IsOpenMap.pullbackObjIso_hom_naturality (c7c4650eb40566f9): resource:States; N 4106, cand 3358, raw 26358 B, 4745 ms + - FAILED RBTree.RBNode.Path.Ordered.fill._f (c7f15b0db1e38d5f): resource:States; N 1035, cand 480, raw 4733 B, 5338 ms + - FAILED preNormEDS_odd (c8ae888fffb97145): resource:States; N 5903, cand 2751, raw 31271 B, 2661 ms + - FAILED CategoryTheory.Bicategory.LeftExtension.IsKan.adjunction._proof_2 (c9eba00a21e017ac): resource:States; N 5557, cand 3655, raw 30614 B, 6845 ms + - FAILED _private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.sylvesterDeriv_of_natDegree_eq_three (cabce28d54f8e662): resource:States; N 32105, cand 14771, raw 156105 B, 4397 ms + - FAILED Lean.Grind.Ring.OfSemiring.mul_assoc (cacd32ba6398d117): resource:States; N 1372, cand 763, raw 7527 B, 4849 ms + - FAILED IsDiscreteValuationRing.toEuclideanDomain._proof_4 (cb687d8c6927e46e): resource:States; N 1148, cand 704, raw 7138 B, 4564 ms + - FAILED CategoryTheory.Pseudofunctor.DescentData'.comm_assoc (cbac8bf1386f68b4): resource:States; N 996, cand 810, raw 6351 B, 2475 ms + - FAILED _private.Init.Data.BitVec.Bitblast.0.BitVec.addRecAux_cpopTree._unary (cc0455870fa49978): resource:States; N 2614, cand 1427, raw 15542 B, 5006 ms + - FAILED tendsto_order._to_dual_1 (cd028329a6247ea6): resource:States; N 452, cand 254, raw 2759 B, 2657 ms + - FAILED OnePoint.map_smul (cd57d561038637e3): resource:States; N 2519, cand 1526, raw 14773 B, 3058 ms + - FAILED GenLoop.transAt_distrib (cda6b3d6b619b4bf): resource:States; N 3975, cand 2784, raw 23171 B, 3294 ms + - FAILED bihimp_triangle (ce0fd6874c8cb693): resource:States; N 260, cand 115, raw 1543 B, 2933 ms + - FAILED Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.mk.injEq (ce4ae3abeaa66b8d): resource:States; N 1500, cand 334, raw 4256 B, 18765 ms + - FAILED Interval.lattice._proof_2 (ced9fb3d3e8f1fc4): resource:States; N 459, cand 250, raw 2825 B, 3077 ms + - FAILED WeierstrassCurve.Affine.cyclic_sum_Y_mul_X_sub_X (cf04c82f6fa506a7): resource:States; N 10129, cand 6394, raw 57956 B, 3245 ms + - FAILED RingCon.quotientQuotientEquivQuotient._proof_3 (cf5302a6ec1fbd44): resource:States; N 629, cand 459, raw 3598 B, 2097 ms + - FAILED Lean.Meta.Simp.Config.mk.injEq (cf72eed2b476eae8): resource:States; N 1994, cand 376, raw 5298 B, 19592 ms + - FAILED WeierstrassCurve.Projective.negAddY_smul (cfceec4f9760fc88): resource:States; N 10831, cand 4697, raw 50913 B, 16523 ms + - FAILED Algebra.TensorProduct.tensorTensorTensorComm._proof_2 (d1bc3029e85ea857): resource:States; N 20808, cand 19243, raw 131570 B, 6341 ms + - FAILED CategoryTheory.Bicategory.conjugateEquiv_comp (d20aa44b163acd92): resource:States; N 8370, cand 4571, raw 42814 B, 2343 ms + - FAILED Int.cooper_resolution_dvd_right (d264fc7a3b27308f): resource:States; N 1138, cand 451, raw 5635 B, 2457 ms + - FAILED QuaternionAlgebra.instStarRing._proof_2 (d35d55c802ac75a6): resource:States; N 5869, cand 2538, raw 28780 B, 4076 ms + - FAILED _private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpConfigAux.evalConfigItem (d429aaec154add51): resource:States; N 1940, cand 407, raw 10168 B, 21340 ms + - FAILED CommGroupWithZero.instStrongNormalizedGCDMonoid._proof_7 (d4dcb32ffada7b7e): resource:States; N 821, cand 430, raw 5000 B, 3278 ms + - FAILED Std.LinearPreorderPackage.ofOrd._proof_1 (d6593f0cd64b97f6): resource:States; N 567, cand 297, raw 3329 B, 4035 ms + - FAILED Fin.partialSum_init (d7a635877bd89d57): resource:States; N 290, cand 163, raw 1965 B, 2505 ms + - FAILED LinearMap.uncurryLeft._proof_2 (d7be0a187b33fcf4): resource:States; N 1757, cand 1245, raw 10506 B, 2669 ms + - FAILED Lean.Meta.ExtractLetsConfig.mk.injEq (d7c4aa4ea0c241f0): resource:States; N 457, cand 122, raw 1489 B, 3077 ms + - FAILED CategoryTheory.CatEnriched.instBicategory._proof_11 (d84838fc1e6f8631): resource:States; N 877, cand 477, raw 4702 B, 4102 ms + - FAILED Set.preimage_boolIndicator (d8c1f44a2ba8c077): resource:States; N 1021, cand 479, raw 5182 B, 2797 ms + - FAILED Complex.cpow_eq_zero_iff (d90643da4951c497): resource:States; N 460, cand 192, raw 2908 B, 2520 ms + - FAILED CategoryTheory.MonoidalCategory.rightUnitor_monoidal (d968b12135f9d92e): resource:States; N 2510, cand 1523, raw 13325 B, 3171 ms + - FAILED RootPairing.Base.root_add_root_mem_of_mem_of_mem (da0c7f822e133391): resource:States; N 2819, cand 1715, raw 17917 B, 3932 ms + - FAILED EisensteinSeries.eisSummand_SL2_apply (da7f69389d081e58): resource:States; N 5587, cand 3116, raw 34127 B, 2883 ms + - FAILED AlgebraicGeometry.Scheme.Hom.instIsIsoNormalizationPullbackOfSmooth (daa5d7f02cabe4d9): resource:States; N 23605, cand 19006, raw 149885 B, 2051 ms + - FAILED SimplexCategory.δ_comp_σ_self (dad509fef03e40d3): resource:States; N 1694, cand 1125, raw 11161 B, 3427 ms + - FAILED HomologicalComplex.alternatingConst._proof_4 (db82d9db6b5caa43): resource:States; N 732, cand 411, raw 4089 B, 2559 ms + - FAILED TopCat.GlueData.MkCore.t' (dbe062a0e0de18ee): resource:States; N 630, cand 468, raw 4649 B, 2319 ms + - FAILED PMF.toOuterMeasure_bindOnSupport_apply (dc147f356655cded): resource:States; N 1098, cand 619, raw 6499 B, 4663 ms + - FAILED IsEllipticNet.atomRel_avg_sub (dd3a57341da30718): resource:States; N 1335, cand 662, raw 6883 B, 6429 ms + - FAILED List.Nodup.rotate_congr_iff (dd887cf3ac294df0): resource:States; N 395, cand 142, raw 2259 B, 4304 ms + - FAILED PMF.bindOnSupport_bindOnSupport (de3fa84b83282950): resource:States; N 2529, cand 1709, raw 15279 B, 6255 ms + - FAILED symmDiff_triangle (de462c19e0336823): resource:States; N 260, cand 115, raw 1546 B, 2383 ms + - FAILED eq_or_eq_or_eq_of_forall_not_lt_lt (de94d7fccc323cf8): resource:States; N 369, cand 256, raw 2040 B, 2230 ms + - FAILED _private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.pIntegral_bernoulli_even_term (def365185027508d): resource:States; N 4560, cand 2573, raw 30109 B, 4100 ms + - FAILED ISize.toInt_bmod_two_pow_numBits (e0027ad59db96616): resource:States; N 449, cand 265, raw 3290 B, 3248 ms + - FAILED Float.Model.UnpackedFloat.unpack_beq_unpack_iff (e0e9b5e9762b8f06): resource:States; N 338, cand 148, raw 2304 B, 2068 ms + - FAILED CategoryTheory.Pseudofunctor.Grothendieck.Hom.noConfusionType (e18715b78d59b1ef): resource:States; N 615, cand 350, raw 3278 B, 2176 ms + - FAILED Int.even_mul (e2abe704472c2b9f): resource:States; N 471, cand 266, raw 2939 B, 3431 ms + - FAILED Sum.instLocallyFiniteOrder._proof_3 (e3966264d60b4ac7): resource:States; N 1499, cand 678, raw 7494 B, 4188 ms + - FAILED Nat.WithBot.add_eq_three_iff (e44c3223c4d0ffd5): resource:States; N 940, cand 351, raw 4755 B, 3033 ms + - FAILED WithBot.unbotD_eq_unbotD_iff (e4dd345b8a079d31): resource:States; N 320, cand 108, raw 1762 B, 3204 ms + - FAILED LieModule.Cohomology.d₂₃_comp_d₁₂ (e69ea582cebe3fd1): resource:States; N 4768, cand 3417, raw 28024 B, 4091 ms + - FAILED Std.DTreeMap.Internal.Impl.Const.maxKeyD_alter_eq_self (e6cd1281b1ee3725): resource:States; N 964, cand 497, raw 5440 B, 2573 ms + - FAILED Polynomial.Chebyshev.one_sub_X_sq_mul_iterate_derivative_T_eq_poly_in_T (e71cf5531f9a2562): resource:States; N 6334, cand 3439, raw 36248 B, 5061 ms + - FAILED WeierstrassCurve.map_b₈ (e8379e4697f41312): resource:States; N 923, cand 567, raw 5802 B, 2610 ms + - FAILED iteratedDeriv_scomp_three (e8422f86fcf5c6a5): resource:States; N 764, cand 562, raw 6219 B, 2973 ms + - FAILED _private.Mathlib.Data.Finsupp.Single.0.Finsupp.update_comm._proof_1_1 (e91fd4241b3a641f): resource:States; N 654, cand 369, raw 3504 B, 3505 ms + - FAILED WeierstrassCurve.Jacobian.polynomial_relation (ea93ed8e45d2ba10): resource:States; N 4947, cand 2320, raw 25558 B, 5106 ms + - FAILED jacobiSum_nontrivial_inv (ea9487fda33c55f5): resource:States; N 3552, cand 2112, raw 22968 B, 5096 ms + - FAILED WeierstrassCurve.Projective.map_negDblY (eac9493f9c619a72): resource:States; N 9567, cand 3594, raw 42548 B, 30753 ms + - FAILED hasFPowerSeriesOnBall_inverse_one_add (ede5a9778252585c): resource:States; N 8655, cand 5536, raw 47130 B, 2369 ms + - FAILED Batteries.UnionFind.parentD_linkAux (ee0bc3283dbfbfbb): resource:States; N 914, cand 531, raw 5046 B, 3066 ms + - FAILED CategoryTheory.Bicategory.LeftExtension.isKanOfWhiskerLeftAdjoint._proof_1 (ee2a364990c758e7): resource:States; N 6588, cand 4361, raw 37219 B, 3588 ms + - FAILED AlgebraicGeometry.continuousMapPresheaf._proof_2 (ef200218e86a63bf): resource:States; N 228, cand 200, raw 1933 B, 2618 ms + - FAILED RBTree.RBNode.Path.ordered_iff (f0b1bded271bf0b9): resource:States; N 3170, cand 1406, raw 14964 B, 5280 ms + - FAILED AddMonoidAlgebra.mapRingHom_comp (f0f4c81b4b62d6de): resource:States; N 989, cand 738, raw 5960 B, 3253 ms + - FAILED CategoryTheory.Pseudofunctor.DescentData.instCategory._proof_4 (f0f75fc624541337): resource:States; N 1500, cand 1067, raw 8745 B, 4411 ms + - FAILED iteratedDeriv_comp_three (f254d5e3cdf89797): resource:States; N 611, cand 429, raw 4960 B, 3519 ms + - FAILED Matroid.IsBase.inter_isBasis_iff_compl_inter_isBasis_dual (f2c497519d91bfe0): resource:States; N 243, cand 125, raw 1753 B, 1791 ms + - FAILED WeierstrassCurve.isHomogeneous_addSubMapCoeff (f2ce788af955876c): resource:States; N 60092, cand 31902, raw 311874 B, 5187 ms + - FAILED Polynomial.discr_of_degree_eq_three (f2e292bc76352c33): resource:States; N 21913, cand 12913, raw 121652 B, 3418 ms + - FAILED MultilinearMap.uncurryRight._proof_1 (f3251295a942cfc4): resource:States; N 1664, cand 1196, raw 9966 B, 4171 ms + - FAILED UpperHalfPlane.exists_SL2_smul_eq_of_apply_zero_one_eq_zero (f3b428d7c560e3b3): resource:States; N 2102, cand 1637, raw 16752 B, 2836 ms + - FAILED _private.Init.Data.Nat.Internal.SOM.0.Nat.Internal.SOM.Poly.add_denote.go (f933e2efb97ec29d): resource:States; N 1474, cand 606, raw 7574 B, 5413 ms + - FAILED isCusp_SL2Z_iff (f9e2e7cb8c1f6dbb): resource:States; N 3624, cand 2170, raw 26662 B, 4731 ms + - FAILED Complex.one_add_cpow_hasFPowerSeriesOnBall_zero (fa3f37ad7b85b1cb): resource:States; N 10183, cand 6170, raw 60521 B, 1792 ms + - FAILED UpperHalfPlane.σ_mul_comm (faa2c19f0849cb5c): resource:States; N 553, cand 385, raw 4582 B, 2738 ms + - FAILED _private.Std.Time.Date.Unit.Month.0.Std.Time.Month.Ordinal.difference_eq.match_1_1 (fb0b602bce49e7da): resource:States; N 1375, cand 613, raw 6421 B, 1734 ms + - FAILED VectorField.fderiv_apply_lieBracket_of_isSymmSndFDerivAt (fc01df351d858a80): resource:States; N 1083, cand 669, raw 7375 B, 1722 ms + - FAILED NumberField.InfinitePlace.not_isUnramified_iff (fc28af1bac4b86bf): resource:States; N 870, cand 383, raw 4883 B, 2650 ms + - FAILED _private.Mathlib.Probability.Distributions.Gaussian.Fernique.0.ProbabilityTheory.IsGaussian.integrable_exp_sq_of_conv_neg._proof_1_8 (fc47a6093d67ae77): resource:States; N 1254, cand 666, raw 8884 B, 2217 ms + - FAILED List.triplewise_reverse (fd07b3643a377b6d): resource:States; N 559, cand 210, raw 2983 B, 3343 ms + - FAILED CategoryTheory.Pseudofunctor.DescentData.iso._proof_8 (fedd85b0478390c2): resource:States; N 1006, cand 725, raw 5999 B, 3273 ms + - FAILED _private.Mathlib.Combinatorics.Extremal.RuzsaSzemeredi.0.mem_triangleIndices (ff5f5f0197adc640): resource:States; N 470, cand 346, raw 3616 B, 2167 ms +- certified constants: stored (heuristic) 1461462148 B; output under Tag4 1143404637 B (-21.76%); under TagN 1131330711 B (-22.59%) +- unshared (where it fits u64, 679157 constants): 214339347746089 B; stored 1461462148 B; Tag4 output 1143404637 B +- Tag4 output - stored per constant: 622989 smaller, 52448 equal, 3720 larger; min -258748 p1 -6128 p10 -949 p50 -114 p90 -1 p99 0 p99.9 12 max 248 +- TagN price - stored per constant: min -267397 p1 -6607 p10 -949 p50 -114 p90 -1 p99 0 p99.9 12 max 248 +- phase-1 width w: {1: 197682, 2: 479734, 3: 1741} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 6 p90 37 p99 147 p99.9 418 max 5756 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 4 p99 9 p99.9 15 max 21 +- uniform search states per constant: min 0 p1 0 p10 0 p50 21 p90 157 p99 1729 p99.9 47638 max 1046337 +- first-tier search states per constant: min 1 p1 1 p10 5 p50 20 p90 127 p99 780 p99.9 2618 max 30126 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 6 p50 66 p90 424 p99 2004 p99.9 6392 max 81833 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 1 p90 5 p99 52 p99.9 473 max 46722 +- slowest 10: + - 51806 ms mfderivWithin_projIcc_one (07c512baeb5f1c75): defn resource:States, N 5218, cand 1580, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 46722 ms CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56): defn ok, N 95110, cand 81833, k 21461, w 3, uncertain 5756, components 4422 (largest 9), states uniform 35812 first-tier 18449 + - 45285 ms WeierstrassCurve.Projective.map_dblX (bce37c4863c98968): defn resource:States, N 7729, cand 2988, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 42764 ms Std.Tactic.BVDecide.BVExpr.bitblast.goCache_decl_eq._mutual (1f13644c31ee2c19): defn resource:States, N 44737, cand 35231, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 39439 ms HasMFDerivWithinAt.hcongr_24 (ad63aeb0a1436353): defn resource:States, N 6865, cand 1852, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 32153 ms WeierstrassCurve.Projective.dblX_smul (55c2d089702c5ef0): defn resource:States, N 27252, cand 11090, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 30753 ms WeierstrassCurve.Projective.map_negDblY (eac9493f9c619a72): defn resource:States, N 9567, cand 3594, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 30729 ms addInvariantVectorField_eq_mpullback (c9b66788cffa121e): defn ok, N 5769, cand 1692, k 711, w 2, uncertain 338, components 150 (largest 21), states uniform 668790 first-tier 1050 + - 29808 ms _private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.mk.injEq (151105c7790e6da0): defn resource:States, N 2657, cand 586, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 + - 29478 ms WeierstrassCurve.Jacobian.negAddY_smul (0c1816c71ee7e564): defn resource:States, N 14839, cand 6369, k 0, w 0, uncertain 0, components 0 (largest 0), states uniform 0 first-tier 0 +- total wall 424.0 s + + Command being timed: "./target/release/examples/sharing_corpus $S/mathlib.ixe --threads 20 --csv $S/mathlib_tiered.csv --select-out $S/mathlib_select.txt" + Elapsed (wall clock) time (h:mm:ss or m:ss): 7:04.72 + Maximum resident set size (kbytes): 4794008 + Exit status: 0 +exit=0 +``` + +
+ +
[X1] width experiment, Init, TagN layout (wx_init_tagN.md) + +```text +# sharing_corpus width experiment (not the canonical construction) +- corpus: $S/init.ixe (56622 constants processed); layout TagN; phases 1-3 at w = 1, 2, 3 +- wall: processing 43.2 s with 8 threads; peak RSS 487180 KiB +- failures by width: w=1 0, w=2 0, w=3 0; constants with all three ok: 56622 +- layout bytes over those constants: K-based 67036818; best of three 66648677 (-388141); stored-count re-solve 66959837 (-76981) +- best-of-three width (ties to the lower w): w=1 45282, w=2 11156, w=3 184 +- best of three vs K-based per constant: better 20651, equal 35971; change min -2304 p1 -180 p10 -30 p50 -8 p90 -2 p99 -1 p99.9 -1 max -1 +- stored-count re-solve vs K-based per constant: better 7339, equal 48569, worse 714 +- total wall 47.5 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --layout tagN --threads 8 --width-experiment --csv $S/wx_init_tagN.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:47.61 + Maximum resident set size (kbytes): 485008 + Exit status: 0 +``` + +
+ +
[X1] width experiment, Mathlib, TagN layout (wx_ml_tagN.md) + +```text +# sharing_corpus width experiment (not the canonical construction) +- corpus: $S/mathlib.ixe (679499 constants processed); layout TagN; phases 1-3 at w = 1, 2, 3 +- wall: processing 1094.1 s with 8 threads; peak RSS 4841540 KiB +- failures by width: w=1 0, w=2 0, w=3 0; constants with all three ok: 679499 +- layout bytes over those constants: K-based 1136221078; best of three 1121777032 (-14444046); stored-count re-solve 1135433559 (-787519) +- best-of-three width (ties to the lower w): w=1 521916, w=2 156170, w=3 1413 +- best of three vs K-based per constant: better 297121, equal 382378; change min -11597 p1 -504 p10 -115 p50 -15 p90 -2 p99 -1 p99.9 -1 max -1 +- stored-count re-solve vs K-based per constant: better 64033, equal 600933, worse 14533 +- total wall 1277.0 s + + Command being timed: "./target/release/examples/sharing_corpus $S/mathlib.ixe --layout tagN --threads 8 --width-experiment --csv $S/wx_ml_tagN.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 21:17.93 + Maximum resident set size (kbytes): 4838516 + Exit status: 0 +exit=0 +``` + +
+ +
[X2] width experiment, Init, Tag4 layout (wx_init_tag4.md) + +```text +# sharing_corpus width experiment (not the canonical construction) +- corpus: $S/init.ixe (56622 constants processed); layout Tag4; phases 1-3 at w = 1, 2, 3 +- wall: processing 44.8 s with 8 threads; peak RSS 462596 KiB +- failures by width: w=1 0, w=2 0, w=3 0; constants with all three ok: 56622 +- layout bytes over those constants: K-based 67747841; best of three 67302328 (-445513); stored-count re-solve 67639163 (-108678) +- best-of-three width (ties to the lower w): w=1 45140, w=2 10981, w=3 501 +- best of three vs K-based per constant: better 20985, equal 35637; change min -1893 p1 -312 p10 -33 p50 -9 p90 -2 p99 -1 p99.9 -1 max -1 +- stored-count re-solve vs K-based per constant: better 7902, equal 47974, worse 746 +- total wall 49.9 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --layout tag4 --threads 8 --width-experiment --csv $S/wx_init_tag4.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:50.00 + Maximum resident set size (kbytes): 460272 + Exit status: 0 +exit=0 +``` + +
+ +
[X2] width experiment, Mathlib, Tag4 layout (wx_ml_tag4.md) + +```text +# sharing_corpus width experiment (not the canonical construction) +- corpus: $S/mathlib.ixe (679499 constants processed); layout Tag4; phases 1-3 at w = 1, 2, 3 +- wall: processing 1031.8 s with 8 threads; peak RSS 4853268 KiB +- failures by width: w=1 0, w=2 0, w=3 0; constants with all three ok: 679499 +- layout bytes over those constants: K-based 1151220860; best of three 1135614916 (-15605944); stored-count re-solve 1149312205 (-1908655) +- best-of-three width (ties to the lower w): w=1 518096, w=2 157708, w=3 3695 +- best of three vs K-based per constant: better 299934, equal 379565; change min -11153 p1 -530 p10 -128 p50 -15 p90 -2 p99 -1 p99.9 -1 max -1 +- stored-count re-solve vs K-based per constant: better 73526, equal 591110, worse 14863 +- total wall 1175.2 s + + Command being timed: "./target/release/examples/sharing_corpus $S/mathlib.ixe --layout tag4 --threads 8 --width-experiment --csv $S/wx_ml_tag4.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 19:36.32 + Maximum resident set size (kbytes): 4853268 + Exit status: 0 +exit=0 +``` + +
+ +
[X3] width experiment, Init, TagN layout, 1 thread (wx_init_tagN_t1.md) + +```text +# sharing_corpus width experiment (not the canonical construction) +- corpus: $S/init.ixe (56622 constants processed); layout TagN; phases 1-3 at w = 1, 2, 3 +- wall: processing 414.9 s with 1 threads; peak RSS 313624 KiB +- failures by width: w=1 0, w=2 0, w=3 0; constants with all three ok: 56622 +- layout bytes over those constants: K-based 67036818; best of three 66648677 (-388141); stored-count re-solve 66959837 (-76981) +- best-of-three width (ties to the lower w): w=1 45282, w=2 11156, w=3 184 +- best of three vs K-based per constant: better 20651, equal 35971; change min -2304 p1 -180 p10 -30 p50 -8 p90 -2 p99 -1 p99.9 -1 max -1 +- stored-count re-solve vs K-based per constant: better 7339, equal 48569, worse 714 +- total wall 419.1 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --layout tagN --threads 1 --width-experiment --csv $S/wx_init_tagN_t1.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 6:59.18 + Maximum resident set size (kbytes): 311764 + Exit status: 0 +exit=0 +``` + +
+ +
[X4] best of four, Init, TagN layout (wx4_init_tagN.md) + +```text +# sharing_corpus width experiment (not the canonical construction) +- corpus: $S/init.ixe (56622 constants processed); layout TagN; phases 1-3 at w = 1, 2, 3 +- wall: processing 44.2 s with 8 threads; peak RSS 455020 KiB +- failures by candidate: w=1 0, w=2 0, w=3 0, all 0; constants with all four ok: 56622 +- best of four (w = 1, 2, 3, all; ties to the earlier): 66648660 (-17 vs best of three); all candidates stored: 67487013 +- best-of-four winner: w=1 45275, w=2 11156, w=3 184, all 7; best of four vs best of three per constant: better 7, equal 56615 +- layout bytes over those constants: K-based 67036818; best of three 66648677 (-388141); stored-count re-solve 66959837 (-76981) +- best-of-three width (ties to the lower w): w=1 45282, w=2 11156, w=3 184 +- best of three vs K-based per constant: better 20651, equal 35971; change min -2304 p1 -180 p10 -30 p50 -8 p90 -2 p99 -1 p99.9 -1 max -1 +- stored-count re-solve vs K-based per constant: better 7339, equal 48569, worse 714 +- total wall 47.3 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --layout tagN --threads 8 --width-experiment --csv $S/wx4_init_tagN.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:47.33 + Maximum resident set size (kbytes): 451608 + Exit status: 0 +exit=0 +``` + +
+ +
[X4] best of four, Mathlib, TagN layout (wx4_ml_tagN.md) + +```text +# sharing_corpus width experiment (not the canonical construction) +- corpus: $S/mathlib.ixe (679499 constants processed); layout TagN; phases 1-3 at w = 1, 2, 3 +- wall: processing 1021.8 s with 12 threads; peak RSS 4873620 KiB +- failures by candidate: w=1 0, w=2 0, w=3 0, all 0; constants with all four ok: 679499 +- best of four (w = 1, 2, 3, all; ties to the earlier): 1121774136 (-2896 vs best of three); all candidates stored: 1129388537 +- best-of-four winner: w=1 520808, w=2 156147, w=3 1413, all 1131; best of four vs best of three per constant: better 1131, equal 678368 +- layout bytes over those constants: K-based 1136221078; best of three 1121777032 (-14444046); stored-count re-solve 1135433559 (-787519) +- best-of-three width (ties to the lower w): w=1 521916, w=2 156170, w=3 1413 +- best of three vs K-based per constant: better 297121, equal 382378; change min -11597 p1 -504 p10 -115 p50 -15 p90 -2 p99 -1 p99.9 -1 max -1 +- stored-count re-solve vs K-based per constant: better 64033, equal 600933, worse 14533 +- total wall 1203.0 s + + Command being timed: "$S/sharing_corpus_wx4 $S/mathlib.ixe --layout tagN --threads 12 --width-experiment --csv $S/wx4_ml_tagN.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 20:05.59 + Maximum resident set size (kbytes): 4873620 + Exit status: 0 +exit=0 +``` + +
+ +
[X4] best of four, Init, Tag4 layout (wx4_init_tag4.md) + +```text +# sharing_corpus width experiment (not the canonical construction) +- corpus: $S/init.ixe (56622 constants processed); layout Tag4; phases 1-3 at w = 1, 2, 3 +- wall: processing 57.7 s with 12 threads; peak RSS 540732 KiB +- failures by candidate: w=1 0, w=2 0, w=3 0, all 0; constants with all four ok: 56622 +- best of four (w = 1, 2, 3, all; ties to the earlier): 67302313 (-15 vs best of three); all candidates stored: 68443810 +- best-of-four winner: w=1 45135, w=2 10981, w=3 501, all 5; best of four vs best of three per constant: better 5, equal 56617 +- layout bytes over those constants: K-based 67747841; best of three 67302328 (-445513); stored-count re-solve 67639163 (-108678) +- best-of-three width (ties to the lower w): w=1 45140, w=2 10981, w=3 501 +- best of three vs K-based per constant: better 20985, equal 35637; change min -1893 p1 -312 p10 -33 p50 -9 p90 -2 p99 -1 p99.9 -1 max -1 +- stored-count re-solve vs K-based per constant: better 7902, equal 47974, worse 746 +- total wall 61.3 s + + Command being timed: "$S/sharing_corpus_wx4 $S/init.ixe --layout tag4 --threads 12 --width-experiment --csv $S/wx4_init_tag4.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:01.37 + Maximum resident set size (kbytes): 538600 + Exit status: 0 +exit=0 +``` + +
+ +
[X4] best of four, Mathlib, Tag4 layout (wx4_ml_tag4.md) + +```text +# sharing_corpus width experiment (not the canonical construction) +- corpus: $S/mathlib.ixe (679499 constants processed); layout Tag4; phases 1-3 at w = 1, 2, 3 +- wall: processing 1141.4 s with 12 threads; peak RSS 5024656 KiB +- failures by candidate: w=1 0, w=2 0, w=3 0, all 0; constants with all four ok: 679499 +- best of four (w = 1, 2, 3, all; ties to the earlier): 1135612767 (-2149 vs best of three); all candidates stored: 1146903694 +- best-of-four winner: w=1 517124, w=2 157688, w=3 3695, all 992; best of four vs best of three per constant: better 992, equal 678507 +- layout bytes over those constants: K-based 1151220860; best of three 1135614916 (-15605944); stored-count re-solve 1149312205 (-1908655) +- best-of-three width (ties to the lower w): w=1 518096, w=2 157708, w=3 3695 +- best of three vs K-based per constant: better 299934, equal 379565; change min -11153 p1 -530 p10 -128 p50 -15 p90 -2 p99 -1 p99.9 -1 max -1 +- stored-count re-solve vs K-based per constant: better 73526, equal 591110, worse 14863 +- total wall 1405.4 s + + Command being timed: "$S/sharing_corpus_wx4 $S/mathlib.ixe --layout tag4 --threads 12 --width-experiment --csv $S/wx4_ml_tag4.csv" + Elapsed (wall clock) time (h:mm:ss or m:ss): 23:26.59 + Maximum resident set size (kbytes): 5024656 + Exit status: 0 +exit=0 +``` + +
+ +
[R10] v4 Init corpus, TagN, 20 threads (init_rust.md) + +```text +# sharing_corpus report +- corpus: $S/init_v4r_six_rung.ixe (56622 constants; 56622 processed); layout TagN +- wall: index 863 ms, processing 32.6 s with 20 threads; peak RSS 756420 KiB +- certified: 56622 / 56622; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 78231552 B; serialized output 66644219 B (-14.81%); under TagN 66644219 B (-14.81%) +- unshared (where it fits u64, 56622 constants): 1070039966 B; stored 78231552 B; serialized output 66644219 B +- serialized output - stored per constant: 50400 smaller, 6174 equal, 48 larger; min -71858 p1 -2227 p10 -373 p50 -49 p90 0 p99 0 p99.9 0 max 7 +- TagN price - stored per constant: min -71858 p1 -2227 p10 -373 p50 -49 p90 0 p99 0 p99.9 0 max 7 +- phase-1 width w: {1: 45323, 2: 11115, 3: 184} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 2 p90 20 p99 90 p99.9 245 max 736 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 6 p99.9 13 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 8 p90 84 p99 396 p99.9 1030 max 10626 +- first-tier search states per constant: min 1 p1 1 p10 3 p50 17 p90 101 p99 623 p99.9 1951 max 12236 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 3 p50 33 p90 227 p99 1168 p99.9 4843 max 22458 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 1 p90 13 p99 105 p99.9 848 max 12597 +- slowest 10: + - 12597 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1 (ef115ac219120830): defn ok, N 26943, cand 19283, k 5136, w 2, uncertain 606, components 582 (largest 3), states uniform 2398 first-tier 8970 + - 11245 ms _private.Init.Data.Array.Extract.0.Array.extract_append._proof_1_1 (af5d4ef692ebbd14): defn ok, N 26754, cand 19091, k 5146, w 2, uncertain 646, components 612 (largest 4), states uniform 2553 first-tier 8926 + - 9829 ms _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (72c7500c0af02f24): defn ok, N 27628, cand 22458, k 4874, w 2, uncertain 736, components 665 (largest 4), states uniform 2843 first-tier 12236 + - 9112 ms _private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1 (30211bedcb9622e8): defn ok, N 26494, cand 19017, k 4919, w 3, uncertain 587, components 555 (largest 3), states uniform 2351 first-tier 8577 + - 8812 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append_extract._proof_1 (a22ec8b0918ea57c): defn ok, N 24658, cand 17290, k 4703, w 3, uncertain 557, components 517 (largest 4), states uniform 2193 first-tier 4104 + - 8329 ms _private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1 (be3b04c344146c3f): defn ok, N 24507, cand 17140, k 4678, w 3, uncertain 571, components 530 (largest 4), states uniform 2247 first-tier 4066 + - 4363 ms _private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition' (46c14ffcdae3b8d7): defn ok, N 16156, cand 11692, k 2712, w 1, uncertain 338, components 308 (largest 3), states uniform 1304 first-tier 2412 + - 3941 ms _private.Init.Data.Int.DivMod.Lemmas.0.Int.add_one_tdiv._proof_1_1 (a896f8dffb7117fc): defn ok, N 18802, cand 13281, k 3236, w 3, uncertain 424, components 406 (largest 4), states uniform 1696 first-tier 2748 + - 3902 ms _private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1 (0dc54307e038a95f): defn ok, N 19523, cand 11454, k 3640, w 3, uncertain 454, components 435 (largest 4), states uniform 1816 first-tier 3143 + - 3430 ms Std.Iter.step_flatMapAfterM (4baea8cab97cbac0): defn ok, N 10787, cand 8261, k 1858, w 1, uncertain 240, components 212 (largest 3), states uniform 917 first-tier 1654 +- total wall 39.8 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init_v4r_six_rung.ixe --threads 20 --csv $S/init_rust.csv --select-out $S/init_all.txt --select-stride 1" + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:39.93 + Maximum resident set size (kbytes): 754936 + Exit status: 0 +exit=0 +``` + +
+ +
[R10] v4 Mathlib corpus, TagN, 20 threads (ml_rust.md) + +```text +# sharing_corpus report +- corpus: $S/mathlib_v4r_six_rung.ixe (679499 constants; 679499 processed); layout TagN +- wall: index 7453 ms, processing 772.3 s with 20 threads; peak RSS 4696000 KiB +- certified: 679498 / 679499; failed: 1 +- failures by status: {"resource:States": 1} + - FAILED CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (ca5b91d86331eb4a): resource:States; N 95110, cand 81833, raw 607293 B, 2956 ms +- certified constants: stored (heuristic) 1422321971 B; serialized output 1121360414 B (-21.16%); under TagN 1121360414 B (-21.16%) +- unshared (where it fits u64, 679498 constants): 217330168440703 B; stored 1422321971 B; serialized output 1121360414 B +- serialized output - stored per constant: 627142 smaller, 51871 equal, 485 larger; min -188376 p1 -5562 p10 -901 p50 -118 p90 -2 p99 0 p99.9 0 max 28 +- TagN price - stored per constant: min -188376 p1 -5562 p10 -901 p50 -118 p90 -2 p99 0 p99.9 0 max 28 +- phase-1 width w: {1: 522899, 2: 155204, 3: 1395} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 2 p90 20 p99 86 p99.9 266 max 2611 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 6 p99.9 11 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 8 p90 80 p99 370 p99.9 1119 max 11095 +- first-tier search states per constant: min 1 p1 1 p10 5 p50 23 p90 136 p99 661 p99.9 2093 max 42793 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 6 p50 66 p90 424 p99 2004 p99.9 6370 max 81833 +- milliseconds per constant (certified): min 0 p1 0 p10 1 p50 4 p90 27 p99 226 p99.9 1659 max 137855 +- slowest 10: + - 137855 ms Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (08f54b4ec0521425): defn ok, N 78913, cand 59202, k 13054, w 1, uncertain 2611, components 2294 (largest 5), states uniform 11095 first-tier 42793 + - 121447 ms CategoryTheory.Bicategory.mateEquiv_vcomp (316210aec3b71877): defn ok, N 50497, cand 32338, k 8940, w 3, uncertain 1899, components 1431 (largest 14), states uniform 7942 first-tier 15083 + - 116752 ms WeierstrassCurve.variableChange_Δ (c4877eb9a43d6ed5): defn ok, N 63501, cand 18996, k 9234, w 3, uncertain 650, components 640 (largest 3), states uniform 2586 first-tier 25596 + - 83547 ms AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq (76d3f459d3934e38): defn ok, N 53511, cand 44632, k 12056, w 2, uncertain 1969, components 1752 (largest 5), states uniform 7601 first-tier 20448 + - 71564 ms Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux (cdf39344197c06e4): defn ok, N 64047, cand 41872, k 8745, w 1, uncertain 1864, components 1563 (largest 8), states uniform 7864 first-tier 7173 + - 69652 ms _private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three (1d6a83d1201da521): defn ok, N 50027, cand 26233, k 10413, w 3, uncertain 1615, components 1567 (largest 4), states uniform 6399 first-tier 8711 + - 61837 ms sum_eight_sq_mul_sum_eight_sq (b505feb329a45c2e): defn ok, N 49322, cand 10408, k 7281, w 2, uncertain 263, components 256 (largest 4), states uniform 1059 first-tier 7035 + - 56908 ms AlgebraicGeometry.exists_appTop_π_eq_of_isLimit (c62d6f62c3b83ae7): defn ok, N 43876, cand 33528, k 9848, w 2, uncertain 1374, components 1268 (largest 5), states uniform 5422 first-tier 8529 + - 55043 ms AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (f519c9c82c160c12): defn ok, N 66025, cand 52066, k 10555, w 3, uncertain 1708, components 1543 (largest 3), states uniform 6584 first-tier 8997 + - 52028 ms WeierstrassCurve.Projective.negDblY_eq' (ce121b7a563b352f): defn ok, N 45785, cand 14522, k 7073, w 3, uncertain 452, components 446 (largest 3), states uniform 1804 first-tier 13128 +- total wall 1011.2 s + + Command being timed: "./target/release/examples/sharing_corpus $S/mathlib_v4r_six_rung.ixe --threads 20 --csv $S/ml_rust.csv --select-out $S/ml_select.txt" + Elapsed (wall clock) time (h:mm:ss or m:ss): 16:52.30 + Maximum resident set size (kbytes): 4713784 + Exit status: 0 +exit=0 +``` + +
+ +
[X7] whole corpus (a), Mathlib, 20 threads (ml_a.md) + +```text +# sharing_corpus report +- corpus: $S/mathlib.ixe (679499 constants; 679499 processed); layout TagN +- wall: index 3995 ms, processing 658.8 s with 20 threads; peak RSS 5596088 KiB +- certified: 679499 / 679499; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 1468890902 B; output under Tag4 1136105745 B (-22.66%); under TagN 1121762443 B (-23.63%) +- unshared (where it fits u64, 679499 constants): 214351802561585 B; stored 1468890902 B; Tag4 output 1136105745 B +- Tag4 output - stored per constant: 627129 smaller, 51867 equal, 503 larger; min -262507 p1 -6326 p10 -1002 p50 -118 p90 -2 p99 0 p99.9 0 max 36 +- TagN price - stored per constant: min -270947 p1 -6916 p10 -1002 p50 -118 p90 -2 p99 0 p99.9 0 max 36 +- phase-1 width w: {1: 521918, 2: 156170, 3: 1411} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 2 p90 20 p99 104 p99.9 269 max 2741 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 13 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 8 p90 81 p99 452 p99.9 1153 max 18471 +- first-tier search states per constant: min 1 p1 1 p10 5 p50 23 p90 136 p99 656 p99.9 2132 max 42797 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 6 p50 66 p90 424 p99 2004 p99.9 6370 max 81833 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 3 p90 22 p99 187 p99.9 1369 max 208145 +- slowest 10: + - 208145 ms CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56): defn ok, N 95110, cand 81833, k 21461, w 2, uncertain 2741, components 2548 (largest 3), states uniform 11006 first-tier 18886 + - 121647 ms Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (2b0491741df2ce98): defn ok, N 78913, cand 59202, k 13054, w 1, uncertain 2610, components 2293 (largest 5), states uniform 11091 first-tier 42797 + - 88041 ms AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq (2d33bfe7c13b87fd): defn ok, N 53511, cand 44632, k 12056, w 2, uncertain 1969, components 1752 (largest 5), states uniform 7601 first-tier 20450 + - 87478 ms AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (4ece542b15e7b7a1): defn ok, N 66025, cand 52066, k 10555, w 3, uncertain 1707, components 1541 (largest 3), states uniform 6586 first-tier 8986 + - 73315 ms WeierstrassCurve.variableChange_Δ (0473473f736e639b): defn ok, N 63501, cand 18995, k 9233, w 3, uncertain 651, components 640 (largest 3), states uniform 2590 first-tier 25590 + - 69310 ms WeierstrassCurve.isHomogeneous_addSubMapCoeff (f2ce788af955876c): defn ok, N 60092, cand 31902, k 10150, w 2, uncertain 1945, components 1879 (largest 3), states uniform 7672 first-tier 16311 + - 67969 ms _private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three (67e377956e9a5e65): defn ok, N 50027, cand 26233, k 10413, w 2, uncertain 1431, components 1407 (largest 3), states uniform 5685 first-tier 9035 + - 63467 ms _private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1 (159e2b0d36d95a7f): defn ok, N 70414, cand 61641, k 11700, w 3, uncertain 1627, components 1537 (largest 4), states uniform 6464 first-tier 10045 + - 53247 ms Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux (83b417c6e46f08e2): defn ok, N 64047, cand 41872, k 8745, w 1, uncertain 1863, components 1562 (largest 8), states uniform 7860 first-tier 7174 + - 49810 ms _private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq' (3d79d639858e7cc1): defn ok, N 53222, cand 38483, k 7317, w 1, uncertain 1224, components 1037 (largest 3), states uniform 4856 first-tier 6300 +- total wall 807.1 s + + Command being timed: "$S/sharing_corpus_par $S/mathlib.ixe --threads 20 --csv $S/ml_a.csv --par-widths 1 --par-components 1 --par-materialize 1" + Elapsed (wall clock) time (h:mm:ss or m:ss): 13:29.27 + Maximum resident set size (kbytes): 5599052 + Exit status: 0 +exit=0 +``` + +
+ +
[X7] whole corpus (b), Mathlib, 20 threads (ml_b.md) + +```text +# sharing_corpus report +- corpus: $S/mathlib.ixe (679499 constants; 679499 processed); layout TagN +- wall: index 4732 ms, processing 697.3 s with 20 threads; peak RSS 5555120 KiB +- certified: 679499 / 679499; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 1468890902 B; output under Tag4 1136105745 B (-22.66%); under TagN 1121762443 B (-23.63%) +- unshared (where it fits u64, 679499 constants): 214351802561585 B; stored 1468890902 B; Tag4 output 1136105745 B +- Tag4 output - stored per constant: 627129 smaller, 51867 equal, 503 larger; min -262507 p1 -6326 p10 -1002 p50 -118 p90 -2 p99 0 p99.9 0 max 36 +- TagN price - stored per constant: min -270947 p1 -6916 p10 -1002 p50 -118 p90 -2 p99 0 p99.9 0 max 36 +- phase-1 width w: {1: 521918, 2: 156170, 3: 1411} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 2 p90 20 p99 104 p99.9 269 max 2741 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 13 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 8 p90 81 p99 452 p99.9 1153 max 18471 +- first-tier search states per constant: min 1 p1 1 p10 5 p50 23 p90 136 p99 656 p99.9 2132 max 42797 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 6 p50 66 p90 424 p99 2004 p99.9 6370 max 81833 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 3 p90 23 p99 199 p99.9 1467 max 196121 +- slowest 10: + - 196121 ms CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56): defn ok, N 95110, cand 81833, k 21461, w 2, uncertain 2741, components 2548 (largest 3), states uniform 11006 first-tier 18886 + - 168596 ms CategoryTheory.Bicategory.mateEquiv_vcomp (9b20bc429f4cd038): defn ok, N 50497, cand 32338, k 8940, w 3, uncertain 1899, components 1431 (largest 14), states uniform 7942 first-tier 15083 + - 155605 ms AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (4ece542b15e7b7a1): defn ok, N 66025, cand 52066, k 10555, w 3, uncertain 1707, components 1541 (largest 3), states uniform 6586 first-tier 8986 + - 105515 ms _private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1 (159e2b0d36d95a7f): defn ok, N 70414, cand 61641, k 11700, w 3, uncertain 1627, components 1537 (largest 4), states uniform 6464 first-tier 10045 + - 84138 ms Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux (83b417c6e46f08e2): defn ok, N 64047, cand 41872, k 8745, w 1, uncertain 1863, components 1562 (largest 8), states uniform 7860 first-tier 7174 + - 74225 ms Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (2b0491741df2ce98): defn ok, N 78913, cand 59202, k 13054, w 1, uncertain 2610, components 2293 (largest 5), states uniform 11091 first-tier 42797 + - 73547 ms AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq (2d33bfe7c13b87fd): defn ok, N 53511, cand 44632, k 12056, w 2, uncertain 1969, components 1752 (largest 5), states uniform 7601 first-tier 20450 + - 69439 ms WeierstrassCurve.variableChange_Δ (0473473f736e639b): defn ok, N 63501, cand 18995, k 9233, w 3, uncertain 651, components 640 (largest 3), states uniform 2590 first-tier 25590 + - 51712 ms _private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three (67e377956e9a5e65): defn ok, N 50027, cand 26233, k 10413, w 2, uncertain 1431, components 1407 (largest 3), states uniform 5685 first-tier 9035 + - 51256 ms _private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq' (3d79d639858e7cc1): defn ok, N 53222, cand 38483, k 7317, w 1, uncertain 1224, components 1037 (largest 3), states uniform 4856 first-tier 6300 +- total wall 956.0 s + + Command being timed: "$S/sharing_corpus_par $S/mathlib.ixe --threads 20 --csv $S/ml_b.csv --par-widths 3 --par-components 1 --par-materialize 1" + Elapsed (wall clock) time (h:mm:ss or m:ss): 56:53.50 + Maximum resident set size (kbytes): 5560880 + Exit status: 0 +exit=0 +``` + +
+ +
[X7] whole corpus (c), Mathlib, 20 threads (ml_c.md) + +```text +# sharing_corpus report +- corpus: $S/mathlib.ixe (679499 constants; 679499 processed); layout TagN +- wall: index 7560 ms, processing 691.2 s with 20 threads; peak RSS 5629852 KiB +- certified: 679499 / 679499; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 1468890902 B; output under Tag4 1136105745 B (-22.66%); under TagN 1121762443 B (-23.63%) +- unshared (where it fits u64, 679499 constants): 214351802561585 B; stored 1468890902 B; Tag4 output 1136105745 B +- Tag4 output - stored per constant: 627129 smaller, 51867 equal, 503 larger; min -262507 p1 -6326 p10 -1002 p50 -118 p90 -2 p99 0 p99.9 0 max 36 +- TagN price - stored per constant: min -270947 p1 -6916 p10 -1002 p50 -118 p90 -2 p99 0 p99.9 0 max 36 +- phase-1 width w: {1: 521918, 2: 156170, 3: 1411} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 2 p90 20 p99 104 p99.9 269 max 2741 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 13 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 8 p90 81 p99 452 p99.9 1153 max 18471 +- first-tier search states per constant: min 1 p1 1 p10 5 p50 23 p90 136 p99 656 p99.9 2132 max 42797 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 6 p50 66 p90 424 p99 2004 p99.9 6370 max 81833 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 3 p90 24 p99 203 p99.9 1492 max 648944 +- slowest 10: + - 648944 ms SimplexCategory.δ₀Iter_δ' (00fe7a1095b01adb): defn ok, N 865, cand 450, k 209, w 2, uncertain 85, components 45 (largest 10), states uniform 586 first-tier 292 + - 247995 ms CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56): defn ok, N 95110, cand 81833, k 21461, w 2, uncertain 2741, components 2548 (largest 3), states uniform 11006 first-tier 18886 + - 141875 ms CategoryTheory.Bicategory.mateEquiv_vcomp (9b20bc429f4cd038): defn ok, N 50497, cand 32338, k 8940, w 3, uncertain 1899, components 1431 (largest 14), states uniform 7942 first-tier 15083 + - 92227 ms _private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1 (159e2b0d36d95a7f): defn ok, N 70414, cand 61641, k 11700, w 3, uncertain 1627, components 1537 (largest 4), states uniform 6464 first-tier 10045 + - 88750 ms Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (2b0491741df2ce98): defn ok, N 78913, cand 59202, k 13054, w 1, uncertain 2610, components 2293 (largest 5), states uniform 11091 first-tier 42797 + - 76338 ms TensorProduct.gradedComm_gradedMul (f4093f3288e828f1): defn ok, N 12408, cand 9721, k 1837, w 1, uncertain 223, components 209 (largest 3), states uniform 878 first-tier 1677 + - 74880 ms WeierstrassCurve.variableChange_Δ (0473473f736e639b): defn ok, N 63501, cand 18995, k 9233, w 3, uncertain 651, components 640 (largest 3), states uniform 2590 first-tier 25590 + - 67660 ms Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux (83b417c6e46f08e2): defn ok, N 64047, cand 41872, k 8745, w 1, uncertain 1863, components 1562 (largest 8), states uniform 7860 first-tier 7174 + - 61954 ms AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (4ece542b15e7b7a1): defn ok, N 66025, cand 52066, k 10555, w 3, uncertain 1707, components 1541 (largest 3), states uniform 6586 first-tier 8986 + - 55227 ms _private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three (67e377956e9a5e65): defn ok, N 50027, cand 26233, k 10413, w 2, uncertain 1431, components 1407 (largest 3), states uniform 5685 first-tier 9035 +- total wall 897.3 s + + Command being timed: "$S/sharing_corpus_par $S/mathlib.ixe --threads 20 --csv $S/ml_c.csv --par-widths 3 --par-components 20 --par-materialize 20" + Elapsed (wall clock) time (h:mm:ss or m:ss): 14:58.19 + Maximum resident set size (kbytes): 5643528 + Exit status: 0 +exit=0 +``` + +
+ +
[X8] Init, parallel 3,20,20 against sequential (init_check_3_20_20.md) + +```text +# sharing_corpus report +- corpus: $S/init.ixe (56622 constants; 56622 processed); layout TagN +- wall: index 451 ms, processing 62.3 s with 20 threads; peak RSS 873372 KiB +- certified: 56622 / 56622; failed: 0 +- failures by status: {} +- sequential check (parallel Parallelism { widths: 3, components: 20, materialize: 20 } vs the sequential reference): {"same": 56622} +- certified constants: stored (heuristic) 80208288 B; output under Tag4 67329705 B (-16.06%); under TagN 66648677 B (-16.91%) +- unshared (where it fits u64, 56622 constants): 1070001199 B; stored 80208288 B; Tag4 output 67329705 B +- Tag4 output - stored per constant: 50406 smaller, 6169 equal, 47 larger; min -69549 p1 -3228 p10 -374 p50 -49 p90 0 p99 0 p99.9 0 max 7 +- TagN price - stored per constant: min -74928 p1 -3495 p10 -374 p50 -49 p90 0 p99 0 p99.9 0 max 7 +- phase-1 width w: {1: 45282, 2: 11156, 3: 184} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 2 p90 20 p99 113 p99.9 245 max 736 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 15 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 8 p90 84 p99 498 p99.9 1067 max 16293 +- first-tier search states per constant: min 1 p1 1 p10 3 p50 17 p90 101 p99 625 p99.9 1955 max 16280 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 3 p50 33 p90 227 p99 1168 p99.9 4843 max 22458 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 1 p90 13 p99 113 p99.9 923 max 48355 +- slowest 10: + - 48355 ms _private.Init.Data.Array.QSort.Basic.0.Array.qpartition.loop._unary.eq_def (033b6a88d11750dc): defn ok, N 7419, cand 6669, k 1367, w 1, uncertain 212, components 163 (largest 5), states uniform 910 first-tier 1184 + - 13006 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1 (d126ef57b21ab268): defn ok, N 26943, cand 19283, k 5136, w 2, uncertain 606, components 582 (largest 3), states uniform 2398 first-tier 8970 + - 12070 ms _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806a): defn ok, N 27628, cand 22458, k 4874, w 2, uncertain 736, components 666 (largest 4), states uniform 2845 first-tier 16280 + - 10445 ms Vector.zipWith_eq_append_iff (eda3bace2fc09771): defn ok, N 6096, cand 3273, k 1307, w 2, uncertain 315, components 271 (largest 5), states uniform 1269 first-tier 977 + - 9671 ms _private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514): defn ok, N 24507, cand 17140, k 4678, w 3, uncertain 571, components 530 (largest 4), states uniform 2247 first-tier 4066 + - 9197 ms _private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1 (89ed0e9889141575): defn ok, N 26494, cand 19017, k 4919, w 3, uncertain 587, components 555 (largest 3), states uniform 2351 first-tier 8577 + - 8528 ms Lean.Grind.Config.mk.injEq (79a818e3bc347ced): defn ok, N 3512, cand 551, k 360, w 1, uncertain 187, components 14 (largest 45), states uniform 16293 first-tier 290 + - 8248 ms _private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.getElem!_toArray_roc_eq_zero_iff._proof_1_2 (b6cb5981b8a92230): defn ok, N 2549, cand 1673, k 569, w 3, uncertain 93, components 83 (largest 4), states uniform 376 first-tier 445 + - 6058 ms _private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1 (b6be5c1a4db8c149): defn ok, N 19523, cand 11454, k 3640, w 3, uncertain 454, components 435 (largest 4), states uniform 1816 first-tier 3143 + - 4165 ms _private.Init.Data.Nat.ToString.0.Nat.digitChar_iff_aux (0691b3f1e8c36b6b): defn ok, N 17671, cand 5848, k 2763, w 1, uncertain 577, components 577 (largest 1), states uniform 2308 first-tier 4383 +- total wall 72.5 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --threads 20 --par-widths 3 --par-components 20 --par-materialize 20 --check-sequential" + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:12.66 + Maximum resident set size (kbytes): 873496 + Exit status: 0 +exit=0 +``` + +
+ +
[X8] Init, parallel 3,1,1 against sequential (init_check_3_1_1.md) + +```text +# sharing_corpus report +- corpus: $S/init.ixe (56622 constants; 56622 processed); layout TagN +- wall: index 319 ms, processing 57.6 s with 20 threads; peak RSS 865016 KiB +- certified: 56622 / 56622; failed: 0 +- failures by status: {} +- sequential check (parallel Parallelism { widths: 3, components: 1, materialize: 1 } vs the sequential reference): {"same": 56622} +- certified constants: stored (heuristic) 80208288 B; output under Tag4 67329705 B (-16.06%); under TagN 66648677 B (-16.91%) +- unshared (where it fits u64, 56622 constants): 1070001199 B; stored 80208288 B; Tag4 output 67329705 B +- Tag4 output - stored per constant: 50406 smaller, 6169 equal, 47 larger; min -69549 p1 -3228 p10 -374 p50 -49 p90 0 p99 0 p99.9 0 max 7 +- TagN price - stored per constant: min -74928 p1 -3495 p10 -374 p50 -49 p90 0 p99 0 p99.9 0 max 7 +- phase-1 width w: {1: 45282, 2: 11156, 3: 184} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 2 p90 20 p99 113 p99.9 245 max 736 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 15 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 8 p90 84 p99 498 p99.9 1067 max 16293 +- first-tier search states per constant: min 1 p1 1 p10 3 p50 17 p90 101 p99 625 p99.9 1955 max 16280 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 3 p50 33 p90 227 p99 1168 p99.9 4843 max 22458 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 1 p90 11 p99 100 p99.9 741 max 13222 +- slowest 10: + - 13222 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1 (d126ef57b21ab268): defn ok, N 26943, cand 19283, k 5136, w 2, uncertain 606, components 582 (largest 3), states uniform 2398 first-tier 8970 + - 10701 ms _private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1 (89ed0e9889141575): defn ok, N 26494, cand 19017, k 4919, w 3, uncertain 587, components 555 (largest 3), states uniform 2351 first-tier 8577 + - 10415 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append_extract._proof_1 (eed90987192d5160): defn ok, N 24658, cand 17290, k 4703, w 3, uncertain 557, components 517 (largest 4), states uniform 2193 first-tier 4104 + - 10066 ms _private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514): defn ok, N 24507, cand 17140, k 4678, w 3, uncertain 571, components 530 (largest 4), states uniform 2247 first-tier 4066 + - 9803 ms _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806a): defn ok, N 27628, cand 22458, k 4874, w 2, uncertain 736, components 666 (largest 4), states uniform 2845 first-tier 16280 + - 7875 ms _private.Init.Data.Array.Extract.0.Array.extract_append._proof_1_1 (e852d49c2b3a2ea7): defn ok, N 26754, cand 19091, k 5146, w 2, uncertain 646, components 612 (largest 4), states uniform 2553 first-tier 8926 + - 6495 ms Lean.Grind.Config.mk.injEq (79a818e3bc347ced): defn ok, N 3512, cand 551, k 360, w 1, uncertain 187, components 14 (largest 45), states uniform 16293 first-tier 290 + - 5007 ms _private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1 (b6be5c1a4db8c149): defn ok, N 19523, cand 11454, k 3640, w 3, uncertain 454, components 435 (largest 4), states uniform 1816 first-tier 3143 + - 4154 ms _private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition' (f22512c397919b72): defn ok, N 16156, cand 11692, k 2712, w 1, uncertain 338, components 308 (largest 3), states uniform 1304 first-tier 2412 + - 3486 ms _private.Init.Data.Int.DivMod.Lemmas.0.Int.add_one_tdiv._proof_1_1 (194bacb9fee23ecb): defn ok, N 18802, cand 13281, k 3236, w 3, uncertain 424, components 406 (largest 4), states uniform 1696 first-tier 2748 +- total wall 63.1 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --threads 20 --par-widths 3 --par-components 1 --par-materialize 1 --check-sequential" + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:03.33 + Maximum resident set size (kbytes): 864624 + Exit status: 0 +exit=0 +``` + +
+ +
[X8] Init, parallel 1,20,1 against sequential (init_check_1_20_1.md) + +```text +# sharing_corpus report +- corpus: $S/init.ixe (56622 constants; 56622 processed); layout TagN +- wall: index 391 ms, processing 59.7 s with 20 threads; peak RSS 852536 KiB +- certified: 56622 / 56622; failed: 0 +- failures by status: {} +- sequential check (parallel Parallelism { widths: 1, components: 20, materialize: 1 } vs the sequential reference): {"same": 56622} +- certified constants: stored (heuristic) 80208288 B; output under Tag4 67329705 B (-16.06%); under TagN 66648677 B (-16.91%) +- unshared (where it fits u64, 56622 constants): 1070001199 B; stored 80208288 B; Tag4 output 67329705 B +- Tag4 output - stored per constant: 50406 smaller, 6169 equal, 47 larger; min -69549 p1 -3228 p10 -374 p50 -49 p90 0 p99 0 p99.9 0 max 7 +- TagN price - stored per constant: min -74928 p1 -3495 p10 -374 p50 -49 p90 0 p99 0 p99.9 0 max 7 +- phase-1 width w: {1: 45282, 2: 11156, 3: 184} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 2 p90 20 p99 113 p99.9 245 max 736 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 15 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 8 p90 84 p99 498 p99.9 1067 max 16293 +- first-tier search states per constant: min 1 p1 1 p10 3 p50 17 p90 101 p99 625 p99.9 1955 max 16280 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 3 p50 33 p90 227 p99 1168 p99.9 4843 max 22458 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 1 p90 12 p99 107 p99.9 859 max 14577 +- slowest 10: + - 14577 ms _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806a): defn ok, N 27628, cand 22458, k 4874, w 2, uncertain 736, components 666 (largest 4), states uniform 2845 first-tier 16280 + - 13272 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1 (d126ef57b21ab268): defn ok, N 26943, cand 19283, k 5136, w 2, uncertain 606, components 582 (largest 3), states uniform 2398 first-tier 8970 + - 11247 ms _private.Init.Data.Array.Extract.0.Array.extract_append._proof_1_1 (e852d49c2b3a2ea7): defn ok, N 26754, cand 19091, k 5146, w 2, uncertain 646, components 612 (largest 4), states uniform 2553 first-tier 8926 + - 10292 ms _private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514): defn ok, N 24507, cand 17140, k 4678, w 3, uncertain 571, components 530 (largest 4), states uniform 2247 first-tier 4066 + - 8187 ms _private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1 (89ed0e9889141575): defn ok, N 26494, cand 19017, k 4919, w 3, uncertain 587, components 555 (largest 3), states uniform 2351 first-tier 8577 + - 7889 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append_extract._proof_1 (eed90987192d5160): defn ok, N 24658, cand 17290, k 4703, w 3, uncertain 557, components 517 (largest 4), states uniform 2193 first-tier 4104 + - 5822 ms Lean.Grind.Config.mk.injEq (79a818e3bc347ced): defn ok, N 3512, cand 551, k 360, w 1, uncertain 187, components 14 (largest 45), states uniform 16293 first-tier 290 + - 5428 ms _private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1 (b6be5c1a4db8c149): defn ok, N 19523, cand 11454, k 3640, w 3, uncertain 454, components 435 (largest 4), states uniform 1816 first-tier 3143 + - 4378 ms _private.Init.Data.Nat.ToString.0.Nat.digitChar_iff_aux (0691b3f1e8c36b6b): defn ok, N 17671, cand 5848, k 2763, w 1, uncertain 577, components 577 (largest 1), states uniform 2308 first-tier 4383 + - 4228 ms _private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxo.Iterator.instIteratorLoop.loopWf_eq._unary (d97528760a895bf6): defn ok, N 11860, cand 8596, k 2398, w 1, uncertain 471, components 447 (largest 3), states uniform 1852 first-tier 1955 +- total wall 62.8 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --threads 20 --par-widths 1 --par-components 20 --par-materialize 1 --check-sequential" + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:02.93 + Maximum resident set size (kbytes): 852852 + Exit status: 0 +exit=0 +``` + +
+ +
[X8] Init, parallel 1,1,20 against sequential (init_check_1_1_20.md) + +```text +# sharing_corpus report +- corpus: $S/init.ixe (56622 constants; 56622 processed); layout TagN +- wall: index 434 ms, processing 56.2 s with 20 threads; peak RSS 814096 KiB +- certified: 56622 / 56622; failed: 0 +- failures by status: {} +- sequential check (parallel Parallelism { widths: 1, components: 1, materialize: 20 } vs the sequential reference): {"same": 56622} +- certified constants: stored (heuristic) 80208288 B; output under Tag4 67329705 B (-16.06%); under TagN 66648677 B (-16.91%) +- unshared (where it fits u64, 56622 constants): 1070001199 B; stored 80208288 B; Tag4 output 67329705 B +- Tag4 output - stored per constant: 50406 smaller, 6169 equal, 47 larger; min -69549 p1 -3228 p10 -374 p50 -49 p90 0 p99 0 p99.9 0 max 7 +- TagN price - stored per constant: min -74928 p1 -3495 p10 -374 p50 -49 p90 0 p99 0 p99.9 0 max 7 +- phase-1 width w: {1: 45282, 2: 11156, 3: 184} +- uncertain terms per constant: min 0 p1 0 p10 0 p50 2 p90 20 p99 113 p99.9 245 max 736 +- largest component per constant: min 0 p1 0 p10 0 p50 1 p90 3 p99 7 p99.9 15 max 57 +- uniform search states per constant: min 0 p1 0 p10 0 p50 8 p90 84 p99 498 p99.9 1067 max 16293 +- first-tier search states per constant: min 1 p1 1 p10 3 p50 17 p90 101 p99 625 p99.9 1955 max 16280 +- R1/R2 candidates per constant (all): min 0 p1 0 p10 3 p50 33 p90 227 p99 1168 p99.9 4843 max 22458 +- milliseconds per constant (certified): min 0 p1 0 p10 0 p50 1 p90 11 p99 101 p99.9 827 max 18240 +- slowest 10: + - 18240 ms _private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1 (89ed0e9889141575): defn ok, N 26494, cand 19017, k 4919, w 3, uncertain 587, components 555 (largest 3), states uniform 2351 first-tier 8577 + - 12455 ms _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806a): defn ok, N 27628, cand 22458, k 4874, w 2, uncertain 736, components 666 (largest 4), states uniform 2845 first-tier 16280 + - 10792 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1 (d126ef57b21ab268): defn ok, N 26943, cand 19283, k 5136, w 2, uncertain 606, components 582 (largest 3), states uniform 2398 first-tier 8970 + - 9042 ms _private.Init.Data.Vector.Extract.0.Vector.extract_append_extract._proof_1 (eed90987192d5160): defn ok, N 24658, cand 17290, k 4703, w 3, uncertain 557, components 517 (largest 4), states uniform 2193 first-tier 4104 + - 7673 ms _private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514): defn ok, N 24507, cand 17140, k 4678, w 3, uncertain 571, components 530 (largest 4), states uniform 2247 first-tier 4066 + - 6328 ms Lean.Grind.Config.mk.injEq (79a818e3bc347ced): defn ok, N 3512, cand 551, k 360, w 1, uncertain 187, components 14 (largest 45), states uniform 16293 first-tier 290 + - 6275 ms _private.Init.Data.Array.Extract.0.Array.extract_append._proof_1_1 (e852d49c2b3a2ea7): defn ok, N 26754, cand 19091, k 5146, w 2, uncertain 646, components 612 (largest 4), states uniform 2553 first-tier 8926 + - 5601 ms _private.Init.Data.Int.DivMod.Lemmas.0.Int.add_one_tdiv._proof_1_1 (194bacb9fee23ecb): defn ok, N 18802, cand 13281, k 3236, w 3, uncertain 424, components 406 (largest 4), states uniform 1696 first-tier 2748 + - 4978 ms _private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1 (b6be5c1a4db8c149): defn ok, N 19523, cand 11454, k 3640, w 3, uncertain 454, components 435 (largest 4), states uniform 1816 first-tier 3143 + - 4449 ms _private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition' (f22512c397919b72): defn ok, N 16156, cand 11692, k 2712, w 1, uncertain 338, components 308 (largest 3), states uniform 1304 first-tier 2412 +- total wall 60.0 s + + Command being timed: "./target/release/examples/sharing_corpus $S/init.ixe --threads 20 --par-widths 1 --par-components 1 --par-materialize 20 --check-sequential" + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:00.13 + Maximum resident set size (kbytes): 813660 + Exit status: 0 +exit=0 +``` + +
+ +
[J1] join output (init_join.txt) + +```text +study rows 56622 +joined rooted 55386, rootless 1236 (changed by the construction: 0), not ok in either run 0, study rows missing from runner 0 +stored-bytes mismatches study vs runner: 0; unshared mismatches: 0; rooted rows with unvalidated unshared: 7 +totals over rooted: heuristic 80161846, MSS(Tag4) 68547873, MSS(TagN price) 67556587, canonical Tag4 67701399, canonical TagN 66990376, TagN construction in Tag4 bytes 67621877, unshared 1069954757 +canonical Tag4 vs MSS: smaller 23157 equal 22616 larger 9613; canonical TagN vs MSS(TagN): smaller 23132 equal 22616 larger 9638 +canonical Tag4 vs heuristic: smaller 49956 equal 4992 larger 438 +Tag4 construction vs TagN construction, both in Tag4 bytes: smaller 372 equal 54148 larger 866 +larger than unshared: canonical Tag4 0, canonical TagN 0, MSS 0 +canonical Tag4 - heuristic (n=55386): min -67656 p1 -3227 p10 -370 p50 -48 p90 -1 p99 0 p99.9 14 max 70 +canonical TagN - heuristic (n=55386): min -72624 p1 -3547 p10 -370 p50 -48 p90 -1 p99 0 p99.9 14 max 70 +canonical Tag4 - MSS (n=55386): min -6588 p1 -337 p10 -35 p50 0 p90 5 p99 58 p99.9 339 max 1521 +canonical TagN - MSS(TagN price) (n=55386): min -7794 p1 -138 p10 -35 p50 0 p90 5 p99 59 p99.9 387 max 1293 +Tag4 construction - TagN construction (Tag4 bytes) (n=55386): min -209 p1 0 p10 0 p50 0 p90 0 p99 33 p99.9 345 max 921 +``` + +
+ +
[J1] join output (init_byw.txt) + +```text +w=1 TagN run: 22270 constants, sum(canonical TagN - MSS TagN) -743, larger 0, smaller 700 | Tag4 run: 22270 constants, sum(canonical Tag4 - MSS) -743, larger 0, smaller 700 +w=2 TagN run: 33008 constants, sum(canonical TagN - MSS TagN) -464153, larger 9596, smaller 22366 | Tag4 run: 31764 constants, sum(canonical Tag4 - MSS) -367450, larger 9332, smaller 21386 +w=3 TagN run: 108 constants, sum(canonical TagN - MSS TagN) -101315, larger 42, smaller 66 | Tag4 run: 1352 constants, sum(canonical Tag4 - MSS) -478281, larger 281, smaller 1071 +``` + +
+ +
[J2] join output (ml_join.txt) + +```text +study rows 679499 +joined rooted 663254, rootless 16245 (changed by the construction: 0), not ok in either run 0, study rows missing from runner 0 +stored-bytes mismatches study vs runner: 0; unshared mismatches: 0; rooted rows with unvalidated unshared: 619 +totals over rooted: heuristic 1468281356, MSS(Tag4) 1148195956, MSS(TagN price) 1130381317, canonical Tag4 1150611314, canonical TagN 1135611532, TagN construction in Tag4 bytes 1148028605, unshared 214351801952039 +canonical Tag4 vs MSS: smaller 244165 equal 199801 larger 219288; canonical TagN vs MSS(TagN): smaller 242375 equal 199829 larger 221050 +canonical Tag4 vs heuristic: smaller 623329 equal 36203 larger 3722 +Tag4 construction vs TagN construction, both in Tag4 bytes: smaller 4258 equal 641798 larger 17198 +larger than unshared: canonical Tag4 0, canonical TagN 0, MSS 26 +canonical Tag4 - heuristic (n=663254): min -258748 p1 -6156 p10 -977 p50 -120 p90 -4 p99 0 p99.9 12 max 248 +canonical TagN - heuristic (n=663254): min -267397 p1 -6770 p10 -979 p50 -120 p90 -4 p99 0 p99.9 12 max 248 +canonical Tag4 - MSS (n=663254): min -22505 p1 -176 p10 -21 p50 0 p90 39 p99 261 p99.9 648 max 9103 +canonical TagN - MSS(TagN price) (n=663254): min -16508 p1 -98 p10 -20 p50 0 p90 40 p99 277 p99.9 752 max 10505 +Tag4 construction - TagN construction (Tag4 bytes) (n=663254): min -1055 p1 0 p10 0 p50 0 p90 0 p99 164 p99.9 497 max 2130 +``` + +
+ +
[J2] join output (ml_byw.txt) + +```text +w=1 TagN run: 181437 constants, sum(canonical TagN - MSS TagN) -2905, larger 0, smaller 2745 | Tag4 run: 181437 constants, sum(canonical Tag4 - MSS) -2905, larger 0, smaller 2745 +w=2 TagN run: 480001 constants, sum(canonical TagN - MSS TagN) +5841564, larger 220221, smaller 238645 | Tag4 run: 458516 constants, sum(canonical Tag4 - MSS) +3521148, larger 207107, smaller 230317 +w=3 TagN run: 1816 constants, sum(canonical TagN - MSS TagN) -608444, larger 829, smaller 985 | Tag4 run: 23301 constants, sum(canonical Tag4 - MSS) -1102885, larger 12181, smaller 11103 +``` + +
+ +
[X1] join output (wx_init_tagN_join.txt) + +```text +rooted constants compared 55386 (incomplete 0, missing from study 0) +totals: MSS(tagN widths) 67556587; K-based 66990376 (-566211 vs MSS); best of three 66602235 (-954352 vs MSS, -388141 vs K-based); re-solve 66913395 (-643192 vs MSS, -76981 vs K-based) +fixed widths: all w=1 66771574 (-785013 vs MSS); all w=2 67050223 (-506364); all w=3 67791486 (+234899) +best-of-three width wins (rooted): w=1 44046, w=2 11156, w=3 184 +vs MSS per constant: K-based smaller 23132 equal 22616 larger 9638; best of three smaller 32236 equal 23145 larger 5; re-solve smaller 27370 equal 23365 larger 4651 +best of three - MSS (n=55386): min -7794 p1 -150 p10 -41 p50 -3 p90 0 p99 0 p99.9 0 max 6 +K-based - MSS (n=55386): min -7794 p1 -138 p10 -35 p50 0 p90 5 p99 59 p99.9 387 max 1293 +re-solve - MSS (n=55386): min -7794 p1 -140 p10 -35 p50 0 p90 0 p99 57 p99.9 300 max 1272 + loss +6: "_private.Init.Data.Iterators.Combinators.Monadic.FilterMap.0.Std.Iterators.Types.FilterMap.instFinitenessRelation._proof_2" (K 241, K-based w 2, best w 1, stored at best 212, MSS 6035) + loss +4: "instLawfulMonadAttachStateTOfLawfulMonad" (K 178, K-based w 2, best w 1, stored at best 149, MSS 3843) + loss +3: "_private.Init.Data.Iterators.Combinators.Monadic.ULift.0.Std.Iterators.Types.ULiftIterator.instFinitenessRelation._proof_2" (K 246, K-based w 2, best w 1, stored at best 230, MSS 5529) + loss +1: "Std.IterM.length_uLift" (K 856, K-based w 2, best w 1, stored at best 737, MSS 14680) + loss +1: "Std.Iter.all_filterMap" (K 324, K-based w 2, best w 1, stored at best 299, MSS 7167) + loss +0: "UInt16.zero_lt_one" (K 6, K-based w 1, best w 1, stored at best 4, MSS 477) + loss +0: "EST.bind" (K 7, K-based w 1, best w 1, stored at best 4, MSS 267) + loss +0: "Std.Iterators.PostconditionT.ctorIdx" (K 2, K-based w 1, best w 1, stored at best 2, MSS 136) + loss +0: "Int32.toBitVec_div" (K 5, K-based w 1, best w 1, stored at best 5, MSS 496) + loss +0: "Vector.find?_mk" (K 7, K-based w 1, best w 1, stored at best 7, MSS 412) +``` + +
+ +
[X1] join output (wx_init_tagN_best.txt) + +```text +all constants 56622 (no best 0): best of three 66648677 vs stored 80208288 (-16.91%) +rootless 1236 (changed 0) +rooted 55386: heuristic 80161846, MSS(tagN widths) 67556587, best of three 66602235 (-16.92% vs heuristic, -954352 = -1.41% vs MSS), unshared 1069954757 +vs heuristic: smaller 50406 equal 4933 larger 47; vs MSS: smaller 32236 equal 23145 larger 5; larger than unshared 0 +best of three - heuristic (n=55386): min -74928 p1 -3566 p10 -383 p50 -51 p90 -1 p99 0 p99.9 0 max 7 +best of three - MSS (n=55386): min -7794 p1 -150 p10 -41 p50 -3 p90 0 p99 0 p99.9 0 max 6 +``` + +
+ +
[X1] join output (wx_ml_tagN_join.txt) + +```text +rooted constants compared 663254 (incomplete 0, missing from study 0) +totals: MSS(tagN widths) 1130381317; K-based 1135611532 (+5230215 vs MSS); best of three 1121167486 (-9213831 vs MSS, -14444046 vs K-based); re-solve 1134824013 (+4442696 vs MSS, -787519 vs K-based) +fixed widths: all w=1 1122848598 (-7532719 vs MSS); all w=2 1135414511 (+5033194); all w=3 1151346211 (+20964894) +best-of-three width wins (rooted): w=1 505671, w=2 156170, w=3 1413 +vs MSS per constant: K-based smaller 242375 equal 199829 larger 221050; best of three smaller 405832 equal 256519 larger 903; re-solve smaller 263473 equal 225637 larger 174144 +best of three - MSS (n=663254): min -16508 p1 -118 p10 -30 p50 -3 p90 0 p99 0 p99.9 1 max 1485 +K-based - MSS (n=663254): min -16508 p1 -98 p10 -20 p50 0 p90 40 p99 277 p99.9 752 max 10505 +re-solve - MSS (n=663254): min -16508 p1 -100 p10 -21 p50 0 p90 40 p99 272 p99.9 690 max 10505 + loss +1485: "Affine.Triangle.dist_orthogonalProjectionSpan_faceOpposite_eq_iff_two_zsmul_oangle_eq" (K 2230, K-based w 3, best w 2, stored at best 1895, MSS 63779) + loss +37: "equalizerCondition_yonedaPresheaf" (K 894, K-based w 2, best w 1, stored at best 769, MSS 14205) + loss +32: "SheafOfModules.Presentation.mk.injEq" (K 553, K-based w 2, best w 1, stored at best 505, MSS 9442) + loss +29: "SheafOfModules.relationsOfIsCokernelFree._proof_2" (K 822, K-based w 2, best w 1, stored at best 739, MSS 15365) + loss +26: "Algebra.Extension.CotangentSpace.map_comp" (K 1457, K-based w 3, best w 1, stored at best 1429, MSS 32918) + loss +25: "SheafOfModules.Presentation.mk.inj" (K 487, K-based w 2, best w 1, stored at best 448, MSS 8555) + loss +23: "SheafOfModules.Presentation.noConfusionType" (K 351, K-based w 2, best w 1, stored at best 326, MSS 7734) + loss +21: "AlgebraicGeometry.SheafedSpace.IsOpenImmersion.image_preimage_is_empty" (K 949, K-based w 2, best w 1, stored at best 882, MSS 17143) + loss +20: "CategoryTheory.MonoidalCategory.externalProductFlip._proof_8" (K 340, K-based w 2, best w 1, stored at best 303, MSS 5626) + loss +18: "Std.DTreeMap.Internal.Impl.link2.fun_cases" (K 241, K-based w 2, best w 1, stored at best 201, MSS 5711) +``` + +
+ +
[X1] join output (wx_ml_tagN_best.txt) + +```text +all constants 679499 (no best 0): best of three 1121777032 vs stored 1468890902 (-23.63%) +rootless 16245 (changed 0) +rooted 663254: heuristic 1468281356, MSS(tagN widths) 1130381317, best of three 1121167486 (-23.64% vs heuristic, -9213831 = -0.82% vs MSS), unshared 214351801952039 +vs heuristic: smaller 627129 equal 35622 larger 503; vs MSS: smaller 405832 equal 256519 larger 903; larger than unshared 0 +best of three - heuristic (n=663254): min -270911 p1 -7015 p10 -1031 p50 -125 p90 -4 p99 0 p99.9 0 max 36 +best of three - MSS (n=663254): min -16508 p1 -118 p10 -30 p50 -3 p90 0 p99 0 p99.9 1 max 1485 +``` + +
+ +
[X1] join output (wx_ml_tagN_slowest.txt) + +```text +163721 ms total | "CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite" | N 95110 | cand 81833 | K 21461 | K-based w 3 | best w 2 | stored w1/w2/w3 18653/18877/18440 | ms w1/w2/w3 74674/44791/44256 +84389 ms total | "WeierstrassCurve.variableChange_Δ" | N 63501 | cand 18995 | K 9233 | K-based w 3 | best w 3 | stored w1/w2/w3 8259/8564/8525 | ms w1/w2/w3 21488/27008/35893 +77150 ms total | "CategoryTheory.Bicategory.mateEquiv_vcomp" | N 50497 | cand 32338 | K 8940 | K-based w 3 | best w 2 | stored w1/w2/w3 6947/7533/7367 | ms w1/w2/w3 32773/23864/20512 +68373 ms total | "Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux" | N 64047 | cand 41872 | K 8745 | K-based w 3 | best w 1 | stored w1/w2/w3 7165/7335/7006 | ms w1/w2/w3 13860/22620/31893 +52355 ms total | "AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective" | N 66025 | cand 52066 | K 10555 | K-based w 3 | best w 3 | stored w1/w2/w3 8980/9284/8981 | ms w1/w2/w3 9839/22778/19738 +49194 ms total | "Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual" | N 78913 | cand 59202 | K 13054 | K-based w 3 | best w 1 | stored w1/w2/w3 10696/11065/10482 | ms w1/w2/w3 15014/17136/17043 +37653 ms total | "_private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three" | N 50027 | cand 26233 | K 10413 | K-based w 3 | best w 3 | stored w1/w2/w3 8545/8943/8673 | ms w1/w2/w3 10723/14022/12908 +37075 ms total | "_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1" | N 70414 | cand 61641 | K 11700 | K-based w 3 | best w 3 | stored w1/w2/w3 9464/10262/10024 | ms w1/w2/w3 11838/12668/12569 +37029 ms total | "WeierstrassCurve.isHomogeneous_addSubMapCoeff" | N 60092 | cand 31902 | K 10150 | K-based w 3 | best w 2 | stored w1/w2/w3 7846/8152/8031 | ms w1/w2/w3 6283/13954/16792 +33626 ms total | "WeierstrassCurve.Affine.addPolynomial_slope" | N 35899 | cand 20245 | K 5956 | K-based w 3 | best w 3 | stored w1/w2/w3 5150/5361/5253 | ms w1/w2/w3 8689/11987/12951 +``` + +
+ +
[X2] join output (wx_init_tag4_join.txt) + +```text +rooted constants compared 55386 (incomplete 0, missing from study 0) +totals: MSS(tag4 widths) 68547873; K-based 67701399 (-846474 vs MSS); best of three 67255886 (-1291987 vs MSS, -445513 vs K-based); re-solve 67592721 (-955152 vs MSS, -108678 vs K-based) +fixed widths: all w=1 67528222 (-1019651 vs MSS); all w=2 67694849 (-853024); all w=3 68358800 (-189073) +best-of-three width wins (rooted): w=1 43904, w=2 10981, w=3 501 +vs MSS per constant: K-based smaller 23157 equal 22616 larger 9613; best of three smaller 32239 equal 23144 larger 3; re-solve smaller 27474 equal 23365 larger 4547 +best of three - MSS (n=55386): min -6588 p1 -437 p10 -42 p50 -3 p90 0 p99 0 p99.9 0 max 6 +K-based - MSS (n=55386): min -6588 p1 -337 p10 -35 p50 0 p90 5 p99 58 p99.9 339 max 1521 +re-solve - MSS (n=55386): min -6588 p1 -360 p10 -36 p50 0 p90 0 p99 51 p99.9 313 max 1521 + loss +6: "_private.Init.Data.Iterators.Combinators.Monadic.FilterMap.0.Std.Iterators.Types.FilterMap.instFinitenessRelation._proof_2" (K 241, K-based w 2, best w 1, stored at best 212, MSS 6035) + loss +4: "instLawfulMonadAttachStateTOfLawfulMonad" (K 178, K-based w 2, best w 1, stored at best 149, MSS 3843) + loss +3: "_private.Init.Data.Iterators.Combinators.Monadic.ULift.0.Std.Iterators.Types.ULiftIterator.instFinitenessRelation._proof_2" (K 246, K-based w 2, best w 1, stored at best 230, MSS 5529) + loss +0: "UInt16.zero_lt_one" (K 6, K-based w 1, best w 1, stored at best 4, MSS 477) + loss +0: "EST.bind" (K 7, K-based w 1, best w 1, stored at best 4, MSS 267) + loss +0: "Std.Iterators.PostconditionT.ctorIdx" (K 2, K-based w 1, best w 1, stored at best 2, MSS 136) + loss +0: "Int32.toBitVec_div" (K 5, K-based w 1, best w 1, stored at best 5, MSS 496) + loss +0: "Vector.find?_mk" (K 7, K-based w 1, best w 1, stored at best 7, MSS 412) + loss +0: "Int16.toInt.eq_1" (K 3, K-based w 1, best w 1, stored at best 1, MSS 405) + loss +0: "UInt64.toBitVec_ofNatTruncate_of_le" (K 7, K-based w 1, best w 1, stored at best 4, MSS 672) +``` + +
+ +
[X2] join output (wx_init_tag4_best.txt) + +```text +all constants 56622 (no best 0): best of three 67302328 vs stored 80208288 (-16.09%) +rootless 1236 (changed 0) +rooted 55386: heuristic 80161846, MSS(tag4 widths) 68547873, best of three 67255886 (-16.10% vs heuristic, -1291987 = -1.88% vs MSS), unshared 1069954757 +vs heuristic: smaller 50406 equal 4933 larger 47; vs MSS: smaller 32239 equal 23144 larger 3; larger than unshared 0 +best of three - heuristic (n=55386): min -69549 p1 -3313 p10 -383 p50 -51 p90 -1 p99 0 p99.9 0 max 7 +best of three - MSS (n=55386): min -6588 p1 -437 p10 -42 p50 -3 p90 0 p99 0 p99.9 0 max 6 +``` + +
+ +
[X2] join output (wx_ml_tag4_join.txt) + +```text +rooted constants compared 663254 (incomplete 0, missing from study 0) +totals: MSS(tag4 widths) 1148195956; K-based 1150611314 (+2415358 vs MSS); best of three 1135005370 (-13190586 vs MSS, -15605944 vs K-based); re-solve 1148702659 (+506703 vs MSS, -1908655 vs K-based) +fixed widths: all w=1 1138024409 (-10171547 vs MSS); all w=2 1148160385 (-35571); all w=3 1161814219 (+13618263) +best-of-three width wins (rooted): w=1 501851, w=2 157708, w=3 3695 +vs MSS per constant: K-based smaller 244165 equal 199801 larger 219288; best of three smaller 405933 equal 256460 larger 861; re-solve smaller 267981 equal 225610 larger 169663 +best of three - MSS (n=663254): min -22505 p1 -361 p10 -31 p50 -3 p90 0 p99 0 p99.9 1 max 266 +K-based - MSS (n=663254): min -22505 p1 -176 p10 -21 p50 0 p90 39 p99 261 p99.9 648 max 9103 +re-solve - MSS (n=663254): min -22505 p1 -228 p10 -22 p50 0 p90 37 p99 228 p99.9 630 max 9103 + loss +266: "Algebra.Extension.Cotangent.map_toInfinitesimal_bijective" (K 730, K-based w 3, best w 1, stored at best 691, MSS 16350) + loss +156: "Module.isBaseChange_map_of_finite_free" (K 1186, K-based w 3, best w 1, stored at best 1148, MSS 31826) + loss +135: "VectorField.DifferentiableWithinAt.pullbackWithin" (K 801, K-based w 3, best w 1, stored at best 785, MSS 21101) + loss +129: "LinearEquiv.image_closure_of_convex'" (K 491, K-based w 3, best w 1, stored at best 463, MSS 12052) + loss +125: "IsBaseChange.end" (K 446, K-based w 3, best w 1, stored at best 432, MSS 12782) + loss +123: "_private.Mathlib.RingTheory.Kaehler.JacobiZariski.0.Algebra.Generators.H1Cotangent.auxMemKer" (K 583, K-based w 3, best w 1, stored at best 573, MSS 15469) + loss +113: "TensorProduct.adjoint_map" (K 463, K-based w 3, best w 1, stored at best 452, MSS 11188) + loss +109: "RingHom.Flat.tensorProductMap" (K 512, K-based w 3, best w 3, stored at best 338, MSS 12609) + loss +100: "LinearMap.tensorEqLocusEquiv._proof_3" (K 390, K-based w 3, best w 1, stored at best 385, MSS 11107) + loss +98: "instOrderIsoClassContinuousLinearMapIdOfNonUnitalAlgEquivClassOfStarHomClassOfContinuousMapClass" (K 520, K-based w 3, best w 1, stored at best 517, MSS 12475) +``` + +
+ +
[X2] join output (wx_ml_tag4_best.txt) + +```text +all constants 679499 (no best 0): best of three 1135614916 vs stored 1468890902 (-22.69%) +rootless 16245 (changed 0) +rooted 663254: heuristic 1468281356, MSS(tag4 widths) 1148195956, best of three 1135005370 (-22.70% vs heuristic, -13190586 = -1.15% vs MSS), unshared 214351801952039 +vs heuristic: smaller 627129 equal 35622 larger 503; vs MSS: smaller 405933 equal 256460 larger 861; larger than unshared 0 +best of three - heuristic (n=663254): min -262502 p1 -6433 p10 -1031 p50 -125 p90 -4 p99 0 p99.9 0 max 36 +best of three - MSS (n=663254): min -22505 p1 -361 p10 -31 p50 -3 p90 0 p99 0 p99.9 1 max 266 +``` + +
+ +
[X3] join output (wx_init_tagN_t1_slowest.txt) + +```text +8801 ms total | "_private.Init.Data.Vector.Extract.0.Vector.extract_append._proof_1" | N 26943 | cand 19283 | K 5136 | K-based w 3 | best w 2 | stored w1/w2/w3 4280/4474/4427 | ms w1/w2/w3 2847/2923/3031 +8644 ms total | "_private.Init.Data.Array.Extract.0.Array.extract_append._proof_1_1" | N 26754 | cand 19091 | K 5146 | K-based w 3 | best w 2 | stored w1/w2/w3 4247/4454/4403 | ms w1/w2/w3 2901/2828/2915 +8028 ms total | "_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList" | N 27628 | cand 22458 | K 4874 | K-based w 3 | best w 2 | stored w1/w2/w3 4076/4067/3785 | ms w1/w2/w3 2654/2806/2569 +6252 ms total | "_private.Init.Data.Array.Extract.0.Array.extract_append_extract._proof_1_1" | N 24507 | cand 17140 | K 4678 | K-based w 3 | best w 3 | stored w1/w2/w3 3939/4107/4059 | ms w1/w2/w3 1980/2267/2005 +5975 ms total | "Lean.Grind.Config.mk.injEq" | N 3512 | cand 551 | K 360 | K-based w 2 | best w 1 | stored w1/w2/w3 281/192/187 | ms w1/w2/w3 4450/873/652 +5167 ms total | "_private.Init.Data.Vector.Extract.0.Vector.extract_append_extract._proof_1" | N 24658 | cand 17290 | K 4703 | K-based w 3 | best w 3 | stored w1/w2/w3 3981/4143/4097 | ms w1/w2/w3 1616/1719/1831 +5165 ms total | "_private.Init.Data.Vector.Extract.0.Vector.extract_extract._proof_1" | N 26494 | cand 19017 | K 4919 | K-based w 3 | best w 3 | stored w1/w2/w3 4127/4303/4279 | ms w1/w2/w3 1375/1644/2146 +4215 ms total | "_private.Init.Data.Array.Extract.0.Array.extract_extract._proof_1_1" | N 19523 | cand 11454 | K 3640 | K-based w 3 | best w 3 | stored w1/w2/w3 3108/3135/3121 | ms w1/w2/w3 1420/1363/1432 +2631 ms total | "_private.Init.Data.Int.DivMod.Lemmas.0.Int.add_one_tdiv._proof_1_1" | N 18802 | cand 13281 | K 3236 | K-based w 3 | best w 3 | stored w1/w2/w3 2782/2793/2740 | ms w1/w2/w3 740/782/1109 +2469 ms total | "_private.Init.Data.Vector.Extract.0.Vector.extract_add_left._proof_1" | N 14521 | cand 8259 | K 2854 | K-based w 3 | best w 3 | stored w1/w2/w3 2412/2494/2464 | ms w1/w2/w3 830/823/816 +``` + +
+ +
[X3] join output (wx_init_tagN_t1_ms.txt) + +```text +best-of-three ms per constant (sum of 3 widths, n=56622): p50 1 p90 10 p99 77 p99.9 570 max 8801 +``` + +
+ +
[X4] join output (wx4_init_tagN_join.txt) + +```text +rooted constants compared 55386 (incomplete 0, missing from study 0) +totals: MSS(tagN widths) 67556587; K-based 66990376 (-566211 vs MSS); best of four 66602218 (-954369 vs MSS, -388158 vs K-based); re-solve 66913395 (-643192 vs MSS, -76981 vs K-based) +fixed widths: all w=1 66771574 (-785013 vs MSS); all w=2 67050223 (-506364); all w=3 67791486 (+234899) +best of four winner (rooted): w=1 44039, w=2 11156, w=3 184, all 7 +vs MSS per constant: K-based smaller 23132 equal 22616 larger 9638; best of four smaller 32237 equal 23149 larger 0; re-solve smaller 27370 equal 23365 larger 4651 +best of four - MSS (n=55386): min -7794 p1 -150 p10 -41 p50 -3 p90 0 p99 0 p99.9 0 max 0 +``` + +
+ +
[X4] join output (wx4_init_tagN_best.txt) + +```text +all constants 56622 (no best 0): best of four 66648660 vs stored 80208288 (-16.91%) +rootless 1236 (changed 0) +rooted 55386: heuristic 80161846, MSS(tagN widths) 67556587, best of four 66602218 (-16.92% vs heuristic, -954369 = -1.41% vs MSS), unshared 1069954757 +vs heuristic: smaller 50406 equal 4933 larger 47; vs MSS: smaller 32237 equal 23149 larger 0; larger than unshared 0 +best of four - heuristic (n=55386): min -74928 p1 -3566 p10 -383 p50 -51 p90 -1 p99 0 p99.9 0 max 7 +best of four - MSS (n=55386): min -7794 p1 -150 p10 -41 p50 -3 p90 0 p99 0 p99.9 0 max 0 +``` + +
+ +
[X4] join output (wx4_ml_tagN_join.txt) + +```text +rooted constants compared 663254 (incomplete 0, missing from study 0) +totals: MSS(tagN widths) 1130381317; K-based 1135611532 (+5230215 vs MSS); best of four 1121164590 (-9216727 vs MSS, -14446942 vs K-based); re-solve 1134824013 (+4442696 vs MSS, -787519 vs K-based) +fixed widths: all w=1 1122848598 (-7532719 vs MSS); all w=2 1135414511 (+5033194); all w=3 1151346211 (+20964894) +best of four winner (rooted): w=1 504563, w=2 156147, w=3 1413, all 1131 +vs MSS per constant: K-based smaller 242375 equal 199829 larger 221050; best of four smaller 405889 equal 257363 larger 2; re-solve smaller 263473 equal 225637 larger 174144 +best of four - MSS (n=663254): min -16508 p1 -118 p10 -30 p50 -3 p90 0 p99 0 p99.9 0 max 1485 +K-based - MSS (n=663254): min -16508 p1 -98 p10 -20 p50 0 p90 40 p99 277 p99.9 752 max 10505 +re-solve - MSS (n=663254): min -16508 p1 -100 p10 -21 p50 0 p90 40 p99 272 p99.9 690 max 10505 + loss +1485: "Affine.Triangle.dist_orthogonalProjectionSpan_faceOpposite_eq_iff_two_zsmul_oangle_eq" (K 2230, K-based w 3, best w 2, stored at best 1895, MSS 63779) + loss +26: "Algebra.Extension.CotangentSpace.map_comp" (K 1457, K-based w 3, best w 1, stored at best 1429, MSS 32918) + loss +0: "UInt16.zero_lt_one" (K 6, K-based w 1, best w 1, stored at best 4, MSS 477) + loss +0: "Std.DHashMap.Const.forInUncurried" (K 8, K-based w 1, best w 1, stored at best 8, MSS 416) + loss +0: "Plausible.Configuration.maxSize" (K 1, K-based w 1, best w 1, stored at best 0, MSS 83) + loss +0: "Std.ExtDHashMap.isSome_getKey?_iff_mem" (K 9, K-based w 2, best w 1, stored at best 9, MSS 648) + loss +0: "Lean.Meta.LazyDiscrTree.Key.arrow.sizeOf_spec" (K 2, K-based w 1, best w 1, stored at best 2, MSS 363) + loss +0: "Std.TreeSet.mem_of_mem_union_of_not_mem_left" (K 9, K-based w 2, best w 1, stored at best 9, MSS 502) + loss +0: "IsRelPrime.mul_dvd" (K 12, K-based w 2, best w 1, stored at best 12, MSS 646) + loss +0: "BialgHom.copy" (K 27, K-based w 2, best w 1, stored at best 27, MSS 1018) +``` + +
+ +
[X4] join output (wx4_ml_tagN_best.txt) + +```text +all constants 679499 (no best 0): best of four 1121774136 vs stored 1468890902 (-23.63%) +rootless 16245 (changed 0) +rooted 663254: heuristic 1468281356, MSS(tagN widths) 1130381317, best of four 1121164590 (-23.64% vs heuristic, -9216727 = -0.82% vs MSS), unshared 214351801952039 +vs heuristic: smaller 627129 equal 35622 larger 503; vs MSS: smaller 405889 equal 257363 larger 2; larger than unshared 0 +best of four - heuristic (n=663254): min -270911 p1 -7015 p10 -1031 p50 -125 p90 -4 p99 0 p99.9 0 max 36 +best of four - MSS (n=663254): min -16508 p1 -118 p10 -30 p50 -3 p90 0 p99 0 p99.9 0 max 1485 +``` + +
+ +
[X4] join output (wx4_init_tag4_join.txt) + +```text +rooted constants compared 55386 (incomplete 0, missing from study 0) +totals: MSS(tag4 widths) 68547873; K-based 67701399 (-846474 vs MSS); best of four 67255871 (-1292002 vs MSS, -445528 vs K-based); re-solve 67592721 (-955152 vs MSS, -108678 vs K-based) +fixed widths: all w=1 67528222 (-1019651 vs MSS); all w=2 67694849 (-853024); all w=3 68358800 (-189073) +best of four winner (rooted): w=1 43899, w=2 10981, w=3 501, all 5 +vs MSS per constant: K-based smaller 23157 equal 22616 larger 9613; best of four smaller 32240 equal 23146 larger 0; re-solve smaller 27474 equal 23365 larger 4547 +best of four - MSS (n=55386): min -6588 p1 -437 p10 -42 p50 -3 p90 0 p99 0 p99.9 0 max 0 +K-based - MSS (n=55386): min -6588 p1 -337 p10 -35 p50 0 p90 5 p99 58 p99.9 339 max 1521 +re-solve - MSS (n=55386): min -6588 p1 -360 p10 -36 p50 0 p90 0 p99 51 p99.9 313 max 1521 + loss +0: "UInt16.zero_lt_one" (K 6, K-based w 1, best w 1, stored at best 4, MSS 477) + loss +0: "EST.bind" (K 7, K-based w 1, best w 1, stored at best 4, MSS 267) + loss +0: "Std.Iterators.PostconditionT.ctorIdx" (K 2, K-based w 1, best w 1, stored at best 2, MSS 136) + loss +0: "Int32.toBitVec_div" (K 5, K-based w 1, best w 1, stored at best 5, MSS 496) + loss +0: "Vector.find?_mk" (K 7, K-based w 1, best w 1, stored at best 7, MSS 412) + loss +0: "Int16.toInt.eq_1" (K 3, K-based w 1, best w 1, stored at best 1, MSS 405) + loss +0: "UInt64.toBitVec_ofNatTruncate_of_le" (K 7, K-based w 1, best w 1, stored at best 4, MSS 672) + loss +0: "Int64.toInt64_toUInt64" (K 2, K-based w 1, best w 1, stored at best 2, MSS 196) + loss +0: "String.Legacy.Iterator.recOn" (K 3, K-based w 1, best w 1, stored at best 3, MSS 211) + loss +0: "USize.lt_asymm" (K 3, K-based w 1, best w 1, stored at best 2, MSS 274) +``` + +
+ +
[X4] join output (wx4_init_tag4_best.txt) + +```text +all constants 56622 (no best 0): best of four 67302313 vs stored 80208288 (-16.09%) +rootless 1236 (changed 0) +rooted 55386: heuristic 80161846, MSS(tag4 widths) 68547873, best of four 67255871 (-16.10% vs heuristic, -1292002 = -1.88% vs MSS), unshared 1069954757 +vs heuristic: smaller 50406 equal 4933 larger 47; vs MSS: smaller 32240 equal 23146 larger 0; larger than unshared 0 +best of four - heuristic (n=55386): min -69549 p1 -3313 p10 -383 p50 -51 p90 -1 p99 0 p99.9 0 max 7 +best of four - MSS (n=55386): min -6588 p1 -437 p10 -42 p50 -3 p90 0 p99 0 p99.9 0 max 0 +``` + +
+ +
[X4] join output (wx4_ml_tag4_join.txt) + +```text +rooted constants compared 663254 (incomplete 0, missing from study 0) +totals: MSS(tag4 widths) 1148195956; K-based 1150611314 (+2415358 vs MSS); best of four 1135003221 (-13192735 vs MSS, -15608093 vs K-based); re-solve 1148702659 (+506703 vs MSS, -1908655 vs K-based) +fixed widths: all w=1 1138024409 (-10171547 vs MSS); all w=2 1148160385 (-35571); all w=3 1161814219 (+13618263) +best of four winner (rooted): w=1 500879, w=2 157688, w=3 3695, all 992 +vs MSS per constant: K-based smaller 244165 equal 199801 larger 219288; best of four smaller 405989 equal 257170 larger 95; re-solve smaller 267981 equal 225610 larger 169663 +best of four - MSS (n=663254): min -22505 p1 -361 p10 -31 p50 -3 p90 0 p99 0 p99.9 0 max 266 +K-based - MSS (n=663254): min -22505 p1 -176 p10 -21 p50 0 p90 39 p99 261 p99.9 648 max 9103 +re-solve - MSS (n=663254): min -22505 p1 -228 p10 -22 p50 0 p90 37 p99 228 p99.9 630 max 9103 + loss +266: "Algebra.Extension.Cotangent.map_toInfinitesimal_bijective" (K 730, K-based w 3, best w 1, stored at best 691, MSS 16350) + loss +156: "Module.isBaseChange_map_of_finite_free" (K 1186, K-based w 3, best w 1, stored at best 1148, MSS 31826) + loss +135: "VectorField.DifferentiableWithinAt.pullbackWithin" (K 801, K-based w 3, best w 1, stored at best 785, MSS 21101) + loss +129: "LinearEquiv.image_closure_of_convex'" (K 491, K-based w 3, best w 1, stored at best 463, MSS 12052) + loss +125: "IsBaseChange.end" (K 446, K-based w 3, best w 1, stored at best 432, MSS 12782) + loss +123: "_private.Mathlib.RingTheory.Kaehler.JacobiZariski.0.Algebra.Generators.H1Cotangent.auxMemKer" (K 583, K-based w 3, best w 1, stored at best 573, MSS 15469) + loss +113: "TensorProduct.adjoint_map" (K 463, K-based w 3, best w 1, stored at best 452, MSS 11188) + loss +109: "RingHom.Flat.tensorProductMap" (K 512, K-based w 3, best w 3, stored at best 338, MSS 12609) + loss +100: "LinearMap.tensorEqLocusEquiv._proof_3" (K 390, K-based w 3, best w 1, stored at best 385, MSS 11107) + loss +98: "instOrderIsoClassContinuousLinearMapIdOfNonUnitalAlgEquivClassOfStarHomClassOfContinuousMapClass" (K 520, K-based w 3, best w 1, stored at best 517, MSS 12475) +``` + +
+ +
[X4] join output (wx4_ml_tag4_best.txt) + +```text +all constants 679499 (no best 0): best of four 1135612767 vs stored 1468890902 (-22.69%) +rootless 16245 (changed 0) +rooted 663254: heuristic 1468281356, MSS(tag4 widths) 1148195956, best of four 1135003221 (-22.70% vs heuristic, -13192735 = -1.15% vs MSS), unshared 214351801952039 +vs heuristic: smaller 627129 equal 35622 larger 503; vs MSS: smaller 405989 equal 257170 larger 95; larger than unshared 0 +best of four - heuristic (n=663254): min -262502 p1 -6433 p10 -1031 p50 -125 p90 -4 p99 0 p99.9 0 max 36 +best of four - MSS (n=663254): min -22505 p1 -361 p10 -31 p50 -3 p90 0 p99 0 p99.9 0 max 266 +``` + +
+ +
[X5] join output (cmp_id_report.md) + +```text +# MSS vs all candidates (TagN), 679499 constants (0 failed) +- TagN bytes: MSS 1130616480, all 1129388537 (-1227943) +- per constant: all larger 0, smaller 157438, equal 522061 +- Shares: MSS 159110515, all 145331762; share bytes MSS 280097495, all 251311059; stored-term occurrences written inline by all: 13778893 in 239559 constants +- total wall 490.4 s + Elapsed (wall clock) time (h:mm:ss or m:ss): 9:46.80 + Maximum resident set size (kbytes): 4930696 +exit=0 +``` + +
+ +
[X5] join output (cmp_blake3_report.md) + +```text +# MSS vs all candidates (TagN), 679499 constants (0 failed) +- TagN bytes: MSS 1130990863, all 1129388537 (-1602326) +- per constant: all larger 206, smaller 166865, equal 512428 +- Shares: MSS 159110515, all 145331762; share bytes MSS 280471878, all 251311059; stored-term occurrences written inline by all: 13778893 in 239559 constants +- total wall 374.6 s + Elapsed (wall clock) time (h:mm:ss or m:ss): 6:15.35 + Maximum resident set size (kbytes): 4948468 +exit=0 +``` + +
+ +
[X5] join output (outlier_diff2.md) + +```text +- MSS with StructuralId ties: TagN 67367 B, Tag4 72071 B +- MSS with Blake3 ties: TagN 63779 B, Tag4 72195 B +# Affine.Triangle.dist_orthogonalProjectionSpan_faceOpposite_eq_iff_two_zsmul_oangle_eq (048653e65a77d222) +- TagN bytes: MSS 67367, all 67367 (+0); table entries MSS 2230, all 2230; DAG nodes 19417 +- entry bodies MSS 28683, all 28683; roots MSS 32421, all 32421 +- Shares: MSS 18949 (TagN width 1/2/3/wider: [1101, 10111, 7737, 0]), all 16729 ([1101, 7891, 7737, 0]); stored-term occurrences written inline: MSS 0, all 2220 +- all: phase-1 order kept false, first tier [18, 19, 20, 89, 100, 203, 215, 279], w 0 +- entries with the same term-level form: 1456 of 2230; entries at a different index: 0 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 23: 108 (m9 a9 deg 108); 31: 104 (m10 a10 deg 104); 26: 94 (m11 a11 deg 94); 17: 83 (m13 a13 deg 83); 39: 82 (m14 a14 deg 82); 15: 79 (m15 a15 deg 79); 25: 75 (m16 a16 deg 75); 21: 72 (m17 a17 deg 72); 16: 62 (m18 a18 deg 62); 24: 60 (m19 a19 deg 60); 22: 57 (m23 a23 deg 57); 47: 55 (m24 a24 deg 55); 94: 47 (m26 a26 deg 47); 126: 42 (m27 a27 deg 42); 32: 38 (m28 a28 deg 38) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +0: term 12 m29 a29 refs 37/0 len 2/2 + - +0: term 13 m30 a30 refs 37/0 len 2/2 + - +0: term 14 m37 a37 refs 31/0 len 2/2 + - +0: term 15 m15 a15 refs 79/0 len 2/2 + - +0: term 16 m18 a18 refs 62/0 len 2/2 + - +0: term 17 m13 a13 refs 83/0 len 2/2 + - +0: term 18 m2 a2 refs 134/134 len 2/2 + - +0: term 19 m1 a1 refs 151/151 len 2/2 + - +0: term 20 m5 a5 refs 124/124 len 2/2 + - +0: term 21 m17 a17 refs 72/0 len 2/2 + - +0: term 22 m23 a23 refs 57/0 len 2/2 + - +0: term 23 m9 a9 refs 108/0 len 2/2 +- body length differences: total +0 / 0 +- Share bytes (refs x TagN width): MSS 44534, all 40094 +- first entry (MSS order) with a different term-level form: term 736, MSS index 70, all index 70, deg 17, refs 17/17 + - first difference at position 4: MSS Some((true, 17)), all Some((false, 17)) + - MSS bytes: 72b824b1b805 + - all bytes: 72b824b1180d + +``` + +
+ +
[X5] join output (diff_up7_blake3.md) + +```text +- MSS with StructuralId ties: TagN 67367 B, Tag4 72071 B +- MSS with Blake3 ties: TagN 63779 B, Tag4 72195 B +# Affine.Triangle.dist_orthogonalProjectionSpan_faceOpposite_eq_iff_two_zsmul_oangle_eq (048653e65a77d222) +- TagN bytes: MSS 63779, all 67367 (+3588); table entries MSS 2230, all 2230; DAG nodes 19417 +- entry bodies MSS 27958, all 28683; roots MSS 29558, all 32421 +- Shares: MSS 18949 (TagN width 1/2/3/wider: [1101, 13699, 4149, 0]), all 16729 ([1101, 7891, 7737, 0]); stored-term occurrences written inline: MSS 0, all 2220 +- all: phase-1 order kept false, first tier [18, 19, 20, 89, 100, 203, 215, 279], w 0 +- entries with the same term-level form: 1456 of 2230; entries at a different index: 2175 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 23: 108 (m9 a9 deg 108); 31: 104 (m10 a10 deg 104); 26: 94 (m11 a11 deg 94); 17: 83 (m13 a13 deg 83); 39: 82 (m14 a14 deg 82); 15: 79 (m15 a15 deg 79); 25: 75 (m16 a16 deg 75); 21: 72 (m17 a17 deg 72); 16: 62 (m18 a18 deg 62); 24: 60 (m20 a19 deg 60); 22: 57 (m23 a23 deg 57); 47: 55 (m24 a24 deg 55); 94: 47 (m26 a26 deg 47); 126: 42 (m27 a27 deg 42); 32: 38 (m28 a28 deg 38) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +153: term 19100 m2032 a2228 refs 2/2 len 1426/1579 + - +151: term 19094 m2034 a2227 refs 2/2 len 1455/1606 + - +150: term 19088 m2033 a2226 refs 2/2 len 1458/1608 + - +147: term 19039 m2029 a2224 refs 2/2 len 1519/1666 + - +33: term 14001 m2022 a2093 refs 22/22 len 268/301 + - +30: term 14002 m1966 a2095 refs 22/22 len 315/345 + - +21: term 13999 m2020 a2089 refs 22/22 len 312/333 + - +19: term 14000 m925 a2091 refs 22/22 len 262/281 + - +7: term 10191 m825 a1756 refs 22/22 len 39/46 + - +6: term 10187 m902 a2125 refs 22/22 len 24/30 + - +6: term 11061 m2023 a1776 refs 22/22 len 36/42 + - +6: term 11663 m1982 a2076 refs 22/22 len 47/53 +- body length differences: total +1397 / -672 +- Share bytes (refs x TagN width): MSS 40946, all 40094 +- first entry (MSS order) with a different term-level form: term 736, MSS index 70, all index 70, deg 17, refs 17/17 + - first difference at position 4: MSS Some((true, 17)), all Some((false, 17)) + - MSS bytes: 72b820b1b805 + - all bytes: 72b824b1180d + +- MSS with StructuralId ties: TagN 162916 B, Tag4 168886 B +- MSS with Blake3 ties: TagN 160431 B, Tag4 167951 B +# sum_eight_sq_mul_sum_eight_sq (0bd4b1175ac1d995) +- TagN bytes: MSS 160431, all 162472 (+2041); table entries MSS 7281, all 7281; DAG nodes 49322 +- entry bodies MSS 49920, all 50577; roots MSS 107233, all 108617 +- Shares: MSS 55565 (TagN width 1/2/3/wider: [2359, 23866, 29340, 0]), all 53293 ([3089, 18093, 32111, 0]); stored-term occurrences written inline: MSS 0, all 2272 +- all: phase-1 order kept false, first tier [10, 52, 142, 146, 300, 447, 468, 509], w 0 +- entries with the same term-level form: 7125 of 7281; entries at a different index: 7278 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 11: 295 (m1 a8 deg 295); 12: 295 (m6 a9 deg 295); 13: 295 (m5 a10 deg 295); 14: 295 (m3 a11 deg 295); 15: 295 (m2 a12 deg 295); 16: 295 (m4 a13 deg 295); 17: 294 (m7 a14 deg 294); 19: 125 (m8 a15 deg 125); 147: 38 (m10 a16 deg 38); 20: 21 (m15 a21 deg 21); 18: 10 (m16 a23 deg 10); 145: 6 (m23 a31 deg 6); 26: 3 (m26 a40 deg 3); 122: 3 (m25 a42 deg 3); 92: 2 (m44 a92 deg 2) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +5: term 21183 m3836 a3314 refs 13/13 len 34/39 + - +5: term 21184 m3435 a3140 refs 7/7 len 37/42 + - +4: term 21212 m3433 a3191 refs 13/13 len 36/40 + - +4: term 26293 m6322 a3981 refs 9/9 len 59/63 + - +4: term 26294 m6260 a3984 refs 9/9 len 59/63 + - +4: term 26295 m7232 a3987 refs 9/9 len 59/63 + - +4: term 26296 m6211 a3990 refs 9/9 len 59/63 + - +4: term 26297 m6288 a3993 refs 9/9 len 59/63 + - +4: term 26298 m6044 a3996 refs 9/9 len 59/63 + - +4: term 26299 m6033 a3999 refs 9/9 len 59/63 + - +3: term 655 m154 a1341 refs 6/6 len 9/12 + - +3: term 805 m191 a1925 refs 7/7 len 9/12 +- body length differences: total +2161 / -1504 +- Share bytes (refs x TagN width): MSS 138111, all 135608 +- first entry (MSS order) with a different term-level form: term 294, MSS index 17, all index 24, deg 28, refs 28/28 + - first difference at position 3: MSS Some((true, 19)), all Some((false, 19)) + - MSS bytes: 72211e03b800b808 + - all bytes: 72211e0318111810 + +- MSS with StructuralId ties: TagN 24055 B, Tag4 26675 B +- MSS with Blake3 ties: TagN 23547 B, Tag4 26729 B +# _private.Init.Data.List.ToArray.0.List.insertIdx_toArray._proof_1_8 (12f7c5d124fdd295) +- TagN bytes: MSS 23547, all 23791 (+244); table entries MSS 1486, all 1486; DAG nodes 6311 +- entry bodies MSS 15584, all 15819; roots MSS 4365, all 4374 +- Shares: MSS 7445 (TagN width 1/2/3/wider: [298, 5589, 1558, 0]), all 6881 ([562, 4253, 2066, 0]); stored-term occurrences written inline: MSS 0, all 564 +- all: phase-1 order kept false, first tier [12, 89, 99, 101, 186, 195, 215, 305], w 0 +- entries with the same term-level form: 1142 of 1486; entries at a different index: 1466 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 14: 31 (m4 a9 deg 31); 13: 30 (m5 a11 deg 30); 10: 28 (m6 a12 deg 28); 49: 25 (m7 a14 deg 25); 40: 24 (m8 a16 deg 24); 11: 22 (m9 a17 deg 22); 15: 17 (m18 a18 deg 17); 57: 16 (m23 a20 deg 16); 59: 16 (m22 a21 deg 16); 76: 16 (m20 a22 deg 16); 78: 16 (m21 a23 deg 16); 16: 14 (m25 a24 deg 14); 85: 14 (m24 a25 deg 14); 52: 13 (m26 a26 deg 13); 9: 11 (m31 a31 deg 11) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +31: term 5841 m1239 a1462 refs 2/2 len 186/217 + - +28: term 6036 m1412 a1438 refs 3/3 len 155/183 + - +28: term 6037 m1413 a1469 refs 2/2 len 155/183 + - +28: term 6073 m1472 a1482 refs 2/2 len 168/196 + - +23: term 6040 m1479 a1472 refs 2/2 len 163/186 + - +23: term 6061 m1475 a1475 refs 2/2 len 169/192 + - +22: term 5901 m1340 a1396 refs 3/3 len 157/179 + - +19: term 6135 m1476 a1483 refs 2/2 len 153/172 + - +18: term 5878 m1478 a1466 refs 2/2 len 138/156 + - +14: term 5873 m1329 a1464 refs 2/2 len 118/132 + - +13: term 6098 m1468 a1453 refs 4/4 len 156/169 + - +12: term 5870 m1303 a1417 refs 3/3 len 138/150 +- body length differences: total +762 / -527 +- Share bytes (refs x TagN width): MSS 16150, all 15266 +- first entry (MSS order) with a different term-level form: term 415, MSS index 15, all index 10, deg 34, refs 34/34 + - first difference at position 2: MSS Some((true, 14)), all Some((false, 14)) + - MSS bytes: 71b805b4 + - all bytes: 71b6180d + +- MSS with StructuralId ties: TagN 29926 B, Tag4 33101 B +- MSS with Blake3 ties: TagN 28862 B, Tag4 33682 B +# _private.Init.Data.Int.LemmasAux.0.Int.max_min_distrib_left._proof_1_1 (20646855d719ed79) +- TagN bytes: MSS 28862, all 29495 (+633); table entries MSS 1815, all 1815; DAG nodes 8427 +- entry bodies MSS 14988, all 15230; roots MSS 11207, all 11598 +- Shares: MSS 9731 (TagN width 1/2/3/wider: [433, 6942, 2356, 0]), all 9347 ([864, 5063, 3420, 0]); stored-term occurrences written inline: MSS 0, all 384 +- all: phase-1 order kept false, first tier [8, 9, 14, 62, 69, 70, 106, 118], w 0 +- entries with the same term-level form: 1538 of 1815; entries at a different index: 1789 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 29: 27 (m5 a8 deg 27); 59: 26 (m6 a9 deg 26); 42: 22 (m11 a11 deg 22); 11: 21 (m13 a13 deg 21); 39: 20 (m15 a14 deg 20); 78: 17 (m17 a16 deg 17); 54: 16 (m19 a18 deg 16); 55: 16 (m18 a19 deg 16); 20: 15 (m20 a20 deg 15); 53: 15 (m21 a21 deg 15); 27: 12 (m24 a24 deg 12); 18: 11 (m25 a25 deg 11); 37: 11 (m26 a26 deg 11); 84: 11 (m27 a27 deg 11); 31: 8 (m30 a28 deg 8) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +23: term 8190 m1799 a1764 refs 3/3 len 374/397 + - +23: term 8245 m1814 a1813 refs 2/2 len 377/400 + - +19: term 8119 m1771 a1809 refs 2/2 len 210/229 + - +19: term 8192 m1806 a1811 refs 2/2 len 378/397 + - +16: term 8123 m1801 a1810 refs 2/2 len 206/222 + - +6: term 8057 m1774 a1808 refs 2/2 len 79/85 + - +5: term 7236 m1600 a1790 refs 2/2 len 47/52 + - +4: term 7237 m1581 a1791 refs 2/2 len 48/52 + - +4: term 7474 m1717 a1792 refs 2/2 len 67/71 + - +4: term 7769 m1465 a1794 refs 2/2 len 75/79 + - +4: term 7874 m1716 a1805 refs 2/2 len 126/130 + - +3: term 7765 m1449 a1793 refs 2/2 len 76/79 +- body length differences: total +662 / -420 +- Share bytes (refs x TagN width): MSS 21385, all 21250 +- first entry (MSS order) with a different term-level form: term 104, MSS index 33, all index 33, deg 7, refs 7/7 + - first difference at position 1: MSS Some((true, 29)), all Some((false, 29)) + - MSS bytes: 71b5b0 + - all bytes: 712018b0 + +- MSS with StructuralId ties: TagN 37641 B, Tag4 39855 B +- MSS with Blake3 ties: TagN 37065 B, Tag4 39847 B +# _private.Mathlib.CategoryTheory.Sites.Hypercover.One.0.CategoryTheory.PreOneHypercover.sieve₁_inter.match_1_3 (b544e59047529675) +- TagN bytes: MSS 37065, all 37641 (+576); table entries MSS 2271, all 2271; DAG nodes 12584 +- entry bodies MSS 31380, all 31920; roots MSS 4384, all 4420 +- Shares: MSS 13361 (TagN width 1/2/3/wider: [1019, 8987, 3355, 0]), all 9693 ([1019, 4743, 3931, 0]); stored-term occurrences written inline: MSS 0, all 3668 +- all: phase-1 order kept false, first tier [25, 26, 27, 28, 29, 30, 33, 37], w 0 +- entries with the same term-level form: 1078 of 2271; entries at a different index: 2213 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 39: 122 (m6 a8 deg 122); 17: 121 (m11 a9 deg 121); 20: 121 (m12 a10 deg 121); 24: 121 (m10 a11 deg 121); 35: 121 (m9 a12 deg 121); 19: 120 (m16 a13 deg 120); 21: 120 (m15 a14 deg 120); 31: 120 (m14 a15 deg 120); 34: 120 (m13 a16 deg 120); 32: 119 (m18 a17 deg 119); 38: 119 (m17 a18 deg 119); 18: 117 (m21 a19 deg 117); 23: 117 (m19 a20 deg 117); 36: 117 (m20 a21 deg 117); 22: 116 (m22 a22 deg 116) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +12: term 11638 m2070 a2231 refs 2/2 len 273/285 + - +12: term 11800 m2221 a2249 refs 2/2 len 105/117 + - +11: term 11789 m2225 a2247 refs 2/2 len 204/215 + - +11: term 11826 m1941 a2260 refs 2/2 len 112/123 + - +10: term 11284 m2191 a2218 refs 2/2 len 73/83 + - +9: term 11785 m2193 a2245 refs 2/2 len 110/119 + - +8: term 11428 m1918 a2224 refs 2/2 len 98/106 + - +8: term 11787 m2077 a2246 refs 2/2 len 112/120 + - +7: term 10930 m1939 a2147 refs 2/2 len 76/83 + - +7: term 11737 m2237 a2237 refs 2/2 len 353/360 + - +7: term 11772 m2218 a2239 refs 2/2 len 108/115 + - +7: term 11774 m2149 a2185 refs 3/3 len 107/114 +- body length differences: total +919 / -379 +- Share bytes (refs x TagN width): MSS 29058, all 22298 +- first entry (MSS order) with a different term-level form: term 3480, MSS index 91, all index 111, deg 6, refs 6/6 + - first difference at position 7: MSS Some((true, 24)), all Some((false, 24)) + - MSS bytes: 74b824b2b4b802b80b + - all bytes: 74b824b2b318161815 + +- MSS with StructuralId ties: TagN 27698 B, Tag4 30928 B +- MSS with Blake3 ties: TagN 26940 B, Tag4 31434 B +# _private.Init.Data.Int.LemmasAux.0.Int.min_max_distrib_left._proof_1_1 (ba424920055f512c) +- TagN bytes: MSS 26940, all 27314 (+374); table entries MSS 1716, all 1716; DAG nodes 7820 +- entry bodies MSS 16436, all 16706; roots MSS 7837, all 7941 +- Shares: MSS 9026 (TagN width 1/2/3/wider: [425, 6476, 2125, 0]), all 8676 ([809, 4984, 2883, 0]); stored-term occurrences written inline: MSS 0, all 350 +- all: phase-1 order kept false, first tier [8, 9, 59, 62, 69, 70, 106, 118], w 0 +- entries with the same term-level form: 1462 of 1716; entries at a different index: 1690 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 29: 25 (m6 a10 deg 25); 11: 21 (m12 a12 deg 21); 42: 21 (m13 a13 deg 21); 39: 19 (m15 a15 deg 19); 78: 19 (m16 a16 deg 19); 54: 16 (m17 a17 deg 16); 20: 15 (m19 a18 deg 15); 53: 13 (m24 a21 deg 13); 55: 13 (m21 a22 deg 13); 27: 12 (m25 a25 deg 12); 18: 11 (m26 a26 deg 11); 37: 11 (m27 a27 deg 11); 84: 11 (m28 a28 deg 11); 31: 8 (m32 a31 deg 8); 32: 8 (m34 a32 deg 8) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +31: term 7645 m1628 a1714 refs 2/2 len 382/413 + - +30: term 7509 m1686 a1706 refs 2/2 len 271/301 + - +26: term 7510 m1546 a1707 refs 2/2 len 303/329 + - +25: term 7669 m1582 a1715 refs 2/2 len 313/338 + - +23: term 7511 m1592 a1708 refs 2/2 len 284/307 + - +23: term 7528 m1574 a1711 refs 2/2 len 280/303 + - +21: term 7612 m1575 a1712 refs 2/2 len 298/319 + - +21: term 7636 m1581 a1713 refs 2/2 len 317/338 + - +18: term 7512 m1580 a1709 refs 2/2 len 209/227 + - +17: term 7513 m1560 a1710 refs 2/2 len 210/227 + - +16: term 7447 m1590 a1702 refs 2/2 len 137/153 + - +15: term 7271 m1494 a1692 refs 2/2 len 105/120 +- body length differences: total +760 / -490 +- Share bytes (refs x TagN width): MSS 19752, all 19426 +- first entry (MSS order) with a different term-level form: term 104, MSS index 23, all index 23, deg 13, refs 13/13 + - first difference at position 1: MSS Some((true, 29)), all Some((false, 29)) + - MSS bytes: 71b6b0 + - all bytes: 712018b0 + +- MSS with StructuralId ties: TagN 27064 B, Tag4 30475 B +- MSS with Blake3 ties: TagN 26449 B, Tag4 30809 B +# _private.Init.Data.Int.LemmasAux.0.Int.min_max_distrib_right._proof_1_1 (bda7230c49640697) +- TagN bytes: MSS 26449, all 26954 (+505); table entries MSS 1687, all 1687; DAG nodes 7767 +- entry bodies MSS 16756, all 17087; roots MSS 7026, all 7200 +- Shares: MSS 8897 (TagN width 1/2/3/wider: [649, 6125, 2123, 0]), all 8540 ([759, 5043, 2738, 0]); stored-term occurrences written inline: MSS 0, all 357 +- all: phase-1 order kept false, first tier [8, 9, 29, 62, 69, 70, 106, 117], w 0 +- entries with the same term-level form: 1432 of 1687; entries at a different index: 1657 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 59: 26 (m5 a8 deg 26); 11: 21 (m12 a12 deg 21); 39: 20 (m14 a13 deg 20); 42: 20 (m15 a14 deg 20); 78: 19 (m16 a16 deg 19); 54: 16 (m18 a18 deg 16); 20: 15 (m19 a19 deg 15); 84: 15 (m20 a20 deg 15); 53: 14 (m21 a21 deg 14); 55: 13 (m22 a22 deg 13); 27: 12 (m25 a25 deg 12); 18: 8 (m29 a29 deg 8); 31: 8 (m31 a30 deg 8); 32: 8 (m34 a31 deg 8); 37: 8 (m32 a32 deg 8) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +35: term 7546 m1616 a1683 refs 2/2 len 292/327 + - +34: term 7440 m1611 a1675 refs 2/2 len 275/309 + - +32: term 7441 m1615 a1676 refs 2/2 len 300/332 + - +32: term 7459 m1620 a1681 refs 2/2 len 271/303 + - +29: term 7607 m1617 a1686 refs 2/2 len 298/327 + - +27: term 7377 m1296 a1671 refs 2/2 len 179/206 + - +24: term 7376 m1511 a1670 refs 2/2 len 182/206 + - +24: term 7386 m1681 a1672 refs 2/2 len 197/221 + - +21: term 7445 m1490 a1680 refs 2/2 len 205/226 + - +18: term 7476 m1685 a1682 refs 2/2 len 247/265 + - +12: term 7421 m1496 a1673 refs 2/2 len 163/175 + - +11: term 7134 m1393 a1657 refs 2/2 len 61/72 +- body length differences: total +807 / -476 +- Share bytes (refs x TagN width): MSS 19268, all 19059 +- first entry (MSS order) with a different term-level form: term 109, MSS index 33, all index 33, deg 9, refs 9/9 + - first difference at position 1: MSS Some((true, 37)), all Some((false, 37)) + - MSS bytes: 71b81817 + - all bytes: 71202017 + +``` + +
+ +
[X5] join output (diff_sample13_id.md) + +```text +- MSS with StructuralId ties: TagN 2819 B, Tag4 2819 B +- MSS with Blake3 ties: TagN 2819 B, Tag4 2819 B +# LinearMap.toMatrix₂ (150fea7b7bae8d61) +- TagN bytes: MSS 2819, all 2778 (-41); table entries MSS 75, all 75; DAG nodes 654 +- entry bodies MSS 724, all 702; roots MSS 632, all 613 +- Shares: MSS 492 (TagN width 1/2/3/wider: [198, 294, 0, 0]), all 403 ([239, 164, 0, 0]); stored-term occurrences written inline: MSS 0, all 89 +- all: phase-1 order kept false, first tier [14, 15, 20, 23, 26, 72, 217, 232], w 0 +- entries with the same term-level form: 48 of 75; entries at a different index: 9 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 21: 13 (m6 a8 deg 13); 16: 11 (m7 a9 deg 11); 17: 11 (m8 a10 deg 11); 19: 11 (m9 a11 deg 11); 22: 11 (m10 a12 deg 11); 18: 10 (m11 a13 deg 10); 24: 9 (m12 a14 deg 9); 25: 7 (m15 a15 deg 7); 27: 6 (m16 a16 deg 6) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +3: term 321 m42 a42 refs 4/4 len 16/19 + - +1: term 130 m28 a28 refs 2/2 len 5/6 + - +1: term 131 m29 a29 refs 2/2 len 5/6 + - +1: term 172 m18 a18 refs 4/4 len 5/6 + - +1: term 274 m54 a54 refs 2/2 len 10/11 + - +1: term 305 m60 a60 refs 2/2 len 11/12 + - +0: term 14 m2 a2 refs 21/21 len 2/2 + - +0: term 15 m3 a3 refs 21/21 len 2/2 + - +0: term 16 m7 a9 refs 11/0 len 2/2 + - +0: term 17 m8 a10 refs 11/0 len 2/2 + - +0: term 18 m11 a13 refs 10/0 len 2/2 + - +0: term 19 m9 a11 refs 11/0 len 2/2 +- body length differences: total +8 / -30 +- Share bytes (refs x TagN width): MSS 786, all 567 +- first entry (MSS order) with a different term-level form: term 172, MSS index 18, all index 18, deg 4, refs 4/4 + - first difference at position 1: MSS Some((true, 21)), all Some((false, 21)) + - MSS bytes: 9117b6b808 + - all bytes: 9117180f1815 + +- MSS with StructuralId ties: TagN 775 B, Tag4 775 B +- MSS with Blake3 ties: TagN 775 B, Tag4 775 B +# Pi.seminormedRing._proof_5 (3fdd3d0435a6cd0f) +- TagN bytes: MSS 775, all 766 (-9); table entries MSS 13, all 13; DAG nodes 89 +- entry bodies MSS 65, all 63; roots MSS 113, all 106 +- Shares: MSS 39 (TagN width 1/2/3/wider: [20, 19, 0, 0]), all 39 ([29, 10, 0, 0]); stored-term occurrences written inline: MSS 0, all 0 +- all: phase-1 order kept false, first tier [8, 10, 11, 12, 26, 27, 39, 40], w 0 +- entries with the same term-level form: 13 of 13; entries at a different index: 4 +- roots with the same term-level form: true +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +1: term 57 m11 a11 refs 2/2 len 8/9 + - +0: term 8 m0 a0 refs 3/3 len 2/2 + - +0: term 10 m3 a3 refs 2/2 len 3/3 + - +0: term 11 m4 a4 refs 2/2 len 4/4 + - +0: term 12 m5 a5 refs 2/2 len 3/3 + - +0: term 13 m6 a8 refs 2/2 len 3/3 + - +0: term 25 m7 a9 refs 2/2 len 3/3 + - +0: term 26 m1 a1 refs 3/3 len 3/3 + - +0: term 27 m8 a6 refs 2/2 len 3/3 + - +0: term 32 m10 a10 refs 2/2 len 4/4 + - +0: term 39 m2 a2 refs 4/4 len 4/4 + - -1: term 40 m9 a7 refs 11/11 len 5/4 +- body length differences: total +1 / -3 +- Share bytes (refs x TagN width): MSS 58, all 49 + +- MSS with StructuralId ties: TagN 5285 B, Tag4 5285 B +- MSS with Blake3 ties: TagN 5285 B, Tag4 5285 B +# _private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.sum_pow_add_indicator_eq_zero (41a2b46683027c60) +- TagN bytes: MSS 5285, all 5176 (-109); table entries MSS 181, all 181; DAG nodes 775 +- entry bodies MSS 1381, all 1299; roots MSS 566, all 539 +- Shares: MSS 645 (TagN width 1/2/3/wider: [73, 572, 0, 0]), all 608 ([182, 426, 0, 0]); stored-term occurrences written inline: MSS 0, all 37 +- all: phase-1 order kept false, first tier [24, 83, 103, 105, 155, 156, 157, 246], w 0 +- entries with the same term-level form: 163 of 181; entries at a different index: 40 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 42: 5 (m2 a8 deg 5); 109: 5 (m4 a9 deg 5); 8: 3 (m11 a17 deg 3); 20: 3 (m16 a22 deg 3); 27: 3 (m19 a25 deg 3); 71: 3 (m27 a33 deg 3); 90: 3 (m31 a37 deg 3); 93: 3 (m33 a39 deg 3); 108: 3 (m43 a43 deg 3); 6: 2 (m58 a58 deg 2); 14: 2 (m59 a59 deg 2); 29: 2 (m63 a63 deg 2) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +3: term 335 m8 a13 refs 8/8 len 8/11 + - +1: term 269 m51 a51 refs 3/3 len 5/6 + - +1: term 361 m10 a15 refs 5/5 len 11/12 + - +1: term 561 m157 a157 refs 2/2 len 14/15 + - +1: term 619 m168 a168 refs 2/2 len 18/19 + - +1: term 688 m174 a174 refs 2/2 len 18/19 + - +0: term 6 m58 a58 refs 2/0 len 2/2 + - +0: term 8 m11 a17 refs 3/0 len 2/2 + - +0: term 9 m5 a10 refs 4/4 len 3/3 + - +0: term 11 m12 a18 refs 3/3 len 3/3 + - +0: term 12 m13 a19 refs 3/3 len 3/3 + - +0: term 13 m14 a20 refs 3/3 len 3/3 +- body length differences: total +8 / -90 +- Share bytes (refs x TagN width): MSS 1217, all 1034 +- first entry (MSS order) with a different term-level form: term 335, MSS index 8, all index 13, deg 8, refs 8/8 + - first difference at position 5: MSS Some((true, 109)), all Some((false, 109)) + - MSS bytes: 73b7b0b4712054b4 + - all bytes: 73b804b0681d712054681d + +- MSS with StructuralId ties: TagN 1443 B, Tag4 1443 B +- MSS with Blake3 ties: TagN 1443 B, Tag4 1443 B +# TensorProduct.comm_comp_comm (47a67d941d274480) +- TagN bytes: MSS 1443, all 1424 (-19); table entries MSS 28, all 28; DAG nodes 309 +- entry bodies MSS 327, all 325; roots MSS 226, all 209 +- Shares: MSS 146 (TagN width 1/2/3/wider: [74, 72, 0, 0]), all 146 ([93, 53, 0, 0]); stored-term occurrences written inline: MSS 0, all 0 +- all: phase-1 order kept false, first tier [31, 89, 94, 113, 164, 169, 171, 201], w 0 +- entries with the same term-level form: 28 of 28; entries at a different index: 9 +- roots with the same term-level form: true +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +6: term 261 m25 a25 refs 2/2 len 54/60 + - +0: term 26 m14 a14 refs 2/2 len 4/4 + - +0: term 31 m6 a3 refs 3/3 len 3/3 + - +0: term 65 m15 a15 refs 2/2 len 5/5 + - +0: term 66 m16 a16 refs 2/2 len 5/5 + - +0: term 69 m17 a17 refs 2/2 len 5/5 + - +0: term 89 m7 a4 refs 18/18 len 4/4 + - +0: term 94 m9 a6 refs 10/10 len 6/6 + - +0: term 113 m8 a5 refs 15/15 len 11/11 + - +0: term 114 m18 a18 refs 2/2 len 12/12 + - +0: term 115 m19 a19 refs 2/2 len 12/12 + - +0: term 164 m2 a2 refs 13/13 len 15/15 +- body length differences: total +6 / -8 +- Share bytes (refs x TagN width): MSS 218, all 199 + +- MSS with StructuralId ties: TagN 1498 B, Tag4 1498 B +- MSS with Blake3 ties: TagN 1498 B, Tag4 1498 B +# PartialEquiv.prod_symm (47be2a47baaa41c6) +- TagN bytes: MSS 1498, all 1483 (-15); table entries MSS 43, all 43; DAG nodes 308 +- entry bodies MSS 372, all 359; roots MSS 256, all 254 +- Shares: MSS 118 (TagN width 1/2/3/wider: [22, 96, 0, 0]), all 118 ([37, 81, 0, 0]); stored-term occurrences written inline: MSS 0, all 0 +- all: phase-1 order kept false, first tier [12, 54, 55, 56, 134, 135, 136, 137], w 0 +- entries with the same term-level form: 43 of 43; entries at a different index: 11 +- roots with the same term-level form: true +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +1: term 220 m18 a18 refs 3/3 len 18/19 + - +1: term 221 m30 a30 refs 3/3 len 10/11 + - +0: term 12 m1 a1 refs 3/3 len 2/2 + - +0: term 28 m4 a10 refs 2/2 len 6/6 + - +0: term 29 m5 a11 refs 2/2 len 6/6 + - +0: term 40 m6 a12 refs 2/2 len 4/4 + - +0: term 54 m0 a0 refs 5/5 len 2/2 + - +0: term 55 m7 a2 refs 2/2 len 4/4 + - +0: term 56 m10 a5 refs 2/2 len 4/4 + - +0: term 63 m13 a13 refs 2/2 len 4/4 + - +0: term 65 m16 a16 refs 2/2 len 4/4 + - +0: term 66 m17 a17 refs 2/2 len 4/4 +- body length differences: total +2 / -15 +- Share bytes (refs x TagN width): MSS 214, all 199 + +- MSS with StructuralId ties: TagN 594 B, Tag4 594 B +- MSS with Blake3 ties: TagN 588 B, Tag4 588 B +# Complex.exists (47c8de36ea6414a9) +- TagN bytes: MSS 594, all 585 (-9); table entries MSS 21, all 21; DAG nodes 114 +- entry bodies MSS 94, all 92; roots MSS 171, all 164 +- Shares: MSS 77 (TagN width 1/2/3/wider: [41, 36, 0, 0]), all 75 ([50, 25, 0, 0]); stored-term occurrences written inline: MSS 0, all 2 +- all: phase-1 order kept false, first tier [10, 14, 16, 17, 33, 34, 37, 52], w 0 +- entries with the same term-level form: 21 of 21; entries at a different index: 8 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 9: 2 (m4 a9 deg 2) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +1: term 27 m13 a13 refs 2/2 len 3/4 + - +1: term 32 m14 a14 refs 2/2 len 3/4 + - +0: term 9 m4 a9 refs 2/0 len 2/2 + - +0: term 10 m1 a1 refs 10/10 len 2/2 + - +0: term 13 m5 a10 refs 2/2 len 3/3 + - +0: term 14 m2 a2 refs 4/4 len 2/2 + - +0: term 15 m6 a11 refs 2/2 len 3/3 + - +0: term 16 m7 a4 refs 2/2 len 3/3 + - +0: term 17 m0 a0 refs 15/15 len 2/2 + - +0: term 19 m12 a12 refs 2/2 len 3/3 + - +0: term 33 m9 a6 refs 4/4 len 3/3 + - +0: term 34 m8 a5 refs 8/8 len 3/3 +- body length differences: total +2 / -4 +- Share bytes (refs x TagN width): MSS 113, all 100 + +- MSS with StructuralId ties: TagN 2776 B, Tag4 2776 B +- MSS with Blake3 ties: TagN 2776 B, Tag4 2776 B +# Std.Packages.PreorderOfLEArgs.decidableLT._autoParam (4a870ecdd4f7740a) +- TagN bytes: MSS 2776, all 2713 (-63); table entries MSS 34, all 34; DAG nodes 334 +- entry bodies MSS 444, all 412; roots MSS 309, all 278 +- Shares: MSS 243 (TagN width 1/2/3/wider: [69, 174, 0, 0]), all 229 ([132, 97, 0, 0]); stored-term occurrences written inline: MSS 0, all 14 +- all: phase-1 order kept false, first tier [0, 1, 8, 9, 84, 85, 89, 95], w 0 +- entries with the same term-level form: 30 of 34; entries at a different index: 21 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 11: 4 (m2 a12 deg 4); 5: 2 (m7 a17 deg 2); 19: 2 (m13 a18 deg 2); 26: 2 (m14 a19 deg 2); 51: 2 (m15 a20 deg 2); 54: 2 (m16 a21 deg 2) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +1: term 96 m23 a23 refs 2/2 len 6/7 + - +1: term 97 m28 a28 refs 2/2 len 5/6 + - +0: term 0 m0 a0 refs 16/16 len 2/2 + - +0: term 1 m1 a1 refs 5/5 len 2/2 + - +0: term 5 m7 a17 refs 2/0 len 2/2 + - +0: term 8 m8 a4 refs 2/2 len 2/2 + - +0: term 9 m4 a2 refs 3/3 len 2/2 + - +0: term 11 m2 a12 refs 4/0 len 2/2 + - +0: term 19 m13 a18 refs 2/0 len 2/2 + - +0: term 26 m14 a19 refs 2/0 len 2/2 + - +0: term 51 m15 a20 refs 2/0 len 2/2 + - +0: term 54 m16 a21 refs 2/0 len 2/2 +- body length differences: total +2 / -34 +- Share bytes (refs x TagN width): MSS 417, all 326 +- first entry (MSS order) with a different term-level form: term 96, MSS index 23, all index 23, deg 2, refs 2/2 + - first difference at position 2: MSS Some((true, 5)), all Some((false, 5)) + - MSS bytes: 72b7582a583d + - all bytes: 72200e582a583d + +- MSS with StructuralId ties: TagN 2895 B, Tag4 2895 B +- MSS with Blake3 ties: TagN 2895 B, Tag4 2895 B +# CategoryTheory.Limits.biprod.braiding._proof_2 (6a9812db4d4daf40) +- TagN bytes: MSS 2895, all 2851 (-44); table entries MSS 151, all 151; DAG nodes 676 +- entry bodies MSS 1049, all 997; roots MSS 614, all 622 +- Shares: MSS 562 (TagN width 1/2/3/wider: [41, 521, 0, 0]), all 554 ([85, 469, 0, 0]); stored-term occurrences written inline: MSS 0, all 8 +- all: phase-1 order kept false, first tier [114, 117, 121, 143, 186, 214, 216, 218], w 0 +- entries with the same term-level form: 151 of 151; entries at a different index: 77 +- roots with the same term-level form: false +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 40: 4 (m3 a17 deg 4); 44: 4 (m5 a19 deg 4) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +1: term 189 m27 a53 refs 3/3 len 4/5 + - +1: term 190 m28 a54 refs 3/3 len 4/5 + - +1: term 191 m29 a55 refs 3/3 len 4/5 + - +1: term 192 m30 a56 refs 3/3 len 4/5 + - +1: term 199 m31 a57 refs 3/3 len 4/5 + - +1: term 200 m32 a58 refs 3/3 len 4/5 + - +1: term 201 m33 a59 refs 3/3 len 4/5 + - +1: term 202 m34 a60 refs 3/3 len 4/5 + - +1: term 301 m104 a104 refs 2/2 len 4/5 + - +1: term 302 m105 a105 refs 2/2 len 4/5 + - +1: term 305 m106 a106 refs 2/2 len 4/5 + - +1: term 306 m107 a107 refs 2/2 len 4/5 +- body length differences: total +12 / -64 +- Share bytes (refs x TagN width): MSS 1083, all 1023 + +- MSS with StructuralId ties: TagN 2031 B, Tag4 2031 B +- MSS with Blake3 ties: TagN 2031 B, Tag4 2031 B +# Monoid.Coprod.map._proof_1 (75bca4f10bbf0073) +- TagN bytes: MSS 2031, all 2009 (-22); table entries MSS 63, all 63; DAG nodes 404 +- entry bodies MSS 605, all 591; roots MSS 277, all 269 +- Shares: MSS 229 (TagN width 1/2/3/wider: [53, 176, 0, 0]), all 226 ([75, 151, 0, 0]); stored-term occurrences written inline: MSS 0, all 3 +- all: phase-1 order kept false, first tier [13, 14, 25, 40, 159, 164, 209, 257], w 0 +- entries with the same term-level form: 60 of 63; entries at a different index: 10 +- roots with the same term-level form: true +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 86: 3 (m6 a10 deg 3) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +2: term 355 m59 a59 refs 2/2 len 35/37 + - +1: term 204 m40 a40 refs 2/2 len 14/15 + - +1: term 205 m21 a21 refs 3/3 len 8/9 + - +1: term 235 m45 a45 refs 2/2 len 13/14 + - +1: term 236 m46 a46 refs 2/2 len 13/14 + - +0: term 13 m1 a1 refs 11/11 len 2/2 + - +0: term 14 m0 a0 refs 14/14 len 2/2 + - +0: term 18 m7 a12 refs 2/2 len 4/4 + - +0: term 19 m8 a13 refs 2/2 len 4/4 + - +0: term 25 m9 a4 refs 2/2 len 4/4 + - +0: term 33 m12 a14 refs 2/2 len 5/5 + - +0: term 40 m13 a6 refs 2/2 len 3/3 +- body length differences: total +6 / -20 +- Share bytes (refs x TagN width): MSS 405, all 377 +- first entry (MSS order) with a different term-level form: term 235, MSS index 45, all index 45, deg 2, refs 2/2 + - first difference at position 5: MSS Some((true, 86)), all Some((false, 86)) + - MSS bytes: 7321150e17b67221170e17b809 + - all bytes: 7321150e1768087221170e17b809 + +- MSS with StructuralId ties: TagN 2008 B, Tag4 2008 B +- MSS with Blake3 ties: TagN 2008 B, Tag4 2008 B +# Polynomial.cyclotomic_prime_mul_X_sub_one (75fb50ca854467f1) +- TagN bytes: MSS 2008, all 1969 (-39); table entries MSS 74, all 74; DAG nodes 277 +- entry bodies MSS 518, all 484; roots MSS 198, all 193 +- Shares: MSS 218 (TagN width 1/2/3/wider: [31, 187, 0, 0]), all 216 ([70, 146, 0, 0]); stored-term occurrences written inline: MSS 0, all 2 +- all: phase-1 order kept false, first tier [7, 12, 17, 18, 74, 75, 83, 84], w 0 +- entries with the same term-level form: 72 of 74; entries at a different index: 6 +- roots with the same term-level form: true +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: 48: 2 (m32 a32 deg 2) +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +1: term 81 m37 a37 refs 2/2 len 4/5 + - +1: term 210 m69 a69 refs 2/2 len 21/22 + - +0: term 7 m4 a4 refs 2/2 len 3/3 + - +0: term 9 m5 a8 refs 2/2 len 3/3 + - +0: term 12 m0 a0 refs 9/9 len 2/2 + - +0: term 14 m6 a9 refs 2/2 len 3/3 + - +0: term 16 m7 a10 refs 2/2 len 3/3 + - +0: term 17 m1 a1 refs 4/4 len 3/3 + - +0: term 18 m8 a5 refs 2/2 len 3/3 + - +0: term 20 m11 a11 refs 2/2 len 3/3 + - +0: term 26 m12 a12 refs 2/2 len 3/3 + - +0: term 27 m13 a13 refs 2/2 len 3/3 +- body length differences: total +2 / -36 +- Share bytes (refs x TagN width): MSS 405, all 362 +- first entry (MSS order) with a different term-level form: term 141, MSS index 52, all index 52, deg 2, refs 2/2 + - first difference at position 4: MSS Some((true, 48)), all Some((false, 48)) + - MSS bytes: 72b80bb801b818 + - all bytes: 72b80bb6680c + +- MSS with StructuralId ties: TagN 1366 B, Tag4 1366 B +- MSS with Blake3 ties: TagN 1352 B, Tag4 1352 B +# CommGrpCat.toAddCommGrp._proof_1 (7610a624ae9ed671) +- TagN bytes: MSS 1366, all 1347 (-19); table entries MSS 32, all 32; DAG nodes 134 +- entry bodies MSS 313, all 294; roots MSS 19, all 19 +- Shares: MSS 95 (TagN width 1/2/3/wider: [20, 75, 0, 0]), all 95 ([39, 56, 0, 0]); stored-term occurrences written inline: MSS 0, all 0 +- all: phase-1 order kept false, first tier [3, 5, 11, 17, 35, 36, 46, 47], w 0 +- entries with the same term-level form: 32 of 32; entries at a different index: 9 +- roots with the same term-level form: true +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +0: term 3 m0 a0 refs 4/4 len 3/3 + - +0: term 5 m2 a2 refs 2/2 len 3/3 + - +0: term 6 m3 a8 refs 2/2 len 3/3 + - +0: term 7 m4 a9 refs 2/2 len 3/3 + - +0: term 11 m1 a1 refs 4/4 len 3/3 + - +0: term 15 m5 a10 refs 2/2 len 3/3 + - +0: term 16 m6 a11 refs 2/2 len 3/3 + - +0: term 17 m7 a3 refs 2/2 len 3/3 + - +0: term 20 m12 a12 refs 2/2 len 3/3 + - +0: term 22 m13 a13 refs 2/2 len 4/4 + - +0: term 25 m14 a14 refs 2/2 len 4/4 + - +0: term 26 m15 a15 refs 2/2 len 4/4 +- body length differences: total +0 / -19 +- Share bytes (refs x TagN width): MSS 170, all 151 + +- MSS with StructuralId ties: TagN 848 B, Tag4 848 B +- MSS with Blake3 ties: TagN 847 B, Tag4 847 B +# SkewMonoidAlgebra.instNonUnitalRing._proof_1 (84f5c3fc061d7f4a) +- TagN bytes: MSS 848, all 838 (-10); table entries MSS 18, all 18; DAG nodes 130 +- entry bodies MSS 151, all 140; roots MSS 101, all 102 +- Shares: MSS 56 (TagN width 1/2/3/wider: [25, 31, 0, 0]), all 56 ([35, 21, 0, 0]); stored-term occurrences written inline: MSS 0, all 0 +- all: phase-1 order kept false, first tier [10, 12, 26, 27, 51, 54, 76, 79], w 0 +- entries with the same term-level form: 18 of 18; entries at a different index: 8 +- roots with the same term-level form: true +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +0: term 10 m1 a1 refs 4/4 len 3/3 + - +0: term 12 m0 a0 refs 5/5 len 3/3 + - +0: term 15 m4 a8 refs 2/2 len 3/3 + - +0: term 22 m5 a9 refs 2/2 len 4/4 + - +0: term 26 m2 a2 refs 4/4 len 4/4 + - +0: term 27 m3 a3 refs 4/4 len 3/3 + - +0: term 38 m6 a10 refs 2/2 len 5/5 + - +0: term 41 m7 a11 refs 2/2 len 5/5 + - +0: term 51 m8 a4 refs 2/2 len 4/4 + - +0: term 54 m10 a6 refs 2/2 len 4/4 + - +0: term 73 m12 a12 refs 2/2 len 12/12 + - +0: term 94 m14 a14 refs 2/2 len 12/12 +- body length differences: total +0 / -11 +- Share bytes (refs x TagN width): MSS 87, all 77 + +- MSS with StructuralId ties: TagN 1294 B, Tag4 1294 B +- MSS with Blake3 ties: TagN 1294 B, Tag4 1294 B +# CategoryTheory.MonoidalOpposite.mopMopEquivalence_counitIso_inv_app (859c756372f27e7c) +- TagN bytes: MSS 1294, all 1271 (-23); table entries MSS 36, all 36; DAG nodes 210 +- entry bodies MSS 292, all 277; roots MSS 187, all 179 +- Shares: MSS 126 (TagN width 1/2/3/wider: [23, 103, 0, 0]), all 126 ([46, 80, 0, 0]); stored-term occurrences written inline: MSS 0, all 0 +- all: phase-1 order kept false, first tier [17, 21, 22, 42, 53, 60, 62, 92], w 0 +- entries with the same term-level form: 36 of 36; entries at a different index: 18 +- roots with the same term-level form: true +- all: stored terms written inline (term: count, MSS index, all index, deg, unshared-size class), top 15: +- entries with the largest (all - MSS) body length (term, MSS index, all index, refs MSS/all, length MSS/all): + - +1: term 57 m21 a21 refs 2/2 len 4/5 + - +1: term 58 m22 a22 refs 2/2 len 4/5 + - +0: term 6 m1 a14 refs 2/2 len 6/6 + - +0: term 8 m2 a15 refs 2/2 len 8/8 + - +0: term 12 m3 a16 refs 2/2 len 4/4 + - +0: term 14 m4 a17 refs 2/2 len 4/4 + - +0: term 17 m5 a0 refs 2/2 len 4/4 + - +0: term 21 m7 a2 refs 2/2 len 3/3 + - +0: term 22 m11 a5 refs 2/2 len 4/4 + - +0: term 24 m18 a18 refs 2/2 len 4/4 + - +0: term 27 m19 a19 refs 2/2 len 6/6 + - +0: term 33 m20 a20 refs 2/2 len 6/6 +- body length differences: total +2 / -17 +- Share bytes (refs x TagN width): MSS 229, all 206 + +``` + +
+ +
[X6] join output (outlier_kahn.txt) + +```text +idx,addr,name,kind,raw,k,wk,status1,status2,status3,stored1,stored2,stored3,bytes1,bytes2,bytes3,kbased,best,best_w,rewidth,rewidth_w,ms1,ms2,ms3,status_all,stored_all,bytes_all,best4,best4_w,ms_all,kept1,kept2,kept3,kept_all +0,048653e65a77d222b4f07c2bee4a1b01ae69f1d615ee776d997156626975b878,"Affine.Triangle.dist_orthogonalProjectionSpan_faceOpposite_eq_iff_two_zsmul_oangle_eq",defn,96389,2230,3,ok,ok,ok,1924,1895,1755,65444,65264,65247,65247,65247,3,65247,3,1034.347,1010.188,1015.793,ok,2230,67367,65247,3,1367.599,true,true,false,false +idx,addr,name,kind,raw,k,wk,status1,status2,status3,stored1,stored2,stored3,bytes1,bytes2,bytes3,kbased,best,best_w,rewidth,rewidth_w,ms1,ms2,ms3,status_all,stored_all,bytes_all,best4,best4_w,ms_all +0,048653e65a77d222b4f07c2bee4a1b01ae69f1d615ee776d997156626975b878,"Affine.Triangle.dist_orthogonalProjectionSpan_faceOpposite_eq_iff_two_zsmul_oangle_eq",defn,96389,2230,3,ok,ok,ok,1924,1895,1755,72405,70422,70623,70623,70422,2,70623,3,585.156,579.169,629.983,ok,2230,72065,70422,2,652.159 +``` + +
+ +
[X7] join output (serial_a_report.txt) + +```text +# sharing_corpus report +- corpus: $S/mathlib.ixe (679499 constants; 11 processed); layout TagN +- wall: index 11664 ms, processing 515.9 s with 20 threads; peak RSS 4493864 KiB +- certified: 11 / 11; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 3766317 B; output under Tag4 2360626 B (-37.32%); under TagN 2269586 B (-39.74%) +- unshared (where it fits u64, 11 constants): 7784704407 B; stored 3766317 B; Tag4 output 2360626 B +- Tag4 output - stored per constant: 11 smaller, 0 equal, 0 larger; min -262507 p1 -262507 p10 -189740 p50 -135224 p90 -48493 p99 -48493 p99.9 -48493 max -1005 +- TagN price - stored per constant: min -270947 p1 -270947 p10 -196799 p50 -141547 p90 -64209 p99 -64209 p99.9 -64209 max -1005 +- phase-1 width w: {1: 3, 2: 5, 3: 3} +- uncertain terms per constant: min 85 p1 85 p10 651 p50 1707 p90 2610 p99 2610 p99.9 2610 max 2741 +- largest component per constant: min 3 p1 3 p10 3 p50 3 p90 8 p99 8 p99.9 8 max 10 +- uniform search states per constant: min 586 p1 586 p10 2590 p50 6586 p90 11006 p99 11006 p99.9 11006 max 11091 +- first-tier search states per constant: min 292 p1 292 p10 6300 p50 10045 p90 25590 p99 25590 p99.9 25590 max 42797 +- R1/R2 candidates per constant (all): min 450 p1 450 p10 18995 p50 41872 p90 61641 p99 61641 p99.9 61641 max 81833 +- milliseconds per constant (certified): min 81 p1 81 p10 25163 p50 44367 p90 59185 p99 59185 p99.9 59185 max 128445 +- slowest 10: + - 128445 ms CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56): defn ok, N 95110, cand 81833, k 21461, w 2, uncertain 2741, components 2548 (largest 3), states uniform 11006 first-tier 18886 + - 59185 ms Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux (83b417c6e46f08e2): defn ok, N 64047, cand 41872, k 8745, w 1, uncertain 1863, components 1562 (largest 8), states uniform 7860 first-tier 7174 + - 50237 ms AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (4ece542b15e7b7a1): defn ok, N 66025, cand 52066, k 10555, w 3, uncertain 1707, components 1541 (largest 3), states uniform 6586 first-tier 8986 + - 48458 ms _private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three (67e377956e9a5e65): defn ok, N 50027, cand 26233, k 10413, w 2, uncertain 1431, components 1407 (largest 3), states uniform 5685 first-tier 9035 + - 47832 ms Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (2b0491741df2ce98): defn ok, N 78913, cand 59202, k 13054, w 1, uncertain 2610, components 2293 (largest 5), states uniform 11091 first-tier 42797 + - 44367 ms WeierstrassCurve.variableChange_Δ (0473473f736e639b): defn ok, N 63501, cand 18995, k 9233, w 3, uncertain 651, components 640 (largest 3), states uniform 2590 first-tier 25590 + - 40183 ms _private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1 (159e2b0d36d95a7f): defn ok, N 70414, cand 61641, k 11700, w 3, uncertain 1627, components 1537 (largest 4), states uniform 6464 first-tier 10045 + - 39726 ms AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq (2d33bfe7c13b87fd): defn ok, N 53511, cand 44632, k 12056, w 2, uncertain 1969, components 1752 (largest 5), states uniform 7601 first-tier 20450 + - 28101 ms _private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq' (3d79d639858e7cc1): defn ok, N 53222, cand 38483, k 7317, w 1, uncertain 1224, components 1037 (largest 3), states uniform 4856 first-tier 6300 + - 25163 ms WeierstrassCurve.isHomogeneous_addSubMapCoeff (f2ce788af955876c): defn ok, N 60092, cand 31902, k 10150, w 2, uncertain 1945, components 1879 (largest 3), states uniform 7672 first-tier 16311 +- total wall 750.9 s + +per-constant (addr, name, status, ms, N, cand, w): +00fe7a1095b01adb "SimplexCategory.δ₀Iter_δ'" ok 81.328 865 450 2 +0473473f736e639b "WeierstrassCurve.variableChange_Δ" ok 44366.662 63501 18995 3 +159e2b0d36d95a7f "_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1" ok 40182.686 70414 61641 3 +2b0491741df2ce98 "Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual" ok 47831.645 78913 59202 1 +2d33bfe7c13b87fd "AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq" ok 39725.999 53511 44632 2 +3d79d639858e7cc1 "_private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq'" ok 28100.699 53222 38483 1 +4ece542b15e7b7a1 "AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective" ok 50237.020 66025 52066 3 +67e377956e9a5e65 "_private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three" ok 48457.751 50027 26233 2 +83b417c6e46f08e2 "Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux" ok 59184.604 64047 41872 1 +bd34cbe632ec9a56 "CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite" ok 128444.697 95110 81833 2 +f2ce788af955876c "WeierstrassCurve.isHomogeneous_addSubMapCoeff" ok 25163.150 60092 31902 2 + Elapsed (wall clock) time (h:mm:ss or m:ss): 12:31.96 + Maximum resident set size (kbytes): 4493864 +exit=0 +``` + +
+ +
[X7] join output (serial_b_report.txt) + +```text +# sharing_corpus report +- corpus: $S/mathlib.ixe (679499 constants; 11 processed); layout TagN +- wall: index 7646 ms, processing 149.3 s with 20 threads; peak RSS 4506028 KiB +- certified: 11 / 11; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 3766317 B; output under Tag4 2360626 B (-37.32%); under TagN 2269586 B (-39.74%) +- unshared (where it fits u64, 11 constants): 7784704407 B; stored 3766317 B; Tag4 output 2360626 B +- Tag4 output - stored per constant: 11 smaller, 0 equal, 0 larger; min -262507 p1 -262507 p10 -189740 p50 -135224 p90 -48493 p99 -48493 p99.9 -48493 max -1005 +- TagN price - stored per constant: min -270947 p1 -270947 p10 -196799 p50 -141547 p90 -64209 p99 -64209 p99.9 -64209 max -1005 +- phase-1 width w: {1: 3, 2: 5, 3: 3} +- uncertain terms per constant: min 85 p1 85 p10 651 p50 1707 p90 2610 p99 2610 p99.9 2610 max 2741 +- largest component per constant: min 3 p1 3 p10 3 p50 3 p90 8 p99 8 p99.9 8 max 10 +- uniform search states per constant: min 586 p1 586 p10 2590 p50 6586 p90 11006 p99 11006 p99.9 11006 max 11091 +- first-tier search states per constant: min 292 p1 292 p10 6300 p50 10045 p90 25590 p99 25590 p99.9 25590 max 42797 +- R1/R2 candidates per constant (all): min 450 p1 450 p10 18995 p50 41872 p90 61641 p99 61641 p99.9 61641 max 81833 +- milliseconds per constant (certified): min 40 p1 40 p10 7115 p50 13056 p90 24732 p99 24732 p99.9 24732 max 30072 +- slowest 10: + - 30072 ms CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56): defn ok, N 95110, cand 81833, k 21461, w 2, uncertain 2741, components 2548 (largest 3), states uniform 11006 first-tier 18886 + - 24732 ms Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (2b0491741df2ce98): defn ok, N 78913, cand 59202, k 13054, w 1, uncertain 2610, components 2293 (largest 5), states uniform 11091 first-tier 42797 + - 17663 ms WeierstrassCurve.variableChange_Δ (0473473f736e639b): defn ok, N 63501, cand 18995, k 9233, w 3, uncertain 651, components 640 (largest 3), states uniform 2590 first-tier 25590 + - 14218 ms AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (4ece542b15e7b7a1): defn ok, N 66025, cand 52066, k 10555, w 3, uncertain 1707, components 1541 (largest 3), states uniform 6586 first-tier 8986 + - 13980 ms _private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1 (159e2b0d36d95a7f): defn ok, N 70414, cand 61641, k 11700, w 3, uncertain 1627, components 1537 (largest 4), states uniform 6464 first-tier 10045 + - 13056 ms AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq (2d33bfe7c13b87fd): defn ok, N 53511, cand 44632, k 12056, w 2, uncertain 1969, components 1752 (largest 5), states uniform 7601 first-tier 20450 + - 9230 ms _private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three (67e377956e9a5e65): defn ok, N 50027, cand 26233, k 10413, w 2, uncertain 1431, components 1407 (largest 3), states uniform 5685 first-tier 9035 + - 8390 ms Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux (83b417c6e46f08e2): defn ok, N 64047, cand 41872, k 8745, w 1, uncertain 1863, components 1562 (largest 8), states uniform 7860 first-tier 7174 + - 8146 ms _private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq' (3d79d639858e7cc1): defn ok, N 53222, cand 38483, k 7317, w 1, uncertain 1224, components 1037 (largest 3), states uniform 4856 first-tier 6300 + - 7115 ms WeierstrassCurve.isHomogeneous_addSubMapCoeff (f2ce788af955876c): defn ok, N 60092, cand 31902, k 10150, w 2, uncertain 1945, components 1879 (largest 3), states uniform 7672 first-tier 16311 +- total wall 423.7 s + +per-constant (addr, name, status, ms, N, cand, w): +00fe7a1095b01adb "SimplexCategory.δ₀Iter_δ'" ok 40.144 865 450 2 +0473473f736e639b "WeierstrassCurve.variableChange_Δ" ok 17662.892 63501 18995 3 +159e2b0d36d95a7f "_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1" ok 13980.043 70414 61641 3 +2b0491741df2ce98 "Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual" ok 24731.996 78913 59202 1 +2d33bfe7c13b87fd "AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq" ok 13055.659 53511 44632 2 +3d79d639858e7cc1 "_private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq'" ok 8145.573 53222 38483 1 +4ece542b15e7b7a1 "AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective" ok 14218.098 66025 52066 3 +67e377956e9a5e65 "_private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three" ok 9229.587 50027 26233 2 +83b417c6e46f08e2 "Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux" ok 8389.657 64047 41872 1 +bd34cbe632ec9a56 "CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite" ok 30072.401 95110 81833 2 +f2ce788af955876c "WeierstrassCurve.isHomogeneous_addSubMapCoeff" ok 7114.862 60092 31902 2 + Elapsed (wall clock) time (h:mm:ss or m:ss): 7:04.50 + Maximum resident set size (kbytes): 4506028 +exit=0 +``` + +
+ +
[X7] join output (serial_c_report.txt) + +```text +# sharing_corpus report +- corpus: $S/mathlib.ixe (679499 constants; 11 processed); layout TagN +- wall: index 4902 ms, processing 69.8 s with 20 threads; peak RSS 4643556 KiB +- certified: 11 / 11; failed: 0 +- failures by status: {} +- certified constants: stored (heuristic) 3766317 B; output under Tag4 2360626 B (-37.32%); under TagN 2269586 B (-39.74%) +- unshared (where it fits u64, 11 constants): 7784704407 B; stored 3766317 B; Tag4 output 2360626 B +- Tag4 output - stored per constant: 11 smaller, 0 equal, 0 larger; min -262507 p1 -262507 p10 -189740 p50 -135224 p90 -48493 p99 -48493 p99.9 -48493 max -1005 +- TagN price - stored per constant: min -270947 p1 -270947 p10 -196799 p50 -141547 p90 -64209 p99 -64209 p99.9 -64209 max -1005 +- phase-1 width w: {1: 3, 2: 5, 3: 3} +- uncertain terms per constant: min 85 p1 85 p10 651 p50 1707 p90 2610 p99 2610 p99.9 2610 max 2741 +- largest component per constant: min 3 p1 3 p10 3 p50 3 p90 8 p99 8 p99.9 8 max 10 +- uniform search states per constant: min 586 p1 586 p10 2590 p50 6586 p90 11006 p99 11006 p99.9 11006 max 11091 +- first-tier search states per constant: min 292 p1 292 p10 6300 p50 10045 p90 25590 p99 25590 p99.9 25590 max 42797 +- R1/R2 candidates per constant (all): min 450 p1 450 p10 18995 p50 41872 p90 61641 p99 61641 p99.9 61641 max 81833 +- milliseconds per constant (certified): min 9 p1 9 p10 2622 p50 4795 p90 6783 p99 6783 p99.9 6783 max 20723 +- slowest 10: + - 20723 ms CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56): defn ok, N 95110, cand 81833, k 21461, w 2, uncertain 2741, components 2548 (largest 3), states uniform 11006 first-tier 18886 + - 6783 ms AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (4ece542b15e7b7a1): defn ok, N 66025, cand 52066, k 10555, w 3, uncertain 1707, components 1541 (largest 3), states uniform 6586 first-tier 8986 + - 6422 ms Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux (83b417c6e46f08e2): defn ok, N 64047, cand 41872, k 8745, w 1, uncertain 1863, components 1562 (largest 8), states uniform 7860 first-tier 7174 + - 6337 ms Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (2b0491741df2ce98): defn ok, N 78913, cand 59202, k 13054, w 1, uncertain 2610, components 2293 (largest 5), states uniform 11091 first-tier 42797 + - 5831 ms _private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three (67e377956e9a5e65): defn ok, N 50027, cand 26233, k 10413, w 2, uncertain 1431, components 1407 (largest 3), states uniform 5685 first-tier 9035 + - 4795 ms _private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1 (159e2b0d36d95a7f): defn ok, N 70414, cand 61641, k 11700, w 3, uncertain 1627, components 1537 (largest 4), states uniform 6464 first-tier 10045 + - 4708 ms WeierstrassCurve.isHomogeneous_addSubMapCoeff (f2ce788af955876c): defn ok, N 60092, cand 31902, k 10150, w 2, uncertain 1945, components 1879 (largest 3), states uniform 7672 first-tier 16311 + - 4512 ms AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq (2d33bfe7c13b87fd): defn ok, N 53511, cand 44632, k 12056, w 2, uncertain 1969, components 1752 (largest 5), states uniform 7601 first-tier 20450 + - 4098 ms WeierstrassCurve.variableChange_Δ (0473473f736e639b): defn ok, N 63501, cand 18995, k 9233, w 3, uncertain 651, components 640 (largest 3), states uniform 2590 first-tier 25590 + - 2622 ms _private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq' (3d79d639858e7cc1): defn ok, N 53222, cand 38483, k 7317, w 1, uncertain 1224, components 1037 (largest 3), states uniform 4856 first-tier 6300 +- total wall 221.6 s + +per-constant (addr, name, status, ms, N, cand, w): +00fe7a1095b01adb "SimplexCategory.δ₀Iter_δ'" ok 8.786 865 450 2 +0473473f736e639b "WeierstrassCurve.variableChange_Δ" ok 4098.233 63501 18995 3 +159e2b0d36d95a7f "_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1" ok 4795.154 70414 61641 3 +2b0491741df2ce98 "Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual" ok 6337.003 78913 59202 1 +2d33bfe7c13b87fd "AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq" ok 4512.205 53511 44632 2 +3d79d639858e7cc1 "_private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq'" ok 2622.169 53222 38483 1 +4ece542b15e7b7a1 "AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective" ok 6782.737 66025 52066 3 +67e377956e9a5e65 "_private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.0.WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three" ok 5830.569 50027 26233 2 +83b417c6e46f08e2 "Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux" ok 6422.273 64047 41872 1 +bd34cbe632ec9a56 "CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite" ok 20722.772 95110 81833 2 +f2ce788af955876c "WeierstrassCurve.isHomogeneous_addSubMapCoeff" ok 4707.564 60092 31902 2 + Elapsed (wall clock) time (h:mm:ss or m:ss): 3:42.69 + Maximum resident set size (kbytes): 4643556 +exit=0 +``` + +
+ +
[X9] join output (dense_widths_all.txt) + +```text +idx,addr,name,kind,raw,k,wk,status1,status2,status3,stored1,stored2,stored3,bytes1,bytes2,bytes3,kbased,best,best_w,rewidth,rewidth_w,ms1,ms2,ms3,status_all,stored_all,bytes_all,best4,best4_w,ms_all,kept1,kept2,kept3,kept_all +# dense_widths +0,ca5b91d86331eb4a78896d3a3d6507d595c1fe23606596e426a34ef83bbe33d3,"CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite",defn,607293,21461,3,resource:States,resource:States,resource:States,0,0,0,,,,,,,,1,2737.055,2819.619,2646.535,ok,21461,340538,340538,all,33278.215,false,false,false,false +# dense_widths_26 +0,ca5b91d86331eb4a78896d3a3d6507d595c1fe23606596e426a34ef83bbe33d3,"CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite",defn,607293,21461,3,ok,ok,ok,18653,18877,18440,338539,337241,340770,340770,337241,2,340770,3,81254.102,49317.505,33608.119,ok,21461,340538,337241,2,30703.228,false,false,false,false +# dense_widths_knap +0,ca5b91d86331eb4a78896d3a3d6507d595c1fe23606596e426a34ef83bbe33d3,"CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite",defn,607293,21461,3,ok,ok,ok,18653,18877,18440,338539,337241,340770,340770,337241,2,340770,3,89636.936,48631.322,37994.027,ok,21461,340538,337241,2,43839.404,false,false,false,false +``` + +
+ + +## Appendix B: differential tallies + +For each differential log: the tally lines and the `DIAGNOSIS` lines, unedited apart from local paths +(written `$S/…`). The per-constant `NOTE` lines are omitted, except the one same-error case of [D11]. + +
[D0] Init, the 10 Lean-only constants, limit diagnosis (*diag*) + +`diag_init.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 97 ms, Rust 6 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1533 ms, Rust 250 ms + [corpus: $S/init.ixe, 56622 constants, comparing 10 under [tiered-tagN, tiered-tag4]; loaded in 1027 ms] + DIAGNOSIS _private.Init.Data.Nat.ToString.«0».Nat.digitChar_iff_aux (0691b3f1e8c36b6ba49eb789ca815ff0583eb48dc4c46886aadb190fe43be2f6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Nat.ToString.«0».Nat.digitChar_iff_aux (0691b3f1e8c36b6ba49eb789ca815ff0583eb48dc4c46886aadb190fe43be2f6) [tiered-tag4]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1 (194bacb9fee23ecb45a13a8fab2095b3f074dceb7bedb7a1a75f47f3ffe5c73b) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1 (194bacb9fee23ecb45a13a8fab2095b3f074dceb7bedb7a1a75f47f3ffe5c73b) [tiered-tag4]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1 (5a362f9e99724cbf1e4dc40216ab8c45c0629e8394bc419dc3ce03a689ca4173) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1 (5a362f9e99724cbf1e4dc40216ab8c45c0629e8394bc419dc3ce03a689ca4173) [tiered-tag4]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1 (89ed0e98891415751b5d901324eb6eece9183078959dd60430cb17bc64d44d79) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1 (89ed0e98891415751b5d901324eb6eece9183078959dd60430cb17bc64d44d79) [tiered-tag4]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806af97e4b133d9d54fb55d3b46d23e0369d83fdd811284302e6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806af97e4b133d9d54fb55d3b46d23e0369d83fdd811284302e6) [tiered-tag4]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1 (b6be5c1a4db8c149c47bd94b0f4acb4231b46ecc62bc2a05cd4be985c5950a74) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1 (b6be5c1a4db8c149c47bd94b0f4acb4231b46ecc62bc2a05cd4be985c5950a74) [tiered-tag4]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1 (d126ef57b21ab268daf3d9cb8faef5455e330eb505556ef14924e8d9cbec2fd9) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1 (d126ef57b21ab268daf3d9cb8faef5455e330eb505556ef14924e8d9cbec2fd9) [tiered-tag4]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514063f3b8c9158d9aea80ca6f8be60d1bdcb3c89b6e7a13333) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514063f3b8c9158d9aea80ca6f8be60d1bdcb3c89b6e7a13333) [tiered-tag4]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1 (e852d49c2b3a2ea71d1036e9a19406c99f5db76288c568bceb90e40c939ebfec) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1 (e852d49c2b3a2ea71d1036e9a19406c99f5db76288c568bceb90e40c939ebfec) [tiered-tag4]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1 (eed90987192d51608f220fd7d7ed664c9c87c132401a2e87a4912cc177e4e941) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1 (eed90987192d51608f220fd7d7ed664c9c87c132401a2e87a4912cc177e4e941) [tiered-tag4]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + [corpus tiered-tagN: 10 constants; 0 same bytes, 0 same error category, 10 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 63094 ms, Rust 9032 ms] + [corpus tiered-tag4: 10 constants; 0 same bytes, 0 same error category, 10 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 40504 ms, Rust 8838 ms] + [corpus: decode failures 0; total 570448 ms] +``` + +
+ +
[D1] Init, all constants, old search, K-based (*diff-1*) + +`corpus_full.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 169 ms, Rust 8 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1242 ms, Rust 207 ms + [corpus: $S/init.ixe, 56622 constants, comparing 56622 under [tiered-tagN, tiered-tag4, uniform-w2]; loaded in 647 ms] + [corpus progress: 5000/56622] + [corpus progress: 10000/56622] + [corpus progress: 15000/56622] + [corpus progress: 20000/56622] + [corpus progress: 25000/56622] + [corpus progress: 30000/56622] + [corpus progress: 35000/56622] + [corpus progress: 40000/56622] + [corpus progress: 45000/56622] + [corpus progress: 50000/56622] + [corpus progress: 55000/56622] + [corpus tiered-tagN: 56622 constants; 56587 same bytes, 25 same error category, 10 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1380260 ms, Rust 137091 ms] + [corpus tiered-tag4: 56622 constants; 56583 same bytes, 29 same error category, 10 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1560208 ms, Rust 146501 ms] + [corpus uniform-w2: 56622 constants; 56594 same bytes, 28 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1206994 ms, Rust 100361 ms] + [corpus: decode failures 0; total 4536443 ms] +exit=0 wall=4543s +``` + +
+ +
[D2] Init, all constants, new search, K-based (*k-bb*) + +`init_bb_s0.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 43 ms, Rust 3 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 477 ms, Rust 138 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, uniform-w2]; loaded in 629 ms] + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1 (5a362f9e99724cbf1e4dc40216ab8c45c0629e8394bc419dc3ce03a689ca4173) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + [corpus progress: 5000/9437] + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1 (89ed0e98891415751b5d901324eb6eece9183078959dd60430cb17bc64d44d79) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806af97e4b133d9d54fb55d3b46d23e0369d83fdd811284302e6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1 (eed90987192d51608f220fd7d7ed664c9c87c132401a2e87a4912cc177e4e941) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + [corpus tiered-tagN: 9437 constants; 9433 same bytes, 0 same error category, 4 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 91435 ms, Rust 14519 ms] + [corpus uniform-w2: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 30748 ms, Rust 5302 ms] + [corpus: decode failures 0; total 269562 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 4:31.73 + Maximum resident set size (kbytes): 834904 +exit=0 +``` + +`init_bb_s1.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 43 ms, Rust 3 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 474 ms, Rust 137 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, uniform-w2]; loaded in 631 ms] + [corpus progress: 5000/9437] + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1 (d126ef57b21ab268daf3d9cb8faef5455e330eb505556ef14924e8d9cbec2fd9) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514063f3b8c9158d9aea80ca6f8be60d1bdcb3c89b6e7a13333) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + [corpus tiered-tagN: 9437 constants; 9435 same bytes, 0 same error category, 2 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 76863 ms, Rust 13456 ms] + [corpus uniform-w2: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 27102 ms, Rust 5230 ms] + [corpus: decode failures 0; total 228840 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 3:51.04 + Maximum resident set size (kbytes): 835116 +exit=0 +``` + +`init_bb_s2.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 48 ms, Rust 3 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 526 ms, Rust 141 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, uniform-w2]; loaded in 496 ms] + [corpus progress: 5000/9437] + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1 (b6be5c1a4db8c149c47bd94b0f4acb4231b46ecc62bc2a05cd4be985c5950a74) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + [corpus tiered-tagN: 9437 constants; 9436 same bytes, 0 same error category, 1 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 63983 ms, Rust 11723 ms] + [corpus uniform-w2: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 22339 ms, Rust 5141 ms] + [corpus: decode failures 0; total 144167 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 2:26.56 + Maximum resident set size (kbytes): 835248 +exit=0 +``` + +`init_bb_s3.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 46 ms, Rust 5 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 467 ms, Rust 136 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, uniform-w2]; loaded in 496 ms] + [corpus progress: 5000/9437] + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1 (e852d49c2b3a2ea71d1036e9a19406c99f5db76288c568bceb90e40c939ebfec) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + [corpus tiered-tagN: 9437 constants; 9436 same bytes, 0 same error category, 1 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 69022 ms, Rust 11963 ms] + [corpus uniform-w2: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 23348 ms, Rust 4888 ms] + [corpus: decode failures 0; total 161702 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 2:43.64 + Maximum resident set size (kbytes): 835172 +exit=0 +``` + +`init_bb_s4.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 43 ms, Rust 3 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 391 ms, Rust 111 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, uniform-w2]; loaded in 477 ms] + DIAGNOSIS _private.Init.Data.Nat.ToString.«0».Nat.digitChar_iff_aux (0691b3f1e8c36b6ba49eb789ca815ff0583eb48dc4c46886aadb190fe43be2f6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1 (194bacb9fee23ecb45a13a8fab2095b3f074dceb7bedb7a1a75f47f3ffe5c73b) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9435 same bytes, 0 same error category, 2 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 67179 ms, Rust 11682 ms] + [corpus uniform-w2: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 24042 ms, Rust 5102 ms] + [corpus: decode failures 0; total 148137 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 2:30.23 + Maximum resident set size (kbytes): 834832 +exit=0 +``` + +`init_bb_s5.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 42 ms, Rust 3 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 437 ms, Rust 124 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, uniform-w2]; loaded in 446 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 67185 ms, Rust 12046 ms] + [corpus uniform-w2: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 23557 ms, Rust 5529 ms] + [corpus: decode failures 0; total 109736 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:52.04 + Maximum resident set size (kbytes): 835176 +exit=0 +``` + +
+ +
[D3] Mathlib sample, old search, K-based (*diag*) + +`mathlib_diff_a.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 48 ms, Rust 3 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 816 ms, Rust 147 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 10132 under [tiered-tagN, uniform-w2]; loaded in 9837 ms] + DIAGNOSIS _private.Init.Data.Nat.ToString.«0».Nat.digitChar_iff_aux (0691b3f1e8c36b6ba49eb789ca815ff0583eb48dc4c46886aadb190fe43be2f6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.negAddY_neg (14f75d2691415463319f5dfce1f3668d59f07ffde9b7aad7c8b0169f407f22ba) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.«0».RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1 (159e2b0d36d95a7feefe9a1f39b7e65da56802a29e83fe00e567d5b963506ede) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824]; succeeded with [maxMaterialize=2147483648]; bytes equal to Rust + DIAGNOSIS Std.DTreeMap.Internal.Impl.balanceR!_eq_balance! (1601895625b67ecddc59ecf9425ca6eae4c66d6b7c8ea8ce5e4490c3ea338e86) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1 (194bacb9fee23ecb45a13a8fab2095b3f074dceb7bedb7a1a75f47f3ffe5c73b) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS TopCat.Sheaf.interUnionPullbackConeLift._proof_5 (1f150c14a61c243d759f462e339b7d824e712ee26eb41419aa9f55b98f0de407) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Localization.existsUnique_algebraMap_eq_of_span_eq_top (23ae320acce50ca3d566210d11ac48d17bf7607df1c356a1a709cdfd12f55d33) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite (248b4aa033342acd791b861a9d0f8303a02c7f034e05a26eb8c5f4b087cc7e26) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS ModularForm.discriminant_T_invariant (28d6ee3847c930ae436f8ebc21fa67e03d783d95582be3871bccc5b249d01466) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.SheafedSpace.IsOpenImmersion.sigma_ι_isOpenImmersion_aux (2dacebaef8b139ded3b4019b96c90d19d0e06a845cff61c2e55763b2a70ded07) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.Scheme.IsLocallyDirected.glueData._proof_6 (338ca448f75e9c25258b64f2a325fac0899b8f347360454e8ecfe7bf7b72ccf7) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.associator_naturality (373b0d8e1af7fe3a1218e5b0f3e7df6c1aa2ad9d2f742ee6460b7f703e0e8e6c) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS HomogeneousLocalization.Away.isLocalization_mul (3af1f33ae2a05488ff0ea5dcdd4892be7d1ece5b5190a45cb3f0380b63791e9f) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.mateEquiv_hcomp (3cf47cf160e37479d1bdbab6b5706ee09570afc05cb16222ed5e00aac6e6711a) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS mem_adjoin_map_integralClosure_of_isStandardEtale (3f383549903f2a37fed9f5d95b0324b680883ee6286b5cfeef222dcdeb91ecc2) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.«0».SzemerediRegularity.edgeDensity_star_not_uniform._proof_1_10 (40e45f2eae83609168fb72486797c8757cf07a130636951cc9b786bc23b56fdc) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.NatTrans.instIsClosedUnderLimitsOfShapeOverFunctorEquifiberedHomOfHasCoproductsOfShapeHom (4b3beb75cfb6da5466c4d9e4e1f23a364c4c16d56ae9be83aa14cbd19a472a47) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS Std.Iter.atIdxSlow?_intermediateZip (55d247210280f56e60ab88a44a8cafb7977eb557fd8790c52fec53286049d547) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1 (5a362f9e99724cbf1e4dc40216ab8c45c0629e8394bc419dc3ce03a689ca4173) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.mono_pushoutSection_of_iSup_eq (5e122ca4869d76508a277442ec2a139158921d8628f607367032e3495bffacd5) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.«0».WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three (67e377956e9a5e65fa8a97da8775eb1f9fe0ff8f7bc6aed75111cd4b17a34636) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.go_denote_eq._unary (68f6e583c732c5f3c079ab3a315711d6b6cba09ffc8dd5b27bf618e251c3d4e6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.«0».ChevalleyThm.PolynomialC.induction_aux (6b75b2b24c2e310aa9ab5110fc9691b4b25818071fcff2019dbc13f2f5390377) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS CartanMatrix.E₇_det (6eb6aa5f6e5cc2b4d7606d8d544a3dc26d50e664bb81f852ef3225f88bddc7e4) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + [corpus progress: 5000/10132] + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1 (89ed0e98891415751b5d901324eb6eece9183078959dd60430cb17bc64d44d79) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.exists_appTop_π_eq_of_isLimit (92454eb0dbd050541a59931f3e202130028143a7c217a88bd98601e4f56d3eb7) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS SSet.StrictSegal.isPointwiseRightKanExtensionAt.fac_aux₂ (9fa5347780bca67caeaeb1f8a08ecc9257132be804ea62495a68113699479aba) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806af97e4b133d9d54fb55d3b46d23e0369d83fdd811284302e6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.Scheme.exists_π_app_comp_eq_of_locallyOfFinitePresentation (ae6266c2b1b35cb5d6b366f958c6ee2ec5d8e2fd577f6b401d82f59843d22004) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Bicategory.mateEquiv_hcomp (b201fe77a69f2111a0e3d3776b9ddda429506ebc08608e6307f867bcd69843cc) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Affine.addPolynomial_slope (b6a5154a781629bb1beb70715e2f9792a918d9c54f5d5c3d4dfae9d5eeac67e9) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.SurjectiveOnStalks.isEmbedding_pullback (bc547eefd4fd84f0992166f05140d4bc221cee0bbc84096c4d036a712e197361) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56a33fd7bb51e23fef8fadb90d7ae3af8216921776ed84bff7) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824, maxMaterialize=2147483648]; succeeded with [maxMaterialize=4294967296]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.isSheaf_type_propQCTopology_iff (c1a56567a54a70cbf0999232c590bb896c7544cd7678151801e236cd9ed6be37) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Lax.OplaxTrans.vComp_naturality_comp (c44c23e5d81a327b0388fb796eeb56d5b68a6d00d71ff74d8e3215088e23ab63) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Affine.CoordinateRing.XYIdeal_neg_mul (c4641901bb3705423856ac01d337794b1d1096a11d0dc76975389aab6a5b1e99) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1 (d126ef57b21ab268daf3d9cb8faef5455e330eb505556ef14924e8d9cbec2fd9) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS TopCat.subcanonical_grothendieckTopology (d216753fba4438d45cf79762178e94f4308da7809083d3392b6cdd369d177ea2) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS MeasureTheory.VectorMeasure.variation_withDensity' (d5ea2d6fbb4ca2a2dd2a75ef68b1768bb780fbab0c85aab6a97254d2d6709738) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.negAddY_eq' (d5ec80e0cce67eb9081abe1075d2940312017829abc9807ceebd32d4222b9b53) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq (d86a5b2a6aef9f5659a894d980fde30a535ed86961a806202ad6bc342eeff25c) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS CartanMatrix.E₆_det (d9660e5a43a0a0fb78097d2a4e562ac8897e887f60abed2bb3f1f3afc70b5f18) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Real.log_five_near_10 (da962aa5afcd9ef1d6f68919543b2a4f56ed97fb113cd9a101f964de681bacd6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Height.mulHeight_sym2_ge (dd9af4585ab3281fd2ae1e46887063a1fcf2d4103b57dff4a7134f89e2d9d159) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CartanMatrix.E₈_det (df85f966e9848e272be9df5ad9e86542a31c5ffd53b2ed63ac8885b9a12ffd64) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.RingTheory.Etale.QuasiFinite.«0».Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq.match_1_1 (dfd42dc5d9b404a98882ab7c615ff22954c63fbbe353aa4ca8ad1d2a1bce1c77) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1 (e852d49c2b3a2ea71d1036e9a19406c99f5db76288c568bceb90e40c939ebfec) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.«0».PeriodPair.iteratedDeriv_six_relation_mul_id_pow_six (ee4f82100489a77cf78a4c542d89541d94630ea17ff1700f3cd242fea32ad3da) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1 (eed90987192d51608f220fd7d7ed664c9c87c132401a2e87a4912cc177e4e941) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + [corpus progress: 10000/10132] + DIAGNOSIS StarAlgEquiv.eq_linearIsometryEquivConjStarAlgEquiv (fdf8644d47f8b068caf56ed87249a924df39afe7abe973d8b458c869639d3c38) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + [corpus tiered-tagN: 10132 constants; 10024 same bytes, 58 same error category, 50 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 4526636 ms, Rust 497523 ms] + [corpus uniform-w2: 10132 constants; 10080 same bytes, 52 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 2634761 ms, Rust 225629 ms] + [corpus: decode failures 0; total 11295228 ms] +uncaught exception: process 'lean' exited with code 255 + Elapsed (wall clock) time (h:mm:ss or m:ss): 3:08:16 + Maximum resident set size (kbytes): 4723896 +exit=1 +``` + +`mathlib_diff_b.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 53 ms, Rust 3 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 839 ms, Rust 141 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 10131 under [tiered-tagN, uniform-w2]; loaded in 9278 ms] + DIAGNOSIS WeierstrassCurve.variableChange_Δ (0473473f736e639b9211812b686cac21574deb66f2382c1f0cbf4166f7e542c7) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824]; succeeded with [maxMaterialize=2147483648]; bytes equal to Rust + DIAGNOSIS ContinuousMultilinearMap.hasStrictFDerivAt_compContinuousLinearMap (057bc467cdb7583185b00d13e915f514af7be0fb23afc5eb648a60c02bdf766c) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS groupCohomology.H1InfRes_exact (076a4a5d72838673c8b1a235fff84767e47060fe8641e355be2c3c68fbf3fd7a) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS sum_eight_sq_mul_sum_eight_sq (0bd4b1175ac1d995d92bf0bec451195592d9edf04afe3cee884da42b7b96c766) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS _private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop.«0».Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastCpopLayer.go._unary (0f75bea9d5dd4591a6f321934e261404b9a8548358d528223bf692a33527d74b) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Jacobian.negAddY_neg (16256043fdb806ecabbd3e043f8f0debf9826eaddc46e79aafb255f469655143) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Algebra.WeaklyQuasiFiniteAt.of_quasiFiniteAt_residueField (1817bbc31c531206f258dd78757e193fe5357451872bb99278d6b46ff8ff6db3) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS MeasureTheory.hasFDerivAt_convolution_right_with_param (221da52233e80ce3a00f6c08e88563b9f5bc6bd5ecf58711be10e25c6a529233) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (2b0491741df2ce98fdf1d49103d1d62a34c935f682c5afe6ef8c4d84916ce51d) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824]; succeeded with [maxMaterialize=2147483648]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq (2d33bfe7c13b87fd41641f9f2fa67e9324fdb71f8a8a3bac49eb3212bfead8e3) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.Proj.valuativeCriterion_existence_aux (36fd5f58fc5f01ac2095417c31694a35783c1c7f13730d9dfa05c2e004757429) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.negDblY_eq' (37cd1c7638fa9899f80d12762241905e5858b0abbf3a9380e8efd93299d3edf5) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.RingTheory.Etale.QuasiFinite.«0».Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq' (3d79d639858e7cc1e87be66760c72e5602102ed2ae099344d87ddc48d77d7494) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayer.go._unary.eq_def (4382aa4d3e6b329f7c28bd5362cba003121730be4b8d8177db49a74abd26691d) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (4ece542b15e7b7a1cfeccea61d88b4a5d5aa477eb8d8938135f7458d8e353e45) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824]; succeeded with [maxMaterialize=2147483648]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Affine.CoordinateRing.XYIdeal_mul_XYIdeal (665f70ff00b204b53d640e57a680266f14339615286866d299612ec5560b770f) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Cubic.discr_eq_prod_three_roots (6a0f9ca821efc5daed4ea38e21ec37f894b62251fa54f0557700e7721ab6df02) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS groupHomology.H1CoresCoinf_exact (6cc20762d74eb85e981ae78103c561f0be13b11ae5cf5b02ca1bf76794455b3e) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.«0».RootPairing.GeckConstruction.instIsIrreducible_aux₀ (6d67600cf8c031b8c42fd108bf4361076ff70248e9a91a8bd1105d615ee73777) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + [corpus progress: 5000/10131] + DIAGNOSIS _private.Mathlib.Topology.Order.WithTop.«0».TopologicalSpace.instSecondCountableTopologyWithTop._proof_3 (828b225acbe466836dca7bf72ce2c1125d3b502ccc7f80e80cbe8c0a40e81374) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux (83b417c6e46f08e27487d87f4529f9c7fdfe204a274e99549522d52940a4ea9b) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Algebra.Group.Pi.Lemmas.«0».Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle._proof_1_2 (8466008af12aab87e42a21847e9d9e7d8d05f5baf1a65ec4c8e9cfb4e89e6717) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.ofJNe0Or1728_Δ (8a2cd7f10b14aee963dd9e952f040b418dd06fab0a3d6798332c2d8032bc01df) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.AlgebraicGeometry.AffineTransitionLimit.«0».AlgebraicGeometry.Scheme.exists_π_app_comp_eq_of_locallyOfFinitePresentation_of_isAffine (8db8dbcb6033f83c3e6e02db5f18b9efd78d24cfa41a6ad9ca3bb8c6192e6e19) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.instMulActionVariableChange._proof_1 (904073d4c5010184f89d49609e09059722b112294deed7930de71b63ee1fcdd3) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Bicategory.mateEquiv_vcomp (9b20bc429f4cd0385f921ace7d460a81141d4121a5549e30aec57ed50d58713e) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824]; succeeded with [maxMaterialize=2147483648]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.addX_eq' (9cbee9afea050a41bf70cc127ecd5f108a3ba9a9eb83491ff815b26b5137fcd6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Std.IterM.stepAsHetT_filterMapWithPostcondition (a028902ef965f77b66367e310ad367299fa876d6f4d8ce3e15734713f39d16df) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS CategoryTheory.PreOneHypercover.sieve₁_inter (a0c19571a4dbe5924fd473d3f07cc6039e9ec8ea132d3e96917b461db4818ea4) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS retractionKerCotangentToTensorEquivSection._proof_20 (a4fb15377dc50d1f640fc355b336a6412f9b0426de9abf20a917a2a7bcad9097) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Lax.LaxTrans.vComp_naturality_comp (a73219dacca75c2ae3dcd1fad1ad17a03f5e43135428591c1faaa999e1afe2c8) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.variableChange_b₈ (a79576d568fe07158efe1f43e0c1c4824746bc891729104c0ff529452c7fefd0) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.LinearAlgebra.Vandermonde.«0».Matrix.det_projVandermonde_of_field (a9268270fdbe2890e45ef573d3b75e238e4b77090bc38d785fe63a5795a7f0c5) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS mpullback_mulInvariantVectorField (aff85dc73860760a7a7a1ba22c4fc276f01e30ad2c03a43534af4ab91eedff9a) [tiered-tagN]: Lean exhausted [maxCostEvals=1073741824, maxCostEvals=2147483648]; succeeded with [maxCostEvals=4294967296]; bytes equal to Rust + DIAGNOSIS mpullback_mulInvariantVectorField (aff85dc73860760a7a7a1ba22c4fc276f01e30ad2c03a43534af4ab91eedff9a) [uniform-w2]: Lean exhausted [maxCostEvals=1073741824, maxCostEvals=2147483648]; succeeded with [maxCostEvals=4294967296]; bytes equal to Rust + DIAGNOSIS CategoryTheory.GrothendieckTopology.subcanonical_over (b247729636890a6027aa4a09607d23c9b0d13322b26dd823b9917bdb0563cfa4) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS String.firstDiffPos_loop_eq._unary (b454ef896ad0240bf720542824f2db566840628d1fdf1ade4c4ed24f0838dea4) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1 (b6be5c1a4db8c149c47bd94b0f4acb4231b46ecc62bc2a05cd4be985c5950a74) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.dblX_eq' (b9ee47912f596dbaf2375180a79623b227dc6c78a3b9281ad43b1f17bc30b00a) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go_denote_eq._unary (bb5e8c0f8d4e379c065df6dccc7841f1f0cb7bd0094fb2d6e0a92de76a0f117e) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS Ideal.Quotient.stabilizerHom_surjective_of_profinite (c107a718cbecb1de3b4d28e890a0d00e4dd9966b925c5f0f87b5de29638c2f5c) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Limits.colimitLimitToLimitColimit_surjective (c3222710fc60f83889987bc3d9397e478e1be4ed7eb404dae24ee6eb9ca022f9) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.exists_etale_isCompl_of_quasiFiniteAt (c49eed57b9e8f7e0fa7145697db173f14d07e55aa16c130b61bba170f6a45bc5) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.MeasureTheory.Integral.CurveIntegral.Poincare.«0».ContinuousMap.Homotopy.curveIntegral_add_curveIntegral_eq_of_hasFDerivWithinAt_off_countable_real (ce07522299bbd3b14d8dd4db01257925bb7c8c8c600262df528160fb225daf00) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Oplax.LaxTrans.vComp_naturality_comp (d67fa53ab81509443326e759ad6b054fd61c14f5e66c45eedf963f1388c125df) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Mat_.hasFiniteBiproducts (dba35adb0f906c80bfe2f5056330ea0d30871907e8eaf7f3d54b86bd0241d359) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS Std.Iter.toList_intermediateZip_of_finite (dbeb56f1bbc5bd7e90258faa26f1632d8eadcf14de0153b8a47f40409242a6b9) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514063f3b8c9158d9aea80ca6f8be60d1bdcb3c89b6e7a13333) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS Function.Exact.splitInjectiveEquiv._proof_10 (e74bdfa22d2477ae37a67344d30f7301f74dfcc1c1bc01b15c3cff988e34ef55) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS TensorProduct.gradedMul_assoc (ecf0501ad22e32ceb7a4405a89e5a543f835528c1909c5abde71664d0084b3df) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.«0».PeriodPair.analyticAt_relation_zero (efb98e985397cccd854391534530ad3c136bdd080e55ceeada910868093d1b8f) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.StrictlyUnitaryLaxFunctor.ext (efdbdbe0618ebba20c0e864a40c2457349ce96db59f4d9bfd22c88324170b265) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS mpullback_addInvariantVectorField (f2bb780a290bf9d1d4f6231ba18eb6881b1cec5dc7e875cad8443d5982d94c5e) [tiered-tagN]: Lean exhausted [maxCostEvals=1073741824, maxCostEvals=2147483648]; succeeded with [maxCostEvals=4294967296]; bytes equal to Rust + DIAGNOSIS mpullback_addInvariantVectorField (f2bb780a290bf9d1d4f6231ba18eb6881b1cec5dc7e875cad8443d5982d94c5e) [uniform-w2]: Lean exhausted [maxCostEvals=1073741824, maxCostEvals=2147483648]; succeeded with [maxCostEvals=4294967296]; bytes equal to Rust + DIAGNOSIS retractionKerCotangentToTensorEquivSection._proof_19 (f35ae2d9f1e53d362abda6efe67df03aff946fa23efae7a1cb6102587d4cd658) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Algebra.Group.Pi.Lemmas.«0».Pi.single_add_single_eq_single_add_single._proof_1_2 (fa2efaa3a1a2a3ea5e6ae17642bc8127509db2bd2d750a35f3108daebc3106e2) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.c_relation (fcc6866343ed8b0e1bd4a9dd85e90352bc9e172dc0366c339212ef2321779068) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + [corpus progress: 10000/10131] + DIAGNOSIS Matrix.sub_scalar_sq_eq_discr (fef37ae69f3001716f1c0673091eb70f05feca1386aa35f93f4855c1f85964fe) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + [corpus tiered-tagN: 10131 constants; 10032 same bytes, 43 same error category, 56 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 3594984 ms, Rust 427449 ms] + [corpus uniform-w2: 10131 constants; 10082 same bytes, 47 same error category, 2 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 2244764 ms, Rust 174048 ms] + [corpus: decode failures 0; total 12193240 ms] +uncaught exception: process 'lean' exited with code 255 + Elapsed (wall clock) time (h:mm:ss or m:ss): 3:23:14 + Maximum resident set size (kbytes): 4729316 +exit=1 +``` + +
+ +
[D4] Mathlib sample, new search, K-based (*k-bb*) + +`ml_bb_s0.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 42 ms, Rust 3 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 414 ms, Rust 120 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 5065 under [tiered-tagN, uniform-w2]; loaded in 22880 ms] + DIAGNOSIS WeierstrassCurve.variableChange_Δ (0473473f736e639b9211812b686cac21574deb66f2382c1f0cbf4166f7e542c7) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824]; succeeded with [maxMaterialize=2147483648]; bytes equal to Rust + DIAGNOSIS ContinuousMultilinearMap.hasStrictFDerivAt_compContinuousLinearMap (057bc467cdb7583185b00d13e915f514af7be0fb23afc5eb648a60c02bdf766c) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS sum_eight_sq_mul_sum_eight_sq (0bd4b1175ac1d995d92bf0bec451195592d9edf04afe3cee884da42b7b96c766) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Jacobian.negAddY_smul (0c1816c71ee7e564981d9ed82f49b1ab9d2abc7cd378c8b93782be6ed9628548) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Jacobian.negAddY_neg (16256043fdb806ecabbd3e043f8f0debf9826eaddc46e79aafb255f469655143) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS MeasureTheory.hasFDerivAt_convolution_right_with_param (221da52233e80ce3a00f6c08e88563b9f5bc6bd5ecf58711be10e25c6a529233) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual (2b0491741df2ce98fdf1d49103d1d62a34c935f682c5afe6ef8c4d84916ce51d) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824]; succeeded with [maxMaterialize=2147483648]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.Proj.valuativeCriterion_existence_aux (36fd5f58fc5f01ac2095417c31694a35783c1c7f13730d9dfa05c2e004757429) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.RingTheory.Etale.QuasiFinite.«0».Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq' (3d79d639858e7cc1e87be66760c72e5602102ed2ae099344d87ddc48d77d7494) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayer.go._unary.eq_def (4382aa4d3e6b329f7c28bd5362cba003121730be4b8d8177db49a74abd26691d) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS QuaternionAlgebra.instRing._proof_1 (55446000b79f451192f9c5f56b6623ed6ad6d17ab703ab2c1a1bc2b24a0cf670) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.GlueData.ofGlueData'._proof_7 (62166e0ed13f509cd8bf4fefa45f240f8a81ee11fadc1528d4a7f3dc5d142cd8) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Affine.CoordinateRing.XYIdeal_mul_XYIdeal (665f70ff00b204b53d640e57a680266f14339615286866d299612ec5560b770f) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Cubic.discr_eq_prod_three_roots (6a0f9ca821efc5daed4ea38e21ec37f894b62251fa54f0557700e7721ab6df02) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.«0».RootPairing.GeckConstruction.instIsIrreducible_aux₀ (6d67600cf8c031b8c42fd108bf4361076ff70248e9a91a8bd1105d615ee73777) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Topology.Order.WithTop.«0».TopologicalSpace.instSecondCountableTopologyWithTop._proof_3 (828b225acbe466836dca7bf72ce2c1125d3b502ccc7f80e80cbe8c0a40e81374) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux (83b417c6e46f08e27487d87f4529f9c7fdfe204a274e99549522d52940a4ea9b) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.ofJNe0Or1728_Δ (8a2cd7f10b14aee963dd9e952f040b418dd06fab0a3d6798332c2d8032bc01df) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Bicategory.mateEquiv_vcomp (9b20bc429f4cd0385f921ace7d460a81141d4121a5549e30aec57ed50d58713e) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824]; succeeded with [maxMaterialize=2147483648]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.addX_eq' (9cbee9afea050a41bf70cc127ecd5f108a3ba9a9eb83491ff815b26b5137fcd6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Std.IterM.stepAsHetT_filterMapWithPostcondition (a028902ef965f77b66367e310ad367299fa876d6f4d8ce3e15734713f39d16df) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Lax.LaxTrans.vComp_naturality_comp (a73219dacca75c2ae3dcd1fad1ad17a03f5e43135428591c1faaa999e1afe2c8) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.GrothendieckTopology.subcanonical_over (b247729636890a6027aa4a09607d23c9b0d13322b26dd823b9917bdb0563cfa4) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS String.firstDiffPos_loop_eq._unary (b454ef896ad0240bf720542824f2db566840628d1fdf1ade4c4ed24f0838dea4) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_extract._proof_1_1 (b6be5c1a4db8c149c47bd94b0f4acb4231b46ecc62bc2a05cd4be985c5950a74) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.dblX_eq' (b9ee47912f596dbaf2375180a79623b227dc6c78a3b9281ad43b1f17bc30b00a) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go_denote_eq._unary (bb5e8c0f8d4e379c065df6dccc7841f1f0cb7bd0094fb2d6e0a92de76a0f117e) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS Ideal.Quotient.stabilizerHom_surjective_of_profinite (c107a718cbecb1de3b4d28e890a0d00e4dd9966b925c5f0f87b5de29638c2f5c) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Limits.colimitLimitToLimitColimit_surjective (c3222710fc60f83889987bc3d9397e478e1be4ed7eb404dae24ee6eb9ca022f9) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.exists_etale_isCompl_of_quasiFiniteAt (c49eed57b9e8f7e0fa7145697db173f14d07e55aa16c130b61bba170f6a45bc5) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Oplax.LaxTrans.vComp_naturality_comp (d67fa53ab81509443326e759ad6b054fd61c14f5e66c45eedf963f1388c125df) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Mat_.hasFiniteBiproducts (dba35adb0f906c80bfe2f5056330ea0d30871907e8eaf7f3d54b86bd0241d359) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS Std.Iter.toList_intermediateZip_of_finite (dbeb56f1bbc5bd7e90258faa26f1632d8eadcf14de0153b8a47f40409242a6b9) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_append_extract._proof_1_1 (e07ec5807ddd2514063f3b8c9158d9aea80ca6f8be60d1bdcb3c89b6e7a13333) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS Function.Exact.splitInjectiveEquiv._proof_10 (e74bdfa22d2477ae37a67344d30f7301f74dfcc1c1bc01b15c3cff988e34ef55) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.«0».PeriodPair.analyticAt_relation_zero (efb98e985397cccd854391534530ad3c136bdd080e55ceeada910868093d1b8f) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.isHomogeneous_addSubMapCoeff (f2ce788af955876c5915f520ac59f72e473f57fbf3aec0857be7005701b17c22) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS retractionKerCotangentToTensorEquivSection._proof_19 (f35ae2d9f1e53d362abda6efe67df03aff946fa23efae7a1cb6102587d4cd658) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.c_relation (fcc6866343ed8b0e1bd4a9dd85e90352bc9e172dc0366c339212ef2321779068) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + [corpus progress: 5000/5065] + DIAGNOSIS Matrix.sub_scalar_sq_eq_discr (fef37ae69f3001716f1c0673091eb70f05feca1386aa35f93f4855c1f85964fe) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + [corpus tiered-tagN: 5065 constants; 5025 same bytes, 0 same error category, 40 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1363726 ms, Rust 196595 ms] + [corpus uniform-w2: 5065 constants; 5065 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 379225 ms, Rust 22355 ms] + [corpus: decode failures 0; total 5867027 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:37:49 + Maximum resident set size (kbytes): 4704176 +exit=0 +``` + +`ml_bb_s1.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 33 ms, Rust 2 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 344 ms, Rust 97 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 5066 under [tiered-tagN, uniform-w2]; loaded in 23804 ms] + DIAGNOSIS Std.DTreeMap.Internal.Impl.balanceR!_eq_balance! (1601895625b67ecddc59ecf9425ca6eae4c66d6b7c8ea8ce5e4490c3ea338e86) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Int.DivMod.Lemmas.«0».Int.add_one_tdiv._proof_1_1 (194bacb9fee23ecb45a13a8fab2095b3f074dceb7bedb7a1a75f47f3ffe5c73b) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS TopCat.Sheaf.interUnionPullbackConeLift._proof_5 (1f150c14a61c243d759f462e339b7d824e712ee26eb41419aa9f55b98f0de407) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Localization.existsUnique_algebraMap_eq_of_span_eq_top (23ae320acce50ca3d566210d11ac48d17bf7607df1c356a1a709cdfd12f55d33) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.SheafedSpace.IsOpenImmersion.sigma_ι_isOpenImmersion_aux (2dacebaef8b139ded3b4019b96c90d19d0e06a845cff61c2e55763b2a70ded07) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS HomogeneousLocalization.Away.isLocalization_mul (3af1f33ae2a05488ff0ea5dcdd4892be7d1ece5b5190a45cb3f0380b63791e9f) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.mateEquiv_hcomp (3cf47cf160e37479d1bdbab6b5706ee09570afc05cb16222ed5e00aac6e6711a) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.«0».SzemerediRegularity.edgeDensity_star_not_uniform._proof_1_10 (40e45f2eae83609168fb72486797c8757cf07a130636951cc9b786bc23b56fdc) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Std.Iter.atIdxSlow?_intermediateZip (55d247210280f56e60ab88a44a8cafb7977eb557fd8790c52fec53286049d547) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_add_left._proof_1 (5a362f9e99724cbf1e4dc40216ab8c45c0629e8394bc419dc3ce03a689ca4173) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.AlgebraicGeometry.EllipticCurve.IsomOfJ.«0».WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three (67e377956e9a5e65fa8a97da8775eb1f9fe0ff8f7bc6aed75111cd4b17a34636) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.«0».ChevalleyThm.PolynomialC.induction_aux (6b75b2b24c2e310aa9ab5110fc9691b4b25818071fcff2019dbc13f2f5390377) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.negDblY_smul (7d2f95bea351a5d580a875a71037d19875cde0936727c2dd3f5f1b8d41c7a9e7) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_extract._proof_1 (89ed0e98891415751b5d901324eb6eece9183078959dd60430cb17bc64d44d79) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS Int.mul_mem_zero_one_two_three_four_iff (8c33c9187f0005395edd2569203d8cd530fa3792eb9fe66cf4fee100411c612a) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.exists_appTop_π_eq_of_isLimit (92454eb0dbd050541a59931f3e202130028143a7c217a88bd98601e4f56d3eb7) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS Matrix.adjugate_fin_three (a55d6767308a54cc15ec6211709a0d1a53fc495cf399885ea6532c6788600efa) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Affine.addPolynomial_slope (b6a5154a781629bb1beb70715e2f9792a918d9c54f5d5c3d4dfae9d5eeac67e9) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.SurjectiveOnStalks.isEmbedding_pullback (bc547eefd4fd84f0992166f05140d4bc221cee0bbc84096c4d036a712e197361) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (bd34cbe632ec9a56a33fd7bb51e23fef8fadb90d7ae3af8216921776ed84bff7) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824, maxMaterialize=2147483648]; succeeded with [maxMaterialize=4294967296]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.isSheaf_type_propQCTopology_iff (c1a56567a54a70cbf0999232c590bb896c7544cd7678151801e236cd9ed6be37) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_append._proof_1 (d126ef57b21ab268daf3d9cb8faef5455e330eb505556ef14924e8d9cbec2fd9) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS TopCat.subcanonical_grothendieckTopology (d216753fba4438d45cf79762178e94f4308da7809083d3392b6cdd369d177ea2) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS MeasureTheory.VectorMeasure.variation_withDensity' (d5ea2d6fbb4ca2a2dd2a75ef68b1768bb780fbab0c85aab6a97254d2d6709738) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Real.log_five_near_10 (da962aa5afcd9ef1d6f68919543b2a4f56ed97fb113cd9a101f964de681bacd6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CartanMatrix.E₈_det (df85f966e9848e272be9df5ad9e86542a31c5ffd53b2ed63ac8885b9a12ffd64) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.«0».PeriodPair.iteratedDeriv_six_relation_mul_id_pow_six (ee4f82100489a77cf78a4c542d89541d94630ea17ff1700f3cd242fea32ad3da) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Vector.Extract.«0».Vector.extract_append_extract._proof_1 (eed90987192d51608f220fd7d7ed664c9c87c132401a2e87a4912cc177e4e941) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + [corpus progress: 5000/5066] + [corpus tiered-tagN: 5066 constants; 5038 same bytes, 0 same error category, 28 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1267778 ms, Rust 173843 ms] + [corpus uniform-w2: 5066 constants; 5066 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 333795 ms, Rust 22299 ms] + [corpus: decode failures 0; total 4825471 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:20:27 + Maximum resident set size (kbytes): 4717480 +exit=0 +``` + +`ml_bb_s2.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 33 ms, Rust 2 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 335 ms, Rust 95 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 5066 under [tiered-tagN, uniform-w2]; loaded in 23498 ms] + DIAGNOSIS WeierstrassCurve.addSubMapCoeff_condition (02ae6cb3f3ccb488fbfed20bf778afdf8f835339dc34fbad5538c6a266643fc4) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS groupCohomology.H1InfRes_exact (076a4a5d72838673c8b1a235fff84767e47060fe8641e355be2c3c68fbf3fd7a) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop.«0».Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastCpopLayer.go._unary (0f75bea9d5dd4591a6f321934e261404b9a8548358d528223bf692a33527d74b) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS Algebra.WeaklyQuasiFiniteAt.of_quasiFiniteAt_residueField (1817bbc31c531206f258dd78757e193fe5357451872bb99278d6b46ff8ff6db3) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.isIso_pushoutSection_of_iSup_eq (2d33bfe7c13b87fd41641f9f2fa67e9324fdb71f8a8a3bac49eb3212bfead8e3) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.negDblY_eq' (37cd1c7638fa9899f80d12762241905e5858b0abbf3a9380e8efd93299d3edf5) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912]; succeeded with [maxMaterialize=1073741824]; bytes equal to Rust + DIAGNOSIS Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ (4838899f29ca9e49b6cba1126be0d7b721d4cae4f8876ed81d25620e9b0dacb5) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective (4ece542b15e7b7a1cfeccea61d88b4a5d5aa477eb8d8938135f7458d8e353e45) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824]; succeeded with [maxMaterialize=2147483648]; bytes equal to Rust + DIAGNOSIS groupHomology.H1CoresCoinf_exact (6cc20762d74eb85e981ae78103c561f0be13b11ae5cf5b02ca1bf76794455b3e) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Algebra.Group.Pi.Lemmas.«0».Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle._proof_1_2 (8466008af12aab87e42a21847e9d9e7d8d05f5baf1a65ec4c8e9cfb4e89e6717) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.AlgebraicGeometry.AffineTransitionLimit.«0».AlgebraicGeometry.Scheme.exists_π_app_comp_eq_of_locallyOfFinitePresentation_of_isAffine (8db8dbcb6033f83c3e6e02db5f18b9efd78d24cfa41a6ad9ca3bb8c6192e6e19) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.instMulActionVariableChange._proof_1 (904073d4c5010184f89d49609e09059722b112294deed7930de71b63ee1fcdd3) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS CategoryTheory.PreOneHypercover.sieve₁_inter (a0c19571a4dbe5924fd473d3f07cc6039e9ec8ea132d3e96917b461db4818ea4) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS retractionKerCotangentToTensorEquivSection._proof_20 (a4fb15377dc50d1f640fc355b336a6412f9b0426de9abf20a917a2a7bcad9097) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.variableChange_b₈ (a79576d568fe07158efe1f43e0c1c4824746bc891729104c0ff529452c7fefd0) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.LinearAlgebra.Vandermonde.«0».Matrix.det_projVandermonde_of_field (a9268270fdbe2890e45ef573d3b75e238e4b77090bc38d785fe63a5795a7f0c5) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.MeasureTheory.Integral.CurveIntegral.Poincare.«0».ContinuousMap.Homotopy.curveIntegral_add_curveIntegral_eq_of_hasFDerivWithinAt_off_countable_real (ce07522299bbd3b14d8dd4db01257925bb7c8c8c600262df528160fb225daf00) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.Scheme.Hom.instIsIsoNormalizationPullbackOfSmooth (daa5d7f02cabe4d9d5ff0cf36901ffcc83fb5705605624c1c64c7b0e7a547d0b) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS TensorProduct.gradedMul_assoc (ecf0501ad22e32ceb7a4405a89e5a543f835528c1909c5abde71664d0084b3df) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.StrictlyUnitaryLaxFunctor.ext (efdbdbe0618ebba20c0e864a40c2457349ce96db59f4d9bfd22c88324170b265) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Polynomial.discr_of_degree_eq_three (f2e292bc76352c3382f2c4bbd6c0228cf74640f1c7966cd09480232d620748e1) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.Algebra.Group.Pi.Lemmas.«0».Pi.single_add_single_eq_single_add_single._proof_1_2 (fa2efaa3a1a2a3ea5e6ae17642bc8127509db2bd2d750a35f3108daebc3106e2) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + [corpus progress: 5000/5066] + [corpus tiered-tagN: 5066 constants; 5044 same bytes, 0 same error category, 22 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1191836 ms, Rust 165258 ms] + [corpus uniform-w2: 5066 constants; 5066 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 320130 ms, Rust 21828 ms] + [corpus: decode failures 0; total 3713030 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:01:54 + Maximum resident set size (kbytes): 4716612 +exit=0 +``` + +`ml_bb_s3.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 48 ms, Rust 3 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 517 ms, Rust 136 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 5066 under [tiered-tagN, uniform-w2]; loaded in 22773 ms] + DIAGNOSIS _private.Init.Data.Nat.ToString.«0».Nat.digitChar_iff_aux (0691b3f1e8c36b6ba49eb789ca815ff0583eb48dc4c46886aadb190fe43be2f6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.negAddY_neg (14f75d2691415463319f5dfce1f3668d59f07ffde9b7aad7c8b0169f407f22ba) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.«0».RootPairing.EmbeddedG2.isOrthogonal_short_and_long_aux._proof_1_1 (159e2b0d36d95a7feefe9a1f39b7e65da56802a29e83fe00e567d5b963506ede) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456, maxMaterialize=536870912, maxMaterialize=1073741824]; succeeded with [maxMaterialize=2147483648]; bytes equal to Rust + DIAGNOSIS Module.reflection_mul_reflection_pow_apply (15b19b23c225d5d472221aea61b5cbe4166b359b0126b53a54669fa41cc8fbfc) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS Std.Tactic.BVDecide.BVExpr.bitblast.goCache_decl_eq._mutual (1f13644c31ee2c19d333220bd3c0147bd65cb5ae77e4429b76ed3fa46de073e2) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite (248b4aa033342acd791b861a9d0f8303a02c7f034e05a26eb8c5f4b087cc7e26) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS ModularForm.discriminant_T_invariant (28d6ee3847c930ae436f8ebc21fa67e03d783d95582be3871bccc5b249d01466) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.Scheme.IsLocallyDirected.glueData._proof_6 (338ca448f75e9c25258b64f2a325fac0899b8f347360454e8ecfe7bf7b72ccf7) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.associator_naturality (373b0d8e1af7fe3a1218e5b0f3e7df6c1aa2ad9d2f742ee6460b7f703e0e8e6c) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS mem_adjoin_map_integralClosure_of_isStandardEtale (3f383549903f2a37fed9f5d95b0324b680883ee6286b5cfeef222dcdeb91ecc2) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CategoryTheory.NatTrans.instIsClosedUnderLimitsOfShapeOverFunctorEquifiberedHomOfHasCoproductsOfShapeHom (4b3beb75cfb6da5466c4d9e4e1f23a364c4c16d56ae9be83aa14cbd19a472a47) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.dblX_smul (55c2d089702c5ef0842325387b5a2ebd34da6eadc46291b29ce198ccd89a791f) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.mono_pushoutSection_of_iSup_eq (5e122ca4869d76508a277442ec2a139158921d8628f607367032e3495bffacd5) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.go_denote_eq._unary (68f6e583c732c5f3c079ab3a315711d6b6cba09ffc8dd5b27bf618e251c3d4e6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS CartanMatrix.E₇_det (6eb6aa5f6e5cc2b4d7606d8d544a3dc26d50e664bb81f852ef3225f88bddc7e4) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS SSet.StrictSegal.isPointwiseRightKanExtensionAt.fac_aux₂ (9fa5347780bca67caeaeb1f8a08ecc9257132be804ea62495a68113699479aba) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.«0».String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList (a400ea3f99ba806af97e4b133d9d54fb55d3b46d23e0369d83fdd811284302e6) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS AlgebraicGeometry.Scheme.exists_π_app_comp_eq_of_locallyOfFinitePresentation (ae6266c2b1b35cb5d6b366f958c6ee2ec5d8e2fd577f6b401d82f59843d22004) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Bicategory.mateEquiv_hcomp (b201fe77a69f2111a0e3d3776b9ddda429506ebc08608e6307f867bcd69843cc) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728, maxMaterialize=268435456]; succeeded with [maxMaterialize=536870912]; bytes equal to Rust + DIAGNOSIS Polynomial.discr_of_degree_eq_two (b2338e6157a26a6a907b37fac1a17cef48ec00184a8015af626661c32a33eafb) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS CategoryTheory.Lax.OplaxTrans.vComp_naturality_comp (c44c23e5d81a327b0388fb796eeb56d5b68a6d00d71ff74d8e3215088e23ab63) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Affine.CoordinateRing.XYIdeal_neg_mul (c4641901bb3705423856ac01d337794b1d1096a11d0dc76975389aab6a5b1e99) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.RingTheory.Polynomial.Resultant.Basic.«0».Polynomial.sylvesterDeriv_of_natDegree_eq_three (cabce28d54f8e662e07494ef43a9f00d5bbc4dfefb7ac95b581dcc378a6771fe) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS WeierstrassCurve.Projective.negAddY_eq' (d5ec80e0cce67eb9081abe1075d2940312017829abc9807ceebd32d4222b9b53) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq (d86a5b2a6aef9f5659a894d980fde30a535ed86961a806202ad6bc342eeff25c) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS CartanMatrix.E₆_det (d9660e5a43a0a0fb78097d2a4e562ac8897e887f60abed2bb3f1f3afc70b5f18) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS Height.mulHeight_sym2_ge (dd9af4585ab3281fd2ae1e46887063a1fcf2d4103b57dff4a7134f89e2d9d159) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + DIAGNOSIS _private.Mathlib.RingTheory.Etale.QuasiFinite.«0».Algebra.exists_etale_completeOrthogonalIdempotents_forall_liesOver_eq.match_1_1 (dfd42dc5d9b404a98882ab7c615ff22954c63fbbe353aa4ca8ad1d2a1bce1c77) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + DIAGNOSIS _private.Init.Data.Array.Extract.«0».Array.extract_append._proof_1_1 (e852d49c2b3a2ea71d1036e9a19406c99f5db76288c568bceb90e40c939ebfec) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864, maxMaterialize=134217728]; succeeded with [maxMaterialize=268435456]; bytes equal to Rust + [corpus progress: 5000/5066] + DIAGNOSIS StarAlgEquiv.eq_linearIsometryEquivConjStarAlgEquiv (fdf8644d47f8b068caf56ed87249a924df39afe7abe973d8b458c869639d3c38) [tiered-tagN]: Lean exhausted [maxMaterialize=67108864]; succeeded with [maxMaterialize=134217728]; bytes equal to Rust + [corpus tiered-tagN: 5066 constants; 5036 same bytes, 0 same error category, 30 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1269207 ms, Rust 167713 ms] + [corpus uniform-w2: 5066 constants; 5066 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 346656 ms, Rust 22847 ms] + [corpus: decode failures 0; total 3796550 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:03:18 + Maximum resident set size (kbytes): 4705116 +exit=0 +``` + +
+ +
[D5] Lean-only constants at *work-limit*, K-based + +`lo_s0.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 69 ms, Rust 4 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 844 ms, Rust 201 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 30 under [tiered-tagN]; loaded in 20540 ms] + [corpus tiered-tagN: 30 constants; 30 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 967287 ms, Rust 47357 ms] + [corpus: decode failures 0; total 1036586 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 17:19.79 + Maximum resident set size (kbytes): 4732112 +exit=0 +``` + +`lo_s1.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 91 ms, Rust 4 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 709 ms, Rust 163 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 30 under [tiered-tagN]; loaded in 19930 ms] + [corpus tiered-tagN: 30 constants; 30 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1198201 ms, Rust 58739 ms] + [corpus: decode failures 0; total 1278450 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 21:21.33 + Maximum resident set size (kbytes): 4735896 +exit=0 +``` + +`lo_s2.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 113 ms, Rust 7 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 861 ms, Rust 246 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 30 under [tiered-tagN]; loaded in 20624 ms] + [corpus tiered-tagN: 30 constants; 30 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1602130 ms, Rust 91515 ms] + [corpus: decode failures 0; total 1715786 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 28:39.03 + Maximum resident set size (kbytes): 4733240 +exit=0 +``` + +`lo_s3.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 103 ms, Rust 6 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 990 ms, Rust 247 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 30 under [tiered-tagN]; loaded in 18584 ms] + [corpus tiered-tagN: 30 constants; 30 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1361105 ms, Rust 60011 ms] + [corpus: decode failures 0; total 1441288 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 24:04.55 + Maximum resident set size (kbytes): 4735536 +exit=0 +``` + +`lo_init.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 105 ms, Rust 6 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1095 ms, Rust 275 ms + [corpus: $S/init.ixe, 56622 constants, comparing 10 under [tiered-tagN, tiered-tag4]; loaded in 1303 ms] + [corpus tiered-tagN: 10 constants; 10 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 300271 ms, Rust 12945 ms] + [corpus tiered-tag4: 10 constants; 10 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 244009 ms, Rust 14012 ms] + [corpus: decode failures 0; total 572790 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 9:36.24 + Maximum resident set size (kbytes): 838408 +exit=0 +``` + +
+ +
[D6] Mathlib, all constants, K-based: the 3 completed address shards, then the 3 empty logs (*work-limit*) + +`lf_s0.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 183 ms, Rust 21 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 609 ms, Rust 172 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 113249 under [tiered-tagN]; loaded in 9841 ms] + [corpus progress: 5000/113249] + [corpus progress: 10000/113249] + [corpus progress: 15000/113249] + [corpus progress: 20000/113249] + [corpus progress: 25000/113249] + [corpus progress: 30000/113249] + [corpus progress: 35000/113249] + [corpus progress: 40000/113249] + [corpus progress: 45000/113249] + [corpus progress: 50000/113249] + [corpus progress: 55000/113249] + [corpus progress: 60000/113249] + [corpus progress: 65000/113249] + [corpus progress: 70000/113249] + [corpus progress: 75000/113249] + [corpus progress: 80000/113249] + [corpus progress: 85000/113249] + [corpus progress: 90000/113249] + [corpus progress: 95000/113249] + [corpus progress: 100000/113249] + [corpus progress: 105000/113249] + [corpus progress: 110000/113249] + [corpus tiered-tagN: 113249 constants; 113249 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 2894778 ms, Rust 366979 ms] + [corpus: decode failures 0; total 3299727 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 55:02.90 + Maximum resident set size (kbytes): 4725640 +exit=0 +``` + +`lf_s3.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 136 ms, Rust 8 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 710 ms, Rust 191 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 113250 under [tiered-tagN]; loaded in 10888 ms] + [corpus progress: 5000/113250] + [corpus progress: 10000/113250] + [corpus progress: 15000/113250] + [corpus progress: 20000/113250] + [corpus progress: 25000/113250] + [corpus progress: 30000/113250] + [corpus progress: 35000/113250] + [corpus progress: 40000/113250] + [corpus progress: 45000/113250] + [corpus progress: 50000/113250] + [corpus progress: 55000/113250] + [corpus progress: 60000/113250] + [corpus progress: 65000/113250] + [corpus progress: 70000/113250] + [corpus progress: 75000/113250] + [corpus progress: 80000/113250] + [corpus progress: 85000/113250] + [corpus progress: 90000/113250] + [corpus progress: 95000/113250] + [corpus progress: 100000/113250] + [corpus progress: 105000/113250] + [corpus progress: 110000/113250] + [corpus tiered-tagN: 113250 constants; 113250 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 2878724 ms, Rust 361923 ms] + [corpus: decode failures 0; total 3276713 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 54:40.01 + Maximum resident set size (kbytes): 4724964 +exit=0 +``` + +`lf_s4.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 166 ms, Rust 14 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 605 ms, Rust 163 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 113250 under [tiered-tagN]; loaded in 11094 ms] + [corpus progress: 5000/113250] + [corpus progress: 10000/113250] + [corpus progress: 15000/113250] + [corpus progress: 20000/113250] + [corpus progress: 25000/113250] + [corpus progress: 30000/113250] + [corpus progress: 35000/113250] + [corpus progress: 40000/113250] + [corpus progress: 45000/113250] + [corpus progress: 50000/113250] + [corpus progress: 55000/113250] + [corpus progress: 60000/113250] + [corpus progress: 65000/113250] + [corpus progress: 70000/113250] + [corpus progress: 75000/113250] + [corpus progress: 80000/113250] + [corpus progress: 85000/113250] + [corpus progress: 90000/113250] + [corpus progress: 95000/113250] + [corpus progress: 100000/113250] + [corpus progress: 105000/113250] + [corpus progress: 110000/113250] + [corpus tiered-tagN: 113250 constants; 113250 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 2789452 ms, Rust 362141 ms] + [corpus: decode failures 0; total 3188208 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 53:11.58 + Maximum resident set size (kbytes): 4731392 +exit=0 +``` + +`lf_s1.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 148 ms, Rust 8 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 599 ms, Rust 153 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 113250 under [tiered-tagN]; loaded in 10395 ms] + [corpus progress: 5000/113250] + [corpus progress: 10000/113250] + [corpus progress: 15000/113250] + [corpus progress: 20000/113250] + [corpus progress: 25000/113250] + [corpus progress: 30000/113250] + [corpus progress: 35000/113250] + [corpus progress: 40000/113250] + [corpus progress: 45000/113250] + [corpus progress: 50000/113250] + [corpus progress: 55000/113250] + [corpus progress: 60000/113250] + [corpus progress: 65000/113250] + [corpus progress: 70000/113250] + [corpus progress: 75000/113250] + [corpus progress: 80000/113250] + [corpus progress: 85000/113250] + [corpus progress: 90000/113250] + [corpus progress: 95000/113250] + [corpus progress: 100000/113250] + [corpus progress: 105000/113250] + [corpus progress: 110000/113250] + [corpus tiered-tagN: 113250 constants; 113250 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 3253186 ms, Rust 362555 ms] + [corpus: decode failures 0; total 3652456 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:00:55 + Maximum resident set size (kbytes): 4726056 +exit=0 +``` + +`lf_s2.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 138 ms, Rust 7 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 569 ms, Rust 163 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 113250 under [tiered-tagN]; loaded in 10272 ms] + [corpus progress: 5000/113250] + [corpus progress: 10000/113250] + [corpus progress: 15000/113250] + [corpus progress: 20000/113250] + [corpus progress: 25000/113250] + [corpus progress: 30000/113250] + [corpus progress: 35000/113250] + [corpus progress: 40000/113250] + [corpus progress: 45000/113250] + [corpus progress: 50000/113250] + [corpus progress: 55000/113250] + [corpus progress: 60000/113250] + [corpus progress: 65000/113250] + [corpus progress: 70000/113250] + [corpus progress: 75000/113250] + [corpus progress: 80000/113250] + [corpus progress: 85000/113250] + [corpus progress: 90000/113250] + [corpus progress: 95000/113250] + [corpus progress: 100000/113250] + [corpus progress: 105000/113250] + [corpus progress: 110000/113250] + [corpus tiered-tagN: 113250 constants; 113250 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 3822533 ms, Rust 385390 ms] + [corpus: decode failures 0; total 4247937 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:10:52 + Maximum resident set size (kbytes): 4731444 +exit=0 +``` + +`lf_s5.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 194 ms, Rust 10 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 640 ms, Rust 173 ms + [corpus: $S/mathlib.ixe, 679499 constants, comparing 113250 under [tiered-tagN]; loaded in 10619 ms] + [corpus progress: 5000/113250] + [corpus progress: 10000/113250] + [corpus progress: 15000/113250] + [corpus progress: 20000/113250] + [corpus progress: 25000/113250] + [corpus progress: 30000/113250] + [corpus progress: 35000/113250] + [corpus progress: 40000/113250] + [corpus progress: 45000/113250] + [corpus progress: 50000/113250] + [corpus progress: 55000/113250] + [corpus progress: 60000/113250] + [corpus progress: 65000/113250] + [corpus progress: 70000/113250] + [corpus progress: 75000/113250] + [corpus progress: 80000/113250] + [corpus progress: 85000/113250] + [corpus progress: 90000/113250] + [corpus progress: 95000/113250] + [corpus progress: 100000/113250] + [corpus progress: 105000/113250] + [corpus progress: 110000/113250] + [corpus tiered-tagN: 113250 constants; 113250 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 3089915 ms, Rust 375400 ms] + [corpus: decode failures 0; total 3504034 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 58:28.78 + Maximum resident set size (kbytes): 4731024 +exit=0 +``` + +
+ +
[D7] Init, all constants, best of three, tiered-TagN and tiered-Tag4 (*b3-rust*) + +`b3_init_s0.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 58 ms, Rust 7 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 763 ms, Rust 273 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 821 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1154355 ms, Rust 64204 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1031664 ms, Rust 66100 ms] + [corpus: decode failures 0; total 2318668 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 38:41.36 + Maximum resident set size (kbytes): 829404 +exit=0 +``` + +`b3_init_s1.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 94 ms, Rust 8 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 874 ms, Rust 234 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 771 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 979395 ms, Rust 73444 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 943637 ms, Rust 77043 ms] + [corpus: decode failures 0; total 2076188 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 34:39.14 + Maximum resident set size (kbytes): 829212 +exit=0 +``` + +`b3_init_s2.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 70 ms, Rust 6 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 856 ms, Rust 228 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 744 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 828231 ms, Rust 59517 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 728887 ms, Rust 59856 ms] + [corpus: decode failures 0; total 1679117 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 28:02.61 + Maximum resident set size (kbytes): 829400 +exit=0 +``` + +`b3_init_s3.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 107 ms, Rust 9 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1445 ms, Rust 452 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 728 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 984823 ms, Rust 67224 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 753423 ms, Rust 61405 ms] + [corpus: decode failures 0; total 1869504 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 31:13.17 + Maximum resident set size (kbytes): 829636 +exit=0 +``` + +`b3_init_s4.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 98 ms, Rust 8 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 865 ms, Rust 233 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 681 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 810440 ms, Rust 62008 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 711211 ms, Rust 65741 ms] + [corpus: decode failures 0; total 1652224 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 27:35.69 + Maximum resident set size (kbytes): 829624 +exit=0 +``` + +`b3_init_s5.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 88 ms, Rust 7 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1734 ms, Rust 562 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 2079 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 657967 ms, Rust 55090 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 588550 ms, Rust 54413 ms] + [corpus: decode failures 0; total 1359924 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 22:45.38 + Maximum resident set size (kbytes): 824832 +exit=0 +``` + +
+ +
[D8] Mathlib sample, best of three, tiered-TagN and tiered-Tag4 (*b3-rust*), aborted + +`b3_ml_s0.log` + +```text +Command terminated by signal 15 + Elapsed (wall clock) time (h:mm:ss or m:ss): 2:04:57 + Maximum resident set size (kbytes): 4731672 +exit=143 +``` + +`b3_ml_s1.log` + +```text +Command terminated by signal 15 + Elapsed (wall clock) time (h:mm:ss or m:ss): 2:04:55 + Maximum resident set size (kbytes): 4722932 +exit=143 +``` + +`b3_ml_s2.log` + +```text +Command terminated by signal 15 + Elapsed (wall clock) time (h:mm:ss or m:ss): 2:04:53 + Maximum resident set size (kbytes): 4730560 +exit=143 +``` + +`b3_ml_s3.log` + +```text +Command terminated by signal 15 + Elapsed (wall clock) time (h:mm:ss or m:ss): 2:04:51 + Maximum resident set size (kbytes): 4723700 +exit=143 +``` + +
+ +
[D9] Init, all constants, best of three with the Kahn order, tiered-TagN and tiered-Tag4 (*kahn*) + +`init_s0.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 51 ms, Rust 4 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1337 ms, Rust 380 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 1154 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 726305 ms, Rust 72934 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 677491 ms, Rust 74282 ms] + [corpus: decode failures 0; total 1554083 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 25:59.56 + Maximum resident set size (kbytes): 839284 +exit=0 +``` + +`init_s1.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 154 ms, Rust 23 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1708 ms, Rust 532 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 1651 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 608095 ms, Rust 70073 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 561240 ms, Rust 69960 ms] + [corpus: decode failures 0; total 1312886 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 22:00.12 + Maximum resident set size (kbytes): 839524 +exit=0 +``` + +`init_s2.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 149 ms, Rust 15 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1683 ms, Rust 578 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 1385 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 414956 ms, Rust 54172 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 411295 ms, Rust 50736 ms] + [corpus: decode failures 0; total 934376 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 15:40.65 + Maximum resident set size (kbytes): 839728 +exit=0 +``` + +`init_s3.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 92 ms, Rust 7 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1566 ms, Rust 504 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 1765 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 500682 ms, Rust 56514 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 475709 ms, Rust 58928 ms] + [corpus: decode failures 0; total 1095511 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 18:21.04 + Maximum resident set size (kbytes): 839008 +exit=0 +``` + +`init_s4.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 252 ms, Rust 25 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1803 ms, Rust 568 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 1248 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 423984 ms, Rust 55817 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 421238 ms, Rust 53568 ms] + [corpus: decode failures 0; total 957750 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 16:03.75 + Maximum resident set size (kbytes): 839684 +exit=0 +``` + +`init_s5.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tag4, tiered-tagN]: 89 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 80 ms, Rust 6 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2398 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1689 ms, Rust 530 ms + [corpus: $S/init.ixe, 56622 constants, comparing 9437 under [tiered-tagN, tiered-tag4]; loaded in 1334 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 371574 ms, Rust 50714 ms] + [corpus tiered-tag4: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 360497 ms, Rust 53412 ms] + [corpus: decode failures 0; total 839322 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 14:05.79 + Maximum resident set size (kbytes): 838816 +exit=0 +``` + +
+ +
[D10] v4 Init corpus, all constants, tiered-TagN (*six-rung*) + +`init_s0.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 116 ms, Rust 5 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 889 ms, Rust 187 ms + [corpus: $S/init_v4r_six_rung.ixe, 56622 constants, comparing 9437 under [tiered-tagN]; loaded in 874 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 718281 ms, Rust 60459 ms] + [corpus: decode failures 0; total 782552 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 13:06.24 + Maximum resident set size (kbytes): 839520 +exit=0 +``` + +`init_s1.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 165 ms, Rust 5 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1343 ms, Rust 325 ms + [corpus: $S/init_v4r_six_rung.ixe, 56622 constants, comparing 9437 under [tiered-tagN]; loaded in 830 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 620439 ms, Rust 63470 ms] + [corpus: decode failures 0; total 688022 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 11:33.34 + Maximum resident set size (kbytes): 839156 +exit=0 +``` + +`init_s2.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 145 ms, Rust 5 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1131 ms, Rust 247 ms + [corpus: $S/init_v4r_six_rung.ixe, 56622 constants, comparing 9437 under [tiered-tagN]; loaded in 661 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 503446 ms, Rust 51849 ms] + [corpus: decode failures 0; total 558610 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 9:22.59 + Maximum resident set size (kbytes): 839200 +exit=0 +``` + +`init_s3.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 116 ms, Rust 5 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1271 ms, Rust 264 ms + [corpus: $S/init_v4r_six_rung.ixe, 56622 constants, comparing 9437 under [tiered-tagN]; loaded in 906 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 682788 ms, Rust 67449 ms] + [corpus: decode failures 0; total 754759 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 12:39.03 + Maximum resident set size (kbytes): 839584 +exit=0 +``` + +`init_s4.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 155 ms, Rust 9 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1247 ms, Rust 275 ms + [corpus: $S/init_v4r_six_rung.ixe, 56622 constants, comparing 9437 under [tiered-tagN]; loaded in 1262 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 363005 ms, Rust 49208 ms] + [corpus: decode failures 0; total 416363 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 7:04.05 + Maximum resident set size (kbytes): 839052 +exit=0 +``` + +`init_s5.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 242 ms, Rust 8 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1852 ms, Rust 353 ms + [corpus: $S/init_v4r_six_rung.ixe, 56622 constants, comparing 9437 under [tiered-tagN]; loaded in 1039 ms] + [corpus progress: 5000/9437] + [corpus tiered-tagN: 9437 constants; 9437 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 550026 ms, Rust 57611 ms] + [corpus: decode failures 0; total 611339 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 10:20.57 + Maximum resident set size (kbytes): 839284 +exit=0 +``` + +
+ +
[D11] v4 Mathlib sample, tiered-TagN (*six-rung*) + +`ml_s0.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 169 ms, Rust 7 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1120 ms, Rust 265 ms + [corpus: $S/mathlib_v4r_six_rung.ixe, 679499 constants, comparing 2533 under [tiered-tagN]; loaded in 13779 ms] + [corpus tiered-tagN: 2533 constants; 2533 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 3372948 ms, Rust 313156 ms] + [corpus: decode failures 0; total 3709009 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:01:52 + Maximum resident set size (kbytes): 4014096 +exit=0 +``` + +`ml_s1.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 129 ms, Rust 6 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1310 ms, Rust 326 ms + [corpus: $S/mathlib_v4r_six_rung.ixe, 679499 constants, comparing 2534 under [tiered-tagN]; loaded in 13378 ms] + [corpus tiered-tagN: 2534 constants; 2534 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 4178724 ms, Rust 328739 ms] + [corpus: decode failures 0; total 4532338 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:15:36 + Maximum resident set size (kbytes): 4013832 +exit=0 +``` + +`ml_s2.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 133 ms, Rust 7 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1179 ms, Rust 300 ms + [corpus: $S/mathlib_v4r_six_rung.ixe, 679499 constants, comparing 2533 under [tiered-tagN]; loaded in 15778 ms] + [corpus tiered-tagN: 2533 constants; 2533 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 4160060 ms, Rust 315849 ms] + [corpus: decode failures 0; total 4502713 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:15:06 + Maximum resident set size (kbytes): 4010636 +exit=0 +``` + +`ml_s3.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 158 ms, Rust 9 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1077 ms, Rust 225 ms + [corpus: $S/mathlib_v4r_six_rung.ixe, 679499 constants, comparing 2533 under [tiered-tagN]; loaded in 14888 ms] + [corpus tiered-tagN: 2533 constants; 2533 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 4823239 ms, Rust 340491 ms] + [corpus: decode failures 0; total 5188350 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:26:31 + Maximum resident set size (kbytes): 4005344 +exit=0 +``` + +`ml_s4.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 118 ms, Rust 6 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1014 ms, Rust 230 ms + [corpus: $S/mathlib_v4r_six_rung.ixe, 679499 constants, comparing 2533 under [tiered-tagN]; loaded in 17410 ms] + [corpus tiered-tagN: 2533 constants; 2533 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 4467566 ms, Rust 358723 ms] + [corpus: decode failures 0; total 4852768 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:20:56 + Maximum resident set size (kbytes): 4003724 +exit=0 +``` + +`ml_s5.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 122 ms, Rust 39 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1007 ms, Rust 241 ms + [corpus: $S/mathlib_v4r_six_rung.ixe, 679499 constants, comparing 2533 under [tiered-tagN]; loaded in 17326 ms] + [corpus tiered-tagN: 2533 constants; 2533 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 4821142 ms, Rust 353157 ms] + [corpus: decode failures 0; total 5199302 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:26:43 + Maximum resident set size (kbytes): 4006108 +exit=0 +``` + +`ml_s6.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 211 ms, Rust 8 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 944 ms, Rust 198 ms + [corpus: $S/mathlib_v4r_six_rung.ixe, 679499 constants, comparing 2533 under [tiered-tagN]; loaded in 13571 ms] + [corpus tiered-tagN: 2533 constants; 2532 same bytes, 1 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 5610089 ms, Rust 366112 ms] + NOTE CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite (ca5b91d86331eb4a78896d3a3d6507d595c1fe23606596e426a34ef83bbe33d3): both resource + [corpus: decode failures 0; total 5997624 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:40:01 + Maximum resident set size (kbytes): 4012144 +exit=0 +``` + +`ml_s7.log` + +```text + §2 fixtures × [exact, uniform-w1, uniform-w2, uniform-w3, uniform-w5, tiered-tagN]: 76 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 144 ms, Rust 9 ms + 350 generated inputs (prefixes, 2-byte payloads, pairs, chains, heavy parents, general) × modes: 2048 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 1146 ms, Rust 280 ms + [corpus: $S/mathlib_v4r_six_rung.ixe, 679499 constants, comparing 2533 under [tiered-tagN]; loaded in 15357 ms] + [corpus tiered-tagN: 2533 constants; 2533 same bytes, 0 same error category, 0 Lean-only and 0 Rust-only resource exhaustion, 0 disagreements; Lean 4060627 ms, Rust 311506 ms] + [corpus: decode failures 0; total 4394967 ms] + Elapsed (wall clock) time (h:mm:ss or m:ss): 1:13:19 + Maximum resident set size (kbytes): 4009940 +exit=0 +``` + +
+ diff --git a/docs/sharing-minimum.md b/docs/sharing-minimum.md new file mode 100644 index 000000000..3ca286f51 --- /dev/null +++ b/docs/sharing-minimum.md @@ -0,0 +1,1122 @@ +# Implement canonical minimum sharing in Ix + +> **Status: implemented, with the target revised (§12).** §1–§10 are the original plan. Its +> target, the global byte minimum under the key of §3.3, was found infeasible at production +> scale (§12.1) and is **superseded** by the decisions of §12 wherever the two differ. Read §12 +> first. What was built: +> +> - **Construction.** `Ix.Sharing.Exact.canonicalSharingTiered .tagN` (Lean +> `Ix/Sharing/Exact/Tiered.lean`, Rust `crates/ixon/src/sharing_exact/tiered.rs`). Phase 1 is +> the exact minimum of the uniform-width model at each width `w ∈ {1, 2, 3}` (§12.3, §12.11). +> Phase 2 allocates an exact first tier of eight 1-byte slots, then orders the rest by Kahn +> priority (§12.14, §12.15). Phase 3 re-materializes every entry and root at the real TagN +> widths. The candidate with the fewest real bytes wins, ties going to the lower width. +> - **Single route.** Both compilers build every table with it. The heuristic +> (`Ix/Sharing.lean`, `crates/ixon/src/sharing.rs`) and its proofs are removed. +> - **Format.** TagN replaces Tag0, Tag2 and Tag4 (§12.12, §12.16). The format version is 4 +> (`.ixe` header `0xE4`), with object format 4 and the identifiers `ixon-v4` and +> `ixon-v4/resource-v1`. The IxVM circuit reads and writes TagN. +> - **Proofs.** Phase-1 minimality, the per-phase specifications, the equality of the minimized +> length with the serialized length, and wire validity of the output are machine-checked, +> for a run on the canonical DAG of the input (§12.13). The compiled fast implementations are +> tied to the specifications by audited `@[csimp]` equalities (§12.18). +> - **Limits.** Resource limits are a safety net with a CLI override (`ix compile +> --sharing-limits`). Exceeding one is a compile error; there is no fallback. +> - **Compile time.** Mathlib `ix compile` takes 1.13–1.26× the time of the heuristic route +> in the final back-to-back runs (§12.18). +> - **Metadata.** The decompilers implement the extended index space of §13.1. The +> construction of §13.2 is not implemented. +> - **Oracles.** The exact search of §6 is kept as a test oracle for small inputs (§12.1). +> +> Not built: the global minimum of §1 and §3.3, and the metadata construction of §13.2. +> [Ixon](Ixon.md#sharing-system) is the normative description of the format; +> [the integration map](sharing-minimum-integration.md) says where it lives in the code. + +Implementation plan, 2026-09-30 (revision 2). Target: an implementation and reviewable PR in +the **Ix repository**, covering its Lean and Rust paths. §0–§11 are the plan as written, apart +from local paths; §12 and §13 record the decisions taken while implementing it. Revision 1 +and its research oracles are in a separate research directory, not part of this repository. +Revision 2 adds §0 (workspace), §4.1 (proved reductions and bounds), §6.4 (sparse states), +the corpus-measurement gate P1.5, and §11 (division of the work). + +## 0. Workspace, toolchain and corpus + +- The work is based on Ix `864130ec`, the revision the research inspected. +- The toolchain comes from the flake: run every `lake`/`cargo` command as + `nix develop --command bash -c ''` from the repository root. +- Tests: `lake test -- exact-sharing exact-sharing-ffi` runs the construction's suites (the + plan was written against the heuristic's `sharing` suite, since removed); `lake test -- + ixon` the codec suite; `cargo test -p ixon` the Rust crate; `lake build IxCompileVerify` + the proofs. +- Corpus: `Init`, compiled by the production compiler with + `lake exe ix compile Benchmarks/CompileInit.lean --out init.ixe` from the repository root + (NOT `Benchmarks/Compile/CompileInit.lean`, which is a separate Lake project that pulls + Mathlib). It has 65,995 constants; the file was 195 MB in format v3 when the plan was + written and is 143,680,738 bytes in format v4. Load it with `Ixon.deEnv` / + `Ixon.deEnvAnon`; each `LazyConstant` exposes `rawBytes` (the exact production bytes) and + `get` (the parsed `Constant`). +- The production root API is `Ix.CompileM.constantInfoRootExprs` and the rebuild logic in + `Ix.CompileM.buildConstantWithSharing` (`Ix/CompileM.lean`); expand an existing table + before re-optimizing (§7). + +## 1. Outcome and scope + +Replace heuristic selection as the canonical construction rule with an **exact minimum +sharing encoding** of a resolved anonymous Ixon constant/block. Equal anonymous ASTs with +the same ordered roots, contracts, refs/univs bindings and format must produce identical +bytes, regardless of pointer sharing, construction history, encoder implementation or +search strategy. Ixsy should call this pure data operation directly; it must not require +the Lean frontend. + +“Minimum” means the fewest bytes in the **complete serialized Constant**, over all legal +sharing selections, table orders and occurrence-level inline/reference choices. A pinned +total tie-break selects one of the shortest encodings. This is stronger than a deterministic +heuristic, a local optimum, or a result no larger than the old heuristic. + +For this PR, fix all non-sharing choices: ConstantInfo variant and fields, semantic member +and root order, constructor contracts, refs table, univs table and their indices. Do not +normalize universes, transform terms by definitional equality, reorder mutual members, +generate auxiliaries, alter declaration factoring, or jointly optimize metadata. The scope +is the smallest **sharing representation of that AST**, not the smallest equivalent program +or globally smallest `.ixe` environment. + +Metadata must remain correct when primary sharing changes. Its contents cannot influence +the anonymous optimum or address. Metadata-table minimization is a separate task. + +The exact minimum exists and can be computed by finite search for every finite admissible +input. A practical bounded invocation may return a resource error. It must never publish +an uncertified best-so-far result as canonical. Optimizer speed remains an engineering and +benchmarking obligation; no polynomial runtime claim has been established for full Ixon. + +## 2. Starting evidence and source map + +Research inspected Ix revision `864130ecaaee8aac9ddc38eaefdfc333fc793513`. Refresh the +target branch, repository instructions, interfaces and test commands before implementing. +Do not copy stale source over later work. Use an isolated branch/worktree and submit the PR +to Ix. + +Relevant paths at that revision, relative to the Ix checkout (the heuristic's files and +functions in this table were removed by this work): + +| Area | Files / entry points to inspect and update | +|---|---| +| Lean sharing | `Ix/Sharing.lean`: `analyzeBlock`, `decideSharing`, `buildSharingVec`, `applySharingCore`, `applySharing` | +| Lean codec and contracts | `Ix/Ixon.lean`: `putTag0`, `putTag4`, `putExpr`, `putConstant`, `Env.VERSION`; `Ix/IxonContract.lean`, `Ix/IxonMode.lean` | +| Rust sharing/codec | `crates/ixon/src/sharing.rs`, `serialize.rs`, `expr.rs` | +| Lean compiler integration | `Ix/CompileM.lean`: `constantInfoRootExprs`, `mutConstRootExprs`, `buildConstantWithSharing`; `Ix/AuxGen/CompileAux.lean` | +| Rust compiler integration | `crates/compile/src/compile.rs`: `apply_sharing_with_stats`, `apply_sharing_to_*`; `compile/mutual.rs`; `kernel_egress.rs`; `decompile.rs` | +| Cross-language boundary | `crates/ffi/src/lean_ixon/sharing.rs`, existing sharing comparison FFI | +| Metadata and ingress | `Ix/DecompileM.lean`, `Ix/Tc/Ingress.lean`, `Ix/Tc/IngressMeta.lean`, Rust `compile/decompile.rs` and kernel ingress consumers | +| Proofs | `Ix/Compile/Verify/Sharing.lean`, `CompileSharingCodec.lean`, downstream compiler codec theorems and audit manifests | +| Tests | `Tests/Ix/Sharing.lean`, Rust sharing tests, codec/compile/decompile differential suites | +| Version policy and docs | `docs/Ixon.md`, `docs/Ixon-v3.md`, format IDs, manifests, CLI/version checks, generated fixtures | + +The heuristic at that revision estimated `(uses−1)·size − uses·shareRefSize` before +rewriting. It used logical expanded occurrence counts, ignored telescope savings in its +subtree cost, and priced provisional indices before emission changed their order. Its +proofs established wire well-formedness/capacity, not size optimality. + +Known complete-Constant measurements: + +| Fixture | Old heuristic | No sharing | Better candidate / certified minimum | +|---|---:|---:|---:| +| `T2 → T2`, where `Tn = Prop → … → Prop` has n binders | 19 | 20 | **17, exact minimum** | +| `T16 → T16` | 81 | 78 | 46, feasible improvement | +| Nine independent repeated Ref atoms; hot atom previously at slot 8 | 676 | — | 578 with same entries reordered | + +The small witness has `P = Sort(0)`, `T1 = All(P,P)`, `T2 = All(P,T1)`, +`R = All(T2,T2)`, default contracts, `Axio(false,0,R)`, refs `[]`, univs `[Zero]`. +Its old table is `[T1, All(P,Share(0))]`; the minimum stores only `[T2]`. + +```text +old: d200009117b1b10291170000911700b0000100 (19 bytes) +minimum: d200009117b0b001921700170000000100 (17 bytes) +``` + +Another closed fixture has two different minimum 25-byte encodings: let +`A = Prop → Prop`, `B = Prop → Type`, and root `A → A → B → B`, with +univs `[Zero, Succ Zero]`. Both entry orders `[A,B]` and `[B,A]` attain the minimum. +The nine-Ref ordering fixture is a wire/expansion witness, not a kernel-checked recursor. + +Supporting material in the research directory of revision 1 (not part of this repository): + +- the research report (`REPORT.md`), including the finite-space and dynamic-programming + argument; +- an independent report (`astra/report.txt`) with production results, source hashes and a + production probe; +- `Counterexample.lean`: subset codec, kernel-checked small byte-count equalities, and a + complete 3,061,082-candidate search of the tiny witness; +- `ExactDP.lean`, its driver `RunExact.lean`, and `exact-dp-results.txt`: fixed-dictionary + telescope recurrence checked against exhaustive variants in 260 cases; subset DP finds the + 17-byte minimum with 16 states. + +These scripts are research oracles. They do not implement the complete format, general +width buckets, production metering or the proposed structural-ID tie-break. Preserve the +distinction when transferring fixtures to Ix. + +## 3. Normative canonical rule + +Use the following concrete tie-break for this implementation. It permits exact merging of +equal-cost table-order histories and avoids making the optimizer algorithm part of identity. +Do not substitute a hash order, the old heuristic's order, or “first answer found.” + +### 3.1 Logical input and feasible representations + +1. Recover a finite anonymous AST DAG with **no unresolved Share leaves**. Existing tables + must be expanded logically, with cycle/index validation, memoization and explicit bounds. + Expansion need not allocate the full occurrence tree. Fresh compiler ASTs can enter + directly after refs/univs allocation. +2. Use every ordered expression root of the complete ConstantInfo. At the inspected revision: + definitions use type/value; axioms and quotients use type; recursors use type/rule bodies; + mutual blocks flatten each member's roots in member order, including inductive/constructor + types. Projection constants have no roots. Reuse or extract the production root API and + check that rebuilding consumes exactly the same number/order of roots. +3. Candidate sharing tables contain ordinary expressions and Share references. In entry `i`, + every Share index must be `< i`; roots may reference any table entry. Expansion must + reproduce every original root exactly. No shifting, substitution or alpha-renaming of + de Bruijn indices occurs at a Share. +4. All other Constant fields, refs/univs arrays and bindings are unchanged. Serialize each + candidate with the canonical Ixon integer and maximal-telescope rules. + +The backward-reference rule is part of this feasible class, even if a low-level decoder +accepts a larger class of raw graphs. Audit and document that distinction. The claim is a +minimum over valid backward-reference sharing encodings. Do not claim optimality over +unrestricted forward-reference graphs without extending the specification and search. + +### 3.2 Deterministic structural term IDs + +Collect all distinct rooted subterms of the expanded roots, including leaves and entire +roots. Equality includes every constructor, scalar, contract and ordered child. The initial +complete algorithm considers them all; candidate elimination requires a proof. + +Assign IDs `0..N−1` as follows: + +1. A leaf has height 0. A nonleaf has height `1 + max(child heights)`. +2. Process heights in increasing order. Children already have IDs. +3. At one height, sort distinct nodes by `(constructor tag, scalar payload vector, + ordered child-ID vector)`, using numeric comparison for unsigned integers and ordinary + lexicographic vector comparison, with a proper prefix ordered first. +4. Assign consecutive IDs in that order. Structurally identical keys are the same node. + +Pin constructor tags and scalar vectors to the following grammar; all integer values are +compared numerically, not by host memory layout: + +| Constructor/tag | Scalar vector | Ordered children | +|---|---|---| +| Sort / `0x0` | `[univIdx]` | `[]` | +| Var / `0x1` | `[deBruijnIdx]` | `[]` | +| Ref / `0x2` | `[refIdx, numberOfUnivs, univIdxs…]` | `[]` | +| Recur / `0x3` | `[recIdx, numberOfUnivs, univIdxs…]` | `[]` | +| Prj / `0x4` | `[typeRefIdx, fieldIdx]` | `[value]` | +| Str / `0x5` | `[refIdx]` | `[]` | +| Nat / `0x6` | `[refIdx]` | `[]` | +| App / `0x7` | `[]` | `[function, argument]` | +| Lam / `0x8` | `[binderContract.toBits]` | `[type, body]` | +| All / `0x9` | `[packAllContract(input,result)]` | `[type, body]` | +| Let / `0xA` | `[letContract.flags, binderContract.toBits]` | `[type, value, body]` | + +There is no Share node in this input alphabet. Update the rule explicitly if the target +revision has additional semantic constructors/fields. The existing contract pack/unpack +theorems can justify the packed scalar keys. Hash tables and pointer caches may accelerate +discovery, but collisions must resolve by structural keys; hash equality alone is not the +normative identity. No metadata, names, allocator addresses or hash-map traversal order +participates in ID assignment. + +### 3.3 Total minimization key + +For feasible representation `e`, define: + +```text +L(e) = byte length of the complete canonical serialized Constant +Q(e) = vector of structural IDs of its expanded sharing entries, in stored order +K(e) = (L(e), Q(e), serialized Constant bytes) + +canonical(A) = the feasible e with lexicographically least K(e) +``` + +Compare `L` numerically, `Q` lexicographically as a vector of numeric IDs, and bytes by +unsigned lexicographic order. A proper vector prefix sorts first. The byte component makes +the final result unique after the table sequence is fixed. + +This chooses a globally shortest encoding. It intentionally does **not** require the byte- +lexicographically first encoding across different table sequences. Both are canonical +definitions; this one supports the simpler exact DP below. Keep the distinction in docs +and tests. Minimum length is the primary criterion in every case. + +## 4. Complete search space and proof obligations for reductions + +Establish these facts before relying on the reduced search: + +1. A table entry reachable from a root expands to a rooted subterm of that root. +2. Removing an unreachable entry preserves expansion and decreases length: surviving + indices and the sharing-count width cannot increase. +3. Duplicate expanded entries are unnecessary. Redirect every use of the later entry to + the earliest equal entry, delete it and reindex. Backwardness is preserved. A Share stays + a Share, so telescope boundaries are unchanged; reference widths cannot increase. A + positive-length entry is removed, so no minimum contains a duplicate. +4. Every remaining expression representation arises by choosing, at each occurrence, + either its inline constructor or a reference to an equal available entry. + +Hence all ordered subsets of the `N` distinct subterms, with all legal representation +choices for their entries and the roots, cover a minimum. Table order need not follow all +expanded-subtree edges: an earlier large entry can inline a subterm stored separately later. + +Do not prefilter with the current positive-savings test, freeze current topological order, +force every occurrence of a selected term to use Share, or assume maximal DAG sharing is +byte-optimal. Each would exclude candidates that the exact specification allows. + +Single-use elimination, dominance between subterms, decomposition into independent parts, +and restricted-model shortcuts may be worthwhile. They are optimizations only after their +soundness is established for the actual telescope, width and table-prefix cost model. + +### 4.1 Reductions and bounds with proof sketches + +These are the reductions the implementation may rely on. Each must be stated as a lemma +in the Lean development (P2/P3) before the optimized search uses it; the sketches here are +the intended proofs. Notation: `occ(t)` is the number of structural occurrences of subterm +`t` in the expanded roots, counted through every DAG edge with multiplicity and every +root occurrence; `size(t)` is `t`'s standalone inline byte length with no sharing. + +**R1 — single-occurrence elimination.** If `occ(t) = 1`, no minimum stores `t`. +Proof: an entry for `t` can be referenced at most once (its one occurrence; no other +expression expands to `t`). If it is referenced zero times, §4(2) removes it. If exactly +once, replace that Share by the entry's own representation and delete the entry. The +replaced Share was a telescope endpoint; inlining a same-family constructor there merges +its header into the enclosing telescope, so the inlined bytes are at most the entry's +standalone bytes (one fewer if merged; if the merged telescope count crosses a Tag4 width +boundary, cutting again at the old boundary via the entry's own head still costs no more +than before). The Share (≥ 1 byte) disappears and all later indices decrease. Strict +decrease. Consequently candidates are exactly the subterms with `occ ≥ 2`, leaves included. + +**R2 — one-byte terms.** If `size(t) = 1` (Var/Sort/Str/Nat with small index), no minimum +stores `t`: every reference costs ≥ 1 byte, so referencing never beats inlining, and the +entry itself costs ≥ 1 byte plus its Tag0 count unit. Generalize only with care: a term +with `size(t) = w` cannot profit from references of width ≥ w, but its width depends on +the final index, so that is a per-state prune, not a global one. + +**R3 — unreachable and duplicate entries** are §4(2)–(3); keep them. + +**LB — optimistic-dictionary lower bound for branch-and-bound.** At width-state `M` with +`k` entries stored, let `M⁺` grant every candidate term not in `M` a reference of width 1 +and keep the widths of stored terms. Then +`F(M) + tag0Width(k) + fixedBytes + Σ_roots C_{M⁺}(root)` is a lower bound on every +completion of `M`: future entry bodies cost ≥ 0, references never get cheaper than width +1, and `C` is antitone in availability and monotone in widths. Any incumbent (unshared, +old heuristic, or the best certified-so-far) prunes states whose bound exceeds the +incumbent length; equal-length states must be kept for the tie-break (§6.3). + +**Unit-width relaxation (sanity oracle, not the canonical rule).** In the model with no +telescope merging and every reference exactly one byte, the minimum is exactly “store every +positive-weight term with `occ ≥ 2`, in dependency order” (proof in the Astra addendum §6). +Use it as a test oracle for the width-state DP on inputs where telescopes cannot merge, +and as an optimistic estimate of how many entries the true optimum will have. + +**Why the general problem is not obviously polynomial.** Sharing an ancestor reduces the +visible occurrences of its descendants, sharing a descendant shrinks the ancestor's body, +references cut telescopes, and only eight width-1 slots exist. The decision structure is a +fixpoint of an antitone operator (a parent and a child can each be profitable alone but +not jointly), which is the shape of independent-set-like problems. No hardness proof +exists either; P1.5 measures whether real candidate counts make the question moot. + +## 5. Exact expression optimizer for a fixed dictionary + +Let `M` map available expanded term IDs to their Share **byte widths**. Define `C_M(t)` +as the minimum byte length of a standalone expression expanding to `t` using those entries. +For materialization, additionally provide the chosen table sequence, which determines +the actual index of each available term. + +For a leaf, compare its canonical inline bytes with its Share cost if available. For Prj +and Let, add the fixed scalar/contract header and optimal children. Whole-expression sharing +is also an option when its term ID is available. + +For App, Lam and All, optimize the maximal matching spine explicitly. Suppose it has `l` +nodes, with each step's side children/contracts and a final nonmatching tail: + +- Consider sharing the entire expression if available. +- For every inline prefix length `j` from 1 through `l`, charge the actual Tag4 header for + `j`, every emitted contract byte, and each side child's optimal standalone cost. +- If `j < l`, the remaining matching spine can terminate that telescope only as a Share + to the corresponding available subterm. Charge its reference width, or reject that cut + if unavailable. Do not use an arbitrary inline representation of the same-family tail; + the canonical writer would merge it back into the telescope. +- If `j = l`, charge the optimal standalone representation of the natural nonmatching tail. +- App traverses its function spine and emits arguments in the existing wire order; Lam/All + traverse bodies and emit binder types/contracts in outer-to-inner order. + +Memoize by `(dictionary-width state, term ID)` and share spine data/prefix sums where useful. +The scalar recurrence is polynomial per dictionary state; avoid enumerating the Cartesian +product of all child representations. Keep costs as exact naturals or sound checked values. + +After selecting the winning table sequence, materialize each expression's shortest encoding +and choose unsigned byte-lexicographic order among equal-length options. Side expressions +are independent and their lengths add. A rope/DAG or streaming byte comparison may avoid +copying large tie candidates. Verify emitted bytes against the real serializer; an isolated +node-size estimate is not an acceptable substitute. + +Required lemma: the recurrence considers every possible canonical telescope boundary and +returns the minimum standalone expression cost for the fixed dictionary. A plain bottom-up +choice of the cheapest standalone spine child is not sufficient because merging changes +the enclosing header cost. + +## 6. Exact table selection and ordering + +### 6.1 Width-state dynamic program + +Share width is monotone in the index: + +```text +shareWidth(i) = 1 if 0 <= i < 8 + = 1 + minimum LE byte count if 8 <= i < 2^64 +``` + +There are nine widths. A state assigns each term ID either absent or a width. Only states +reachable by filling consecutive actual index positions are valid; width 1 has capacity 8, +width 2 the next 248 positions, width 3 the next 65,280, and so on. Never freely assign a +cheap width beyond its capacity. + +For state `M`, store `F(M)`, the least accumulated byte length of table bodies producing +that state. Also retain the lexicographically least term-ID prefix among equal-cost histories. +Start at the empty state with body cost zero. If `k` entries exist and `t` is absent: + +```text +M' = M extended with t -> shareWidth(k) +candidateBodyCost = F(M) + C_M(t) +relax M' by (candidateBodyCost, priorTermIDSequence ++ [t]) +``` + +The appended entry may use only the prior dictionary. Its own term is absent, so it cannot +refer to itself. Actual dependency order is satisfied by construction, including cases where +an earlier entry inlines a subterm that is added later. + +At every reached state, evaluate stopping: + +```text +totalLength(M) = F(M) + + sum(C_M(root) for each ordered root) + + tag0Width(k) + + fixedNonExpressionConstantBytes +``` + +The fixed part includes ConstantInfo scalar fields, refs/univs tables and their lengths. +Account for the sharing-vector length exactly: Tag0 is one byte through 127 entries, two +through 255, then three, etc. There is no table-body concatenation telescope across entries. +Validate the decomposition against `putConstant` / `Constant::put` for every fixture. + +Choose the stopping state by `(totalLength, retained term-ID sequence)`, then materialize +the byte-minimal expression choices for that sequence. This computes the full key in §3.3. + +### 6.2 Why merging histories is exact + +With the fixed grammar/tables, future expression **lengths** depend only on which expanded +subterms are available and each one's reference width. They do not depend on the exact +index within a width class or on previous entries' internal representations. Therefore a +larger accumulated body cost at the same state is dominated for every continuation. + +On equal cost, same-state prefixes have equal length. Appending a common continuation +preserves their lexicographic order. Retaining the least term-ID prefix therefore preserves +the global secondary tie-break. It would not automatically preserve a different rule that +compared complete bytes before table IDs, since root bytes precede table bodies in the file. + +A coarse bound is `10^N` states (absent plus nine widths) with `N` possible extensions per +state and polynomial expression optimization. Most assignments violate bucket capacities; +if `N <= 8`, the state is simply a subset, with `2^N` states. These are algorithmic upper +bounds, not a claim of necessary complexity or production-scale performance. + +### 6.4 State representation + +Never allocate `10^N` or `2^N` arrays. Represent a width-state as the sorted vector of +(term ID, width) pairs (equivalently the bucket sets), store reached states in a hash map +keyed by that vector, and expand states in order of `k` (entries stored) so that every +transition goes from layer `k` to layer `k+1`; the retained term-ID prefix for ties is +stored with the state. Per layer only the frontier is live. Meter states, transitions and +memo entries (§7) and fail closed when limits are hit. + +### 6.3 Practical search and safe acceleration + +Use the unshared encoding and old heuristic, when representable, to establish feasible +upper bounds. Exact-score improved candidates may tighten the bound. None of them proves +optimality. If the old heuristic's implementation can overflow on the input, skip that +upper-bound source; correctness cannot depend on it. + +Branch-and-bound, A*, sparse subset states, memoization, parallel exploration and solver +backends are permitted if they compute the same minimum key. Every pruning condition needs +a proved lower bound or dominance argument. Do not prune equal-length branches that could +improve the canonical tie. Do not assume independent components are additive until shared +index capacities and the count prefix have been accounted for. + +Keep an intentionally simple exact reference search for tiny inputs, independent of the +optimized search. The optimized implementation must agree with it, not merely beat the old +heuristic. A SAT/MILP backend is optional; a solver returning only a feasible incumbent is +not an exact-success result, and its proof/trust boundary must be explicit. + +## 7. API, validation, resource accounting and arithmetic + +Prefer a pure core over anonymous Ixon data, with explicit success/error results. Illustrative +API shapes, to adapt to the target repository's conventions: + +```text +optimizeSharing(expandedRoots, limits) + -> ExactSharingResult | SharingError + +normalizeConstantSharing(constant, limits) + -> Constant | SharingError + +checkCanonicalSharing(constant, limits) + -> canonical | noncanonical(expectedBytesOrDigest) | SharingError +``` + +`ExactSharingResult` contains rewritten roots and table, exact variable-byte cost, and +optional nonsemantic statistics. Full-Constant integration checks the fixed-cost accounting. +Failures distinguish malformed/cyclic sharing, index/format bounds, and resource exhaustion. +An optimizer must not return a truncated table, silently drop a root, wrap an index, or treat +the best feasible candidate as certified because its budget expired. + +Meter distinct nodes, depth, states, transitions, memo storage, output bytes and tie-byte +comparison/materialization work. Avoid mandatory full tree expansion. Prefer deterministic +work counters for reproducible failures; wall-clock cancellation may abort but cannot select +a different successful encoding. Different limits may change success versus failure, never +the result of two successful invocations on the same input. + +The semantic reference function can be total by finite search. The executable bounded API +returns an error when it cannot complete. Fuel/work limits are operational and must not +redefine the set over which “minimum” is claimed. Exposing a size cutoff as a smaller test +oracle is fine; silently using it as the production optimum is not. + +Lean should reason with `Nat` costs and proved UInt64 conversion bounds. Rust must use +checked arithmetic or an equivalent exact bounded scheme. Logical occurrence counts and +unshared byte lengths may be exponential in the compact DAG size. Never rely on `usize` / +`isize` wraparound, or on `Nat.toUInt64` silently truncating. Saturation used only for +sound pruning must preserve the distinction between equal cost and strictly above the bound. + +If normalizing an already shared Constant, expand against its table before optimization. +Applying the current `applySharing` again to Share-bearing roots is not normalization: the +function receives no old table and treats Share as a leaf. + +## 8. Compiler, metadata and format integration + +### 8.1 Both compiler routes and direct data callers + +Build one explicit root extraction/reassembly interface per language. Derive roots from +ConstantInfo where feasible instead of accepting an unchecked second array. Validate lengths +and order during reassembly; do not use out-of-range fallbacks that leave stale expressions. + +Route Lean definition/axiom/quotient/recursor/mutual/auxiliary compilation and Rust equivalents +through the exact implementation at the selected new construction version. Include kernel +egress, decompile/recompile routes and test FFI. Propagate errors through existing compiler +result types; do not preserve an infallible signature by returning the old heuristic on error. + +Keep low-level Ixon decoding/encoding distinct from the expensive canonical-sharing check. +A caller must explicitly know whether it has only wire validity, well-founded share +expansion, or exact construction canonicality. Ixsy can invoke the pure normalizer/checker +without `Lean.Syntax`, `Lean.Expr`, elaboration or kernel typechecking. + +### 8.2 Metadata invariants + +Audit actual index spaces before remapping. At the inspected revision, +`CallSiteEntry.collapsed.sharingIdx` addresses the per-constant `metaSharing` vector, not +the block's `Constant.sharing` vector. Both start at zero. Do not offset collapsed indices +by the primary table length or merge these namespaces. + +Metadata expressions may also contain Share references or extension refs/univs, according +to the pinned metadata format. If a payload depends on old primary entries, preserve its +logical expression by correct remapping or inlining before removing/reordering those entries. +Do not assume a one-to-one old/new slot map: the optimum can remove a previously stored term. +Preserve per-occurrence arena roots, binder data, call-site surgery, universe patches and +`Named.original`. A metadata-only edit must leave anonymous bytes unchanged. + +Test mutual blocks with both shared anonymous terms and collapsed source call-site payloads. +Keep metadata optimization outside this primary-byte objective. Primary minimization does +not imply that the combined anonymous-plus-metadata artifact has globally minimum length. + +The extended index space for `Share` inside metadata expressions (a metadata `Share(i)` with +`i < p` is a primary entry, `i ≥ p` is `metaSharing[i − p]`) and its construction are specified +in §13; collapsed call-site indices keep addressing `metaSharing` directly. + +### 8.3 Version and address migration + +The inspected `docs/Ixon.md` and `Ixon.Env.VERSION` documentation require a version bump +when serialized bytes change, and require regeneration rather than old-version decoding. +The current header is v3 (`0xE3`). Follow the target repository's current policy: when making +the exact rule canonical for compilation, bump the coordinated format/construction version, +format IDs, manifest pins, readers/writers and golden fixtures. Determine the next version +from the actual target branch; do not hard-code a stale number from this plan. + +The expression byte grammar need not change. Canonical construction and resulting addresses +do change. Do not silently redefine v3, invent an unrecorded per-file profile switch, or add +a multi-version decoder contrary to repository policy. The old heuristic may remain available +for research/regression comparisons and initial upper bounds; that does not make its output +canonical under the new version. + +Recompile/regenerate affected artifacts and dependency addresses, environment roots, pins, +projection/member references, manifests and metadata address references through existing +production flows. Do not relabel an existing artifact with a new header while retaining +unverified contents. A standalone sharing normalizer should return the new Constant/address +and must not imply that it has migrated the whole dependent environment. + +## 9. Proof and validation requirements + +The formal target is a successful result's minimum **key**, not only wire well-formedness. +Organize Lean lemmas so the executable algorithm is connected to its specification: + +1. Structural interning/ID determinism and collision-independent equality. +2. Share expansion correctness, bounds and backwardness, including all expression contracts. +3. Removal of unreachable/duplicate entries and completeness of ordered distinct subterms. +4. Exact serializer length decomposition, including all telescope and integer boundaries. +5. Fixed-dictionary recurrence soundness and completeness; materialization attains its cost + and the least bytes among tied representations. +6. Width-state sufficiency, Bellman recurrence, history dominance and term-ID tie preservation. +7. Successful full optimizer output minimizes the specified key over all feasible encodings. +8. Determinism, preservation of resolved AST, and idempotence of expand-then-normalize. +9. `size(exact) <= size(unshared)` and `size(exact) <= size(old heuristic)` whenever those + candidates are valid for the same problem; derive these from minimality. +10. Connection to the real Constant builder, Lean/Rust parity tests, and existing compiler + codec/verification endpoints after the integration changes. + +Do not establish a similarly named property of a detached toy encoder and present it as a +production theorem. Follow existing axiom/audit conventions; introduce no new `sorry` or +untracked axioms. If a proof milestone remains open, identify its exact statement and mark +the PR incomplete/draft rather than asserting the acceptance gate passed. + +Tests must include: + +| Group | Required coverage | +|---|---| +| Tiny exhaustive oracle | All table orders and independent occurrence choices; compare full key, not only size or expansion | +| Known regressions | 19→17 witness; heuristic worse than unshared; same selected entries with hot slot 8; two 25-byte minima and deterministic tie | +| Telescope behavior | App/Lam/All, nested/mixed constructors, different contracts, natural ends vs internal Share cuts, one term used in different spine contexts | +| Widths | Share 7/8, 255/256, 65535/65536 and remaining UInt64 boundaries; telescope length boundaries; Tag0 table counts 127/128 and 255/256 | +| Ordering | A parent stored before an independently stored descendant by inlining; actual backward refs; arbitrary incoming table orders after logical expansion | +| Semantic coverage | All ConstantInfo/MutConst kinds, multiple roots, all contracts, projections, no-expression constants, refs/recur/str/nat and universe indices | +| Representation independence | Different pointer/DAG/alias layouts; allocation order; map iteration; repeated DAG edges; different incoming valid encodings of the same AST | +| Safety and bounds | Bad indices, cycles, forward refs according to API policy, depth/state/output exhaustion, overflow, empty input, no silent partial success | +| Metadata | Per-occurrence metadata, call-site/eta surgery, collapsed payloads, metaSharing namespace, universe patches, original records, metadata-only edits | +| End-to-end | Lean/Rust byte equality, decode/encode equality, normalize fixpoint, compiler/decompiler roundtrip and new-format migration | + +Large numeric boundary tests should exercise scalar helpers and forced dictionary states; +do not attempt `2^65536` exhaustive optimization to check a three-byte index. Reduced-width +model tests can exercise multi-bucket state merging, but cannot replace tests of actual +format widths. Generate small legal ASTs with an independent exhaustive oracle and shrink +failures to a saved counterexample. + +## 10. Implementation sequence and acceptance gates + +### P0 — Rebase the inventory and freeze the specification + +Read target instructions, inspect callers/validators/format policy, and move this spec into +tracked Ix documentation. Pin the feasible backward-reference class, the exact key and +structural IDs above. Record any necessary revision-specific adaptation explicitly. Confirm +there is no frontend dependency in the public data API. + +Deliver: reviewed spec, integration map and portable golden fixtures. Do not begin by +changing the existing heuristic's score and calling it canonical minimum. + +### P1 — Independent oracle and serializer costs + +Implement the tiny all-order/all-occurrence reference optimizer and exact size helpers. +Port the known fixtures; compare actual complete Constant bytes in Lean and Rust. Verify +the structural-ID ordering and key comparison independently. + +Deliver: reproducible exact minima and tie vectors; scalar/telescope cost tests. + +### P1.5 — Corpus measurement gate (run before designing P3 at scale) + +Using the `init.ixe` corpus (§0), build a harness (`Benchmarks/SharingStudy.lean`, exe +`sharing-study` in `lakefile.lean`) that, for every constant: expands the stored table, +recovers the ordered roots, and reports (a) distinct subterms `N`, (b) candidates after R1 +and R2, (c) the current table size, (d) `rawBytes.size`, the unshared size, and the size +the current heuristic reproduces from the expanded roots (must equal `rawBytes.size`; +count any mismatch as a harness bug). Report the distribution (percentiles, max, the ten +largest) and the total bytes. This decides P3's design: if candidates are small for almost +all constants, the sparse width-state DP with LB pruning is the production algorithm and +the remainder needs a resource-error story; if candidates are routinely in the hundreds, +additional proved reductions are required before any migration and the plan must be +revised. Report the numbers; do not pick a fallback silently. + +### P2 — Fixed-dictionary optimizer + +Implement every constructor and telescope recurrence with witnesses/materialization. +Compare it against enumeration over tiny dictionaries, including arbitrary dictionary order +and mixed inline/reference choices. Add the corresponding proofs. + +Deliver: exact expression costs and byte-minimal witnesses for any fixed legal dictionary. + +### P3 — Global exact search + +Implement width-state DP, history tie-breaking and bounded error behavior. First establish +agreement with the unoptimized oracle, then add safe pruning, caching and fast paths with +separate correctness arguments. Keep cost computation and final materialization separate +where that saves memory. + +Deliver: full-key minimum on successful calls, with state/transition/memory statistics and +an arbitrary finite-input reference algorithm. No heuristic fallback within the exact API. + +### P4 — Production viability measurements + +Benchmark actual singleton constants and mutual blocks from the repository's available +Init/Std/Lean and representative project compile fixtures. Include artificial nested sharing, +long spines, many independent candidates and index-boundary cases. Record distinct-subterm +counts, retained candidate counts after proved reductions, visited states/transitions, +old/unshared/new bytes, wall time, peak memory and all resource failures. Report distribution +and worst cases; a tiny witness's speed is not a production benchmark. + +The naive exponential DP may be unusable at production sizes. Treat that as a concrete +performance result requiring additional exact reductions/algorithms or an explicit adoption +decision. Do not hide it behind a cutoff that changes the canonical result. Resource limits +must be documented and exercised, and ordinary compiler fixtures must not start failing +silently. An exact library plus an unready default migration is not a completed integration. + +### P5 — Integrate and migrate + +Switch all selected-version compiler/data routes together, propagate errors, preserve +metadata, update proof endpoints and bump the coordinated version under repository policy. +Regenerate fixtures and artifacts through their producers. Add explicit canonicality checks +at callers that require them without making every raw decode run the optimizer implicitly. + +Deliver: matching Lean/Rust canonical output, intact roundtrips, version/address migration +evidence and reusable direct-Ixon entry points for Ixsy. + +### P6 — Validate and submit the Ix PR + +At the inspected revision, relevant commands include the following; refresh them against +the current toolchain and target's CI instructions: + +```text +cargo test -p ixon +cargo test -p ix-compile +lake test +lake build IxCompileVerify +``` + +Run the focused exact-sharing/differential tests during development, then the affected +compile/decompile/codec and audit suites required by CI. Check formatting/lint using the +repository's documented commands. Include command outcomes and benchmark data; do not +claim a blocked or unrun check passed. + +Create the branch and PR in Ix with a description that leads with the concrete failure: +the current canonical construction can encode `T2 → T2` in 19 bytes although 17 is possible, +and can even exceed unshared size. Explain the exact minimum key, backward-reference scope, +Lean/Rust integration, resource semantics, version/address impact, proof coverage and +measured performance. Link tracked tests/docs/benchmarks, not only this ignored research +directory. Keep the PR draft if any required acceptance gate remains unresolved. + +The PR is complete when the implementation computes the specified minimum key on success, +all integration/version/metadata paths are coherent, required proofs and checks pass, and +production performance and failure behavior have been reported honestly. A deterministic +compression improvement alone does not satisfy this handoff. + +## 11. Division of the work + +The work splits into four parts with disjoint files. Their interfaces are the spec above +(structural IDs §3.2, key §3.3, recurrence §5, DP §6) and the golden fixtures in §2. + +| Part | Files | Deliverable | +|---|---|---| +| Lean exact core | `Ix/Sharing/Exact.lean` (new; split as needed), `Tests/Ix/SharingExact.lean`, `Tests/Main.lean` suite entry | Structural IDs, bounded share expansion, exact serializer-length helpers checked against `putExpr`, tiny all-order/all-occurrence oracle, fixed-dictionary telescope DP with materialization, sparse width-state DP with LB pruning and resource errors; P1–P3 tests including every §2 fixture | +| Rust exact core | `crates/ixon/src/sharing_exact.rs` (new), its tests, `crates/ffi` differential hook | Same algorithm and key, checked arithmetic, differential test against Lean bytes through the FFI parity harness | +| Corpus measurement | `Benchmarks/SharingStudy.lean`, `lakefile.lean` exe entry, `docs/sharing-minimum-measurements.md` | P1.5 numbers on `init.ixe`; once the Lean core lands, rerun with the exact optimizer under explicit limits and report success rate, byte savings vs heuristic, states/transitions and wall time | +| Integration (after review of the other three) | `Ix/CompileM.lean`, `crates/compile`, metadata remap, version bump, proofs, docs | P5–P6 | + +Integration starts after the P1.5 gate has been evaluated and the exact cores agree on all +fixtures. + +## 12. Decision record after gate P1.5 (2026-09-30) + +Measurements are in `sharing-minimum-measurements.md` (Init corpus, 55,386 rooted constants). + +### 12.1 The width-state DP is not a production algorithm + +Candidates after R1/R2 have median 34, p90 232, p99 1,187, max 22,458. Only 17% of constants +have ≤ 8 candidates. The exact search of §6 stays as the **oracle** for small inputs +(`Ix/Sharing/Exact/*`, suite `exact-sharing`) and is not the canonical construction. + +### 12.2 The in-degree rule (MSS) beats the heuristic + +“Store every compact-DAG node with in-degree ≥ 2 (edge multiplicity + roots) and standalone +size > 1; reference every occurrence; priority topological order” is the exact minimum of the +additive unit-width model. On Init it is 14.5% smaller than the heuristic in total, smaller +on 90.6% of constants, larger on 0.4% (total loss 933 bytes, max 50), never larger than +unshared on Init (on Mathlib 26 of 679,499 constants are larger than unshared, by at most 38 +bytes), and reproduces the 17-byte and 46-byte witnesses. Its losses are all in tables +with > 8 entries, i.e. the index-tier effect. + +### 12.3 Uniform reference width makes the exact minimum tractable + +In the **uniform width model** (every Share costs `w` bytes, everything else the real Ixon +cost including telescopes and the Tag0 count prefix) adding a stored term never raises any +other node's cost, so the exchange argument of §4.1 classifies every candidate with DAG-only +bounds (`deg`, `headdeg`, `occ`, width-aware `payloadMin`/`payloadMax`): + +| w | certain-stored | certain-excluded | uncertain | largest uncertain component p99 / max | +|---|---:|---:|---:|---| +| 1 | 80.5% | 0% | 19.5% | 4 / 45 | +| 2 | 64.1% | 14.9% | 21.0% | 5 / 44 | +| 3 | 54.4% | 24.3% | 21.3% | 6 / 44 | + +Uncertain nodes interact only along DAG paths that avoid certain-stored nodes, so they split +into components (≤ 8 nodes for 99.7% of constants). The canonical algorithm is therefore: +classify → exhaustive search with a sound lower bound per component (cost via the §5 +fixed-dictionary DP with all certain-stored terms available) → pinned dependency order +(in-degree descending, structural ID ascending). Its minimality proof is: exchange lemmas +for the two certain classes, independence of components, completeness of the finite search. +It is implemented as `optimizeSharingUniform` (`Ix/Sharing/Exact/Uniform.lean`). + +### 12.4 Format change: fixed per-constant Share width (proposal) + +To make the uniform model the real byte count, the Share width must not depend on the index. +Proposal **D**: one width per constant chosen by the AST's candidate count `K` (deg ≥ 2 and +size > 1; an AST property, so the width never depends on the chosen table): 1 byte when +`K ≤ 16` (4-bit index in the tag's low nibble), 2 bytes when `K ≤ 4096` (12-bit index), +3 bytes otherwise (20-bit index). Cost measured on the MSS encoding vs today's index tiers: ++0.93% bytes (+638,883 on Init; MSS stays 13.7% below the heuristic). Alternatives measured: +B (2/3 bytes, cut at 2048) +2.07%, C (B plus 1 byte ≤ 8) +1.69%. Under D, 31,200 Init +constants use 1-byte references, 24,180 use 2, 6 use 3. + +Decoder impact: the Share tag `0xB` changes from Tag4 to “flag nibble + index bits”, and the +reader must know `w` before the roots. Either write `K` (or `w`) in the constant header +before `ConstantInfo`, or move the sharing table ahead of the info. Everything else in the +grammar is unchanged. Backward references remain the feasible class (`SharingWF`). +**Status: not adopted.** §12.8 chose the two-phase construction with the TagN layout +instead; the exact uniform algorithm stays parameterised by `w` and is phase 1 of it. + +### 12.5 Revised work plan + +- Lean: `optimizeSharingUniform` + differential tests against the width-state oracle. +- Rust: a port of the same, plus a differential FFI test. +- Corpus: rerun with the exact uniform optimizer (bytes vs MSS/heuristic, class and + component statistics, wall time, resource failures). +- Integration (after the format decision): Share width encoding, header field, + `SharingWF`/codec proofs, compiler routes in Lean and Rust, metadata remap, version bump, + fixtures. + +### 12.6 Corrections from the Lean implementation (pinned rules) + +- **R1 is an exchange, not an exclusion.** An in-degree-1 term `t` can be referenced once + per inline write of its unstored parent `p`. Storing `p` instead (or turning extra writes of + `p` into `Share(p)`) never increases length, so *some* minimum uses only in-degree ≥ 2 terms + and the minimum length is unchanged, but ties exist. The canonical construction is defined as + the minimum over tables whose entries have in-degree ≥ 2; "certain-stored" means "in every + minimum of that class". +- **Continuation-only terms (`headdeg = 0`)** subtract the full `tag4Size(spine length)` of the + entry's own telescope in the gain, not 1. +- **Certain-stored** requires gain ≥ 2 at the lower bounds (absorbs a Tag0 count boundary); + **certain-excluded** is `(occ − 1) · size < occ · w` with exact `occ` and unshared size. +- **Count brackets:** when the stored count reaches a Tag0 boundary a knapsack over components + decides which entries to drop. +- **Tie-break among minimum-length stored sets:** compare indicator vectors over structural IDs + ascending, preferring "not stored" at the first difference (the smaller ID in the symmetric + difference is left out). Decomposes over components. **Table order:** stored descendants + first, then larger in-degree, then smaller ID. +- Lean (`Ix/Sharing/Exact/Uniform.lean`) agrees with the width-state reference on 400 generated + inputs at w ∈ {1,2,3,5}. + +### 12.7 Tier layouts measured (MSS encoding, Init) + +| Layout | 1-byte | 2-byte | Δ vs Tag4 tiers | worse constants | +|---|---|---|---:|---:| +| Tag4 (A) | 8 | 256 | — | — | +| F: two marker bits | 8 | 1,024 | −1.45% | 0 | +| G: nibble escapes 14/15 | 14 | 256 | −1.21% | 0 | +| D: fixed per constant | 16 | 4,096 | +0.93% | 23,342 | + +Recommended layout **TagN** (nibble-bootstrapped; first called Ladder4): nibble `[L][M][c1][c0]`; `L=0` → 3-bit index; `L=1,M=0` → 2 bits + +1 byte (8..1031); `L=1,M=1,c∈{0,1,2}` → 2/4/8 following bytes (offsets continue; `c=3` invalid; +superseded by the 4-byte rung of §12.16). +Bijective (each index has one encoding), capped only at 2^64 like every other count. +Two-phase construction (uniform-model selection → exact 8-slot allocation + pinned order → +re-materialisation under real widths), parameterised by the layout. + +### 12.8 Decision (2026-09-30): two-phase canonical construction with the TagN Share layout + +Chosen over fixed-width D. Canonical sharing of a constant is `canonicalSharingTiered tagN` +(`Ix/Sharing/Exact/Tiered.lean`): phase 1 exact uniform-model selection at the nominal width +from the candidate count; phase 2 exact first-tier (8-slot) allocation, pinned priority order +beyond; phase 3 per-part re-materialisation under real widths. Each phase's optimality claim is +stated in its docstring; the width-1 model length is a provable lower bound on any encoding and +is used to report the gap. The Share tag `0xB` adopts the TagN nibble layout (no header +change, backward references unchanged, bijective so no canonical-integer check is needed). +Open at the time: whether to adopt the TagN code for all Tag0/Tag4 integers (decided in +§12.12). Integration was to start once the Rust uniform/tiered port agreed with Lean on +fixtures. Later changes: phase 1 runs at every width w ∈ {1, 2, 3} (§12.11), and the order +beyond the first tier is the Kahn priority order (§12.14). + +### 12.9 Mathlib corpus (2026-09-30, `docs/sharing-minimum-measurements-mathlib.md`) + +679,499 unique constants (3.3 GB, compiled in 152 s, 18 GB peak RSS); harness: 0 rebuild +mismatches, 0 skipped. Candidates median 69 / p99 2,029 / max 81,833. MSS is **21.8%** below +the heuristic (1,468,281,356 → 1,148,195,956 bytes), smaller on 94.3% of constants, larger on +0.3% (max loss 112 bytes), larger than unshared on 26 constants (≤ 38 bytes each). Uniform-model +classification: certain-stored 88.4 / 71.0 / 57.9% at w = 1/2/3; largest uncertain component +p99 4–5, max 45 (same constant as Init, `Lean.Grind.Config.mk.injEq`), ≤ 8 for 99.8%. Tier +layouts on MSS: F (= TagN below 66,568) −1.55%, G −1.30%, D +1.44%. One stored heuristic table +has 81,565 entries (Tag4 indices ≥ 65,536 cost 4 bytes); the largest MSS table is 21,461. +Lean/Rust parity on Init: 0 byte disagreements in 56,622 constants, tiered and uniform. + +### 12.10 Lean/Rust parity and production speed (2026-10-01) + +- Init, all 56,622 constants, both implementations on the branch-and-reclassify search: + tiered-TagN 0 byte disagreements; uniform-w2 56,622/56,622 identical with no exhaustion. +- Mathlib sample (20,263 constants: every 50th plus every constant with > 2,000 candidates): + 0 byte disagreements in tiered-TagN and uniform-w2; every one-sided Lean exhaustion was the + phase-3 materialisation work limit and gives Rust's bytes once raised; once the separate + `maxMaterializeWork` limit was set to 2^36, all 120 such constants and the 10 Init ones succeed at defaults. +- Rust canonical construction over all 679,499 Mathlib constants: 0 failures, 184 s processing + on 20 threads (315 s wall), 5.3 GB peak RSS; TagN bytes −22.65% vs the stored heuristic. + +### 12.11 Phase-1 width rule corrected (2026-10-01) + +Choosing the nominal uniform width from the candidate count K was wrong: the optimum stores far +fewer terms than K, so real references are narrower than modelled and the w = 2/3 models exclude +terms that pay. On Mathlib the K-based construction was +0.46% vs MSS at TagN widths (larger on +221,050 constants). **New rule:** run phase 1 at each w ∈ {1, 2, 3}, carry each through phases 2 +and 3, and keep the result with the fewest real layout bytes; ties → lower w, then `setPrec`. +Measured (Rust, all constants certified at every w): Mathlib −0.82% vs MSS (smaller on +405,832, equal 256,519, larger 903, max +1,485, p99.9 +1); Init −1.41% (larger on 5, max +6). +Width 1 wins for 505,671 Mathlib constants, width 2 for 156,170, width 3 for 1,413. Cost: three +phase-1 runs instead of one (about 3× the time; still minutes for all of Mathlib in Rust). + +### 12.12 Decision (2026-10-01): TagN replaces all three integer codes + +Owner decision: TagN (flag widths 0, 2, 4) replaces Tag0, Tag2 and Tag4 everywhere in the Ixon +grammar, for uniformity and to simplify the serialization. Measured byte effect is the Share +savings only (other fields change by ≈0), and no integer gets longer. Consequences: one integer +code with one proof of roundtrip/bijectivity (`Ix/Compile/Verify/TagN.lean`); the three +"noncanonical … integer" reader checks are removed; every codec theorem that mentions +`tag0Bytes`/`tag4Bytes` sizes is restated with `tagNBytes`; the format version bumps once for +sharing + integers together. + +### 12.13 What is machine-checked (first recorded 2026-10-01; stated at this PR's head) + +The theorems below are roots of the compiler audit manifest +(`Ix/Compile/Verify/Audit/Statements.lean`, 250 roots at this PR's head; each root's axioms are +fixed exactly, and no declaration of `Ix.Compile.Verify` or `Ix.Sharing` uses `sorry`; checked +by `lake build IxCompileVerify`). The construction theorems are stated for a successful run on +the canonical DAG of the input (`ex.dag`, `ex.roots`). + +- **Phase 1** (`UniformOptimality.lean`): `optimizeUniform_minimum` (a successful + `optimizeUniformExpanded w limits ex` returns a stored set that is a minimum of the uniform + model `ulen` over the restricted class, with `modelBytes` equal to it) and + `optimizeUniform_least` (it is the `setPrec`-least such minimum), both under + `limits.uniformSubsetSearch = false`. The certain-excluded class needs every telescope spine + shorter than `teleSubaddEnd`, which the optimizer checks before it runs (§12.17). + Reachability of every term from a root is a runtime check plus `optimizeUniform_reach`. +- **Phases 2 and 3 and the width selection** have per-phase specifications: `allocate_spec`, + `firstTier_spec`, `allocate_optimal` (the order's reference cost is minimal when the table + has at most 1,032 entries), `materializeTable_min`, `rematerialize_spec` (including the round + trip to the stored terms and root IDs of the canonical DAG), `phase3_le_phase1` and + `canonicalTieredCore_select`. The one-pass phase 3 equals the per-prefix specification on + every input (`materializeTableOnePass_eq`). +- **Serialized length.** `canonicalSharingTiered_serialized` (`TieredWire.lean`; the same for + `canonicalSharingTieredTable_serialized`): if `canonicalSharingTiered .tagN roots limits = + .ok r`, then `r.result.variableBytes = tag0Size r.result.sharing.size + Σ (serExpr e).size` + over the table entries and roots, and `r.result.modelBytes = r.result.variableBytes`. The + layout length that phase 3 and the width selection minimize is therefore the serialized + length. Supporting facts: `exprSize_eq_serExpr` (the TagN-priced size is the serialized + length of every wire-domain expression), `serConstant_size_decomposition` (a constant's + serialized length splits into root-free bytes, roots, table count and table entries) and + `optimizeUniform_variableBytes` (phase 1's serialized length equals its model length when + every index has width `w`). +- **Format.** `canonicalSharingTiered_format` (`TieredWire.lean`) gives every output entry and + root `wireWF`, a table count below 2^64, and backward Shares (entry `k` references only + entries below `k`, roots only table entries). The compiler endpoint theorems + (`buildConstantWithSharing_wireWF` and the `*_codecWF` theorems of + `Ix/Compile/Verify/Compile*Codec.lean`) are stated over it and conclude `SharingRunOK`: a + compiler run returns an exactly decodable block, or fails with an error that the sharing + builder returns on some payload (the payload is existentially quantified). +- **Compiled code.** The compiler runs fast twins attached to the specifications by + unconditional `@[csimp]` equalities; `Ix/Compile/Verify/Audit/CompiledCode.lean` fails the + build unless every csimp theorem on the compiler's import path is an audit root (19 at + this PR's head) and unless `Ix.Sharing.*` has no `unsafe`, `partial`, `implemented_by` or `extern` + declaration besides the pointer-cache key `exprPtr`. + +Run-time checks that remain in Lean's phase 3 (`rematerialize`), each failing closed with an +internal error, in this order: the layout length equals the evaluated length; it is at most +phase 1's layout length (proved never to fail, `phase3_le_phase1`); the output re-expands, +through the same interner, to the stored terms and the input's root IDs; and every output +expression is in the wire domain. Rust serializes the returned candidate and compares its +length (every candidate in its checked mode, §12.18). + +Not machine-checked: phase-2 optimality for tables of more than 1,032 entries; any global +minimum; and the step from the input expressions to the canonical DAG (`expand`, whose +interner keys a cache by the `unsafe` pointer address `exprPtr`). No theorem states that this +DAG denotes the input expressions, so the round trip to the input is proved only relative to +the DAG; independence from pointer layout is tested, and idempotence is proved only under the +hypothesis that the output expands to the input's DAG (`canonicalSharingTieredTable_idem`). +The reference enumeration path (`uniformSubsetSearch = true`) is excluded from the theorems. +Failure semantics: an error at any width fails the whole call, with the lowest failing width's +error (no fallback to other widths). Rust matches on every limit and length check; its default +mode runs the checks of built expressions only for the returned candidate (§12.18). + +### 12.14 Best-of-four rejected; outlier diagnosis (2026-10-01) + +Adding "store every candidate" as a fourth phase-1 candidate closes 901 of the 903 Mathlib +losses vs MSS but saves only 2,896 bytes in total (of 1.12 GB) and costs a fourth pass; not +adopted. The one real outlier (`Affine.Triangle.dist_orthogonalProjectionSpan…`, +1,485 vs MSS) +loses even with MSS's exact stored set (67,367 vs MSS 63,779), so the gap is in phase 2's pinned +order for entries beyond the first tier (its 2,230 entries straddle the TagN 1,032 boundary): +the "stored descendants first" order places high-reference entries late, whereas MSS's Kahn +priority order (largest in-degree among available entries) keeps them in the 2-byte tier. +Adopted: phase 2's order beyond the first tier is the Kahn priority order by reference count +(ties by structural ID), which is also what MSS measured with. + +### 12.15 Outlier resolved (2026-10-01): a tie-break artifact, no rule change + +The +3,588-byte loss of the construction vs "MSS" on `Affine.Triangle.dist_orthogonalProjectionSpan…` +is entirely the tie rule inside the Kahn priority order: the measured MSS broke ties between +equal-in-degree entries by blake3 hash, the construction by structural ID. With 2,230 entries +straddling the TagN 1,032 boundary, the tie order moves thousands of references between the 2- and +3-byte rungs (widths [1101, 13699, 4149] vs [1101, 10111, 7737]). Rust re-implementation of MSS with +both tie rules on all 679,499 Mathlib constants: the construction's "store-all" candidate is **never +larger than MSS under the same tie rule** (0 larger, 157,438 smaller, −1,227,943 B); structural-ID +ties beat blake3 ties in aggregate by 374,383 B; choosing the better rule per constant would gain +only 0.011%. Phase 2's exact allocation covers the first tier; beyond it the order is the greedy +Kahn rule, whose tie-break is pinned (structural ID). A possible refinement, not adopted: exact +maximum-weight closed set for the ≤ 1,032-entry second rung (same problem as the first tier with a +larger cap), relevant only to tables that straddle the boundary. + +### 12.16 TagN gains a 4-byte rung (owner decision, 2026-10-01) + +Rung codes after `L=1, M=1`: `c = 0, 1, 2, 3` → 2, 3, 4, 8 following little-endian bytes (code 3 was +invalid). Widths become 1/2/3/4/5/9 for every flag width f ∈ {0, 2, 4}; rung ends +`R1 = 2^(r−1)`, `R2 = R1 + 2^(r−2+8)`, `R3 = R2 + 2^16`, `R4 = R3 + 2^24`, `R5 = R4 + 2^32`, +`R6 = R5 + 2^64` (r = 8 − f). Reason: without it, f = 0 values in [82,048, 2^24) cost 5 bytes where +Tag0 cost 4; Mathlib's 4.8M name indices lose 22.1 MB (+0.66% of the file). With it TagN is never +longer than the old codes on any field measured. Still bijective; `Ix/Ixon.lean`'s TagN docstring is +the normative layout. + +### 12.17 Proof-library status after the TagN switch (2026-10-01) + +The whole verification library is restated against the TagN-only codec and the six-rung table +(`IxCompileVerify` 227 audit roots, `IxTcVerify` 2034+7+1, sorry frontier clean, no new axioms). +Changes to earlier statements in this section: the certain-stored threshold is now +θ = `tag0StepBound n + 1` (exact Tag0 growth, replacing the fixed "gain ≥ 2"); header-width +subadditivity (`tag4Size_add_le`) holds only below `teleSubaddEnd = Ixon.tagNEnd5 4` +(4,311,811,080), so `optimizeUniformExpanded` fails closed (`formatBound "telescope spine length"`) +on any longer telescope spine and the optimality theorems derive the bound from that guard; +`ShareLayout` has the single constructor `tagN`. Lean/Rust parity re-checked: 0 disagreements on +fixtures, 350 generated inputs, 124 Share-bearing constants and 306 compiler-route cases. +Removing the heuristic later dropped its two audit roots (`rewriteWithSharing_wireWF`, +`applySharing_wireWF`), leaving 225. + +### 12.18 Compile time, the fast implementations and the review (2026-10-02) + +**Owner acceptance.** Mathlib `ix compile` with the canonical route must stay within 1.5× of the +heuristic route, ideally closer, and only speedups specific to the canonical route belong in +this PR (general pipeline work is deferred). Measured: 1.13–1.26× in the final back-to-back runs +(1.24–1.30× in earlier ones; numbers in `sharing-minimum-performance.md`). Width 3 stays: +dropping it would cost 35,783 bytes on Mathlib (1,395 constants) and 6,891 bytes on Init (184 +constants) and is held in reserve. + +**Rust** (byte-identical on all of Init and Mathlib). Phase 3 evaluates the whole table once when +the order is closed under stored descendants (every order of Init and Mathlib is) and falls back +to one evaluation per prefix otherwise; width-independent tables are shared by the three widths; +the table-count knapsack works on ranks; phase 1 is a dry run that builds no expressions. Checks +(module documentation of `crates/ixon/src/sharing_exact/tiered.rs`, "Checks"): in the default +mode, which the compiler uses, every limit and every phase-1 to phase-3 length check applies to +all three candidates and an error at any width fails the call with the lowest failing width's +error, while the checks on built expressions (one-pass decisions and their `work`, the build, +the layout price, re-expansion and node count, the serialized length) run only for the returned +candidate. The checked mode (`ExactSharingLimits::full_check`: unit tests, the FFI parity hooks, +`sharing_corpus --full-check`) builds and verifies all three; over all of Init (56,622 +constants) and all of Mathlib (679,499) it has no failure and gives the same output as the +default mode. `work` charges the work done: one evaluation of the whole table plus the +hidden-top evaluations in one pass, one evaluation per prefix otherwise; the one-pass decisions +are charged to the returned candidate. The per-prefix path is reachable: an App spine of 1,288 +nodes ending in a stored term (7,105 bytes, the same as Lean's) is a fixture in both languages. + +**Lean.** Lean is the proved reference. Fast twins (`Exact.Phase3`, `Exact.Reexpand`, +`Exact.UniformSearchLocal`, `Exact.TierFast`, `Exact.PinnedDeps`, `Exact.PinnedFast`, +`Exact.KnapsackFast`, `Exact.TieredFast`; the module map of `Ix/Sharing/Exact.lean`) are attached +to the specifications by unconditional `@[csimp]` equalities, which are audit roots; +`Ix/Compile/Verify/Audit/CompiledCode.lean` fails the build if a csimp theorem on the compiler's +import path is not a root, and the sorry frontier covers `Ix.Sharing`. Phase 3 also runs in one +pass (`materializeTableOnePass`, equal to `materializeTable` on every input, +`materializeTableOnePass_eq`, with the same `materializeWork`), and the three widths run as +parallel tasks above 1,024 DAG terms (`tieredCandidates_eq`). The merge-queue partition +(`lake test -- --ignored compile`, Lean and Rust compile every constant of the test environment) +takes 11:51 against 15:30 before the route switch; its Lean step takes 238 s against 177 s. +The construction is still 8–15× slower than Rust single-threaded, short of the 2–4× target: the +specification's cost model evaluates a component's whole closure where Rust evaluates its area, +so closing the gap needs a change of the specification and its proofs (follow-up). + +**Review fixes.** Rust no longer applies its `candidates` limit (2^16, meant for the width-state +oracle) to the canonical path; in both languages the candidate count is recorded, not limited +(Rust regression test: 70,000 distinct references used twice). `knapsack_cells` (2^28) is about +27 times the largest knapsack on Init and Mathlib. The limits override is parsed by one grammar +in both languages (digits only; 35 shared specifications) and read once per run. Rust's phase +1 uses 128-bit lengths and fails closed (`LengthOverflow`) where Lean's `Nat` succeeds, e.g. on +the chain `e(i+1) = App(e(i), e(i))` at depth 127 or more; this divergence is documented, not +removed (no corpus constant is near it). The layout length equals the serialized length by +theorem (§12.13), and the metadata table check is linear in both languages. + +## 13. Metadata sharing: the extended index space (owner decision 2026-10-01) + +Status: **the index space (§13.1) is implemented by the readers; the construction (§13.2) is +not.** No writer emits a `Share` inside a metadata expression, and serialization is unchanged. +The opportunity is small (`sharing-minimum-measurements.md`): Init has no metadata expressions; +Mathlib has 524 in 7 constants, 42,929 bytes in total (0.0013% of the file), and the best +possible re-encoding saves about 40 KB. The reader rule is fixed now so that readers need not +change when a construction lands. + +### 13.1 Index space + +Let a constant have the primary sharing table `sharing` with `p` entries, and metadata +`ConstantMeta` with `metaSharing` of `q` entries. A `Share(i)` occurring inside an expression +of `metaSharing` denotes: + +* `i < p`: primary entry `i` (its expansion against the primary table); +* `p ≤ i < p + q`: `metaSharing[i − p]` (its expansion), subject to the well-foundedness + rule below; +* `i ≥ p + q`: invalid (a decode error). + +This mirrors the existing extension tables (`metaRefs`, `metaUnivs`), which already extend the +primary `refs`/`univs` index spaces. A `Share` inside a primary expression (a primary table +entry or a primary root) always denotes a primary entry (`i < p`); metadata never changes how +primary bytes decode. + +Well-foundedness: entry `metaSharing[j]` may reference every primary entry and the metadata +entries before it (`p ≤ i < p + j`); a reader expands `metaSharing` in order, each entry against +`sharing ++ metaSharing[0..j)`. Call-site references are unchanged: `CallSiteEntry.collapsed +sharingIdx` and `origHead = some (sharingIdx, …)` index `metaSharing` directly +(`metaSharing[sharingIdx]`, no offset by `p`), as in §8.2. + +Readers. Only the two decompilers read `metaSharing` contents, and both implement the rule: +Lean `Ix.DecompileM` (`ShareScope`, `resolveShareIn`; also the semantic-contract scan +`Ix.SemanticContract.containsIxon`) and Rust `ix_compile::decompile` (`ShareScope`; also +`semantic_contract::contains_ixon`). A primary `Share(i)` with `i ≥ p` is +`invalidShareIndex`; a metadata `Share(i)` outside `[0, p + j)` is `invalidMetaShareIndex` +(Rust `InvalidMetaShareIndex`, error tag 11 in both languages), with `i ≥ p + q` out of range +and `p + j ≤ i < p + q` a forward or self reference. When a constant's metadata is loaded, the +whole table is checked first (`validateMetaSharing`, Rust `validate_meta_sharing`), reporting +the first violation in entry order and then left-to-right pre-order. Kernel ingress +(`Ix/Tc/IngressMeta.lean`, Rust `crates/kernel/src/ingress.rs`), the IxVM circuit and the +resource validators do not read `metaSharing` contents. Two gaps of the readers predate this +rule and are not addressed by it: a call site nested inside a metadata expression may reference +any `metaSharing` entry, including its own, and neither the decompilers nor kernel ingress check +that primary table entries reference only earlier entries. A malformed table of either kind can +therefore make them loop instead of failing; hardening the readers is follow-up work. + +### 13.2 Canonical construction (specified, not implemented) + +The primary table is constructed first, from the primary roots alone (§12.8, `canonicalSharingTiered`), +and is never influenced by metadata: the metadata construction takes the primary result as a +fixed input. Given the primary table (`p` entries, the Share at index `i` priced by the layout +width of `i`) and the metadata roots (the collapsed call-site argument expressions and any other +`Expr` payloads of `ConstantMeta`, each expanded against the old primary and metadata tables +into the canonical DAG of the constant): + +1. Every primary entry is pre-stored, at its own index and real width (certain-stored in the + uniform search; never removed, never moved). +2. Candidates for new entries are the metadata roots' subterms of in-degree at least 2, counting + occurrences across the metadata roots only (primary subterms are already available through + the pre-stored entries). +3. The same three-phase construction selects and orders the new entries `N`, at indices + `p, p + 1, …` (TagN widths at those indices); phase 3 re-materializes each new entry against + the primary entries and the new entries before it, and each metadata root against the whole + dictionary (primary entries and `N`). +4. `metaSharing = N ++ R`, where `R[r]` is the re-materialized metadata root `r` in its original + order; every call-site index to root `r` becomes `|N| + r`. + +Obligations when implemented: the primary table, primary roots and primary bytes are identical +with and without metadata (a theorem, by construction: the primary result is an input); +expansion round trip of every metadata root; idempotence; Lean/Rust byte parity; fixtures. +Like §8.2, this does not make the combined primary-plus-metadata artifact a global minimum. diff --git a/docs/source-contracts.md b/docs/source-contracts.md index 005bbdbb6..e18671612 100644 --- a/docs/source-contracts.md +++ b/docs/source-contracts.md @@ -4,7 +4,7 @@ The Ix frontend records three independent properties: usage, ownership, and relative locality. Aiur is one consumer of this shared frontend. The source frontend resolves exact binder occurrences before canonicalization -and sharing. Both environment compilers preserve those contracts in Ixon v3 +and sharing. Both environment compilers preserve those contracts in Ixon v4 and run resource and erased-type validation before emitting annotated output. Persistent registrations and annotations survive imports. The decompiler reconstructs committed contracts independently of optional presentation data. @@ -19,7 +19,7 @@ recursor generation and nonidentity compiler surgery currently report an unsupported transformation before emission. Ordinary source keeps its existing compilation path. Source syntax alone does not establish resource validity. -The complete semantic and binary design is in [Ixon v3](Ixon-v3.md). +The complete semantic and binary design is in [Ixon v4](Ixon-v4.md). ## Modes @@ -197,6 +197,6 @@ The focused `source-contract-tests` target checks source identity, distinct occurrences of equal terms, every arrow contract, syntax, imported interfaces, native metadata, result placement, both let kinds, and rejection of unadmitted external interfaces before artifacts are written. Syntax fixtures also reject accidental -`sorryAx` insertion. The `ixon-v3-tests` target separately exercises binary -representations, FFI, sharing hashes, accepted compilation and decompilation, +`sorryAx` insertion. The `ixon-v4-tests` target separately exercises binary +representations, FFI, accepted compilation and decompilation, resource admission, VM execution, interpretation, and proving. diff --git a/flake.nix b/flake.nix index 69bbf742a..075b0202f 100644 --- a/flake.nix +++ b/flake.nix @@ -104,7 +104,7 @@ root = ./.; fileset = pkgs.lib.fileset.unions [ (pkgs.lib.fileset.fromSource (craneLib.cleanCargoSource ./.)) - ./Tests/Fixtures/ixon-v3 + ./Tests/Fixtures/ixon-v4 ]; }; # Rust code generation for the sandboxed builds. `.cargo/config.toml` diff --git a/lakefile.lean b/lakefile.lean index 8d8807df8..1d327b73a 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -166,14 +166,17 @@ lean_exe «source-contract-tests» where root := `Tests.SourceContractMain supportInterpreter := true -/-- Focused v3 codec, locality, and cross-language transport checks. -/ -lean_exe «ixon-v3-tests» where - root := `Tests.IxonV3Main +/-- Focused Ixon v4 codec, locality, and cross-language transport checks; +`--export-fixtures` and `--export-handoff` regenerate the generated fixtures. +Scratch files live in `$IX_IXON_V4_DIR` (default `/tmp`); see `--help`. -/ +lean_exe «ixon-v4-tests» where + root := `Tests.IxonV4Main moreLinkObjs := #[ix_rs_test] -/-- Regenerate format-specific primitive identities from the installed Lean environment. -/ -lean_exe «ixon-v3-primitives» where - root := `Tests.IxonV3Primitives +/-- Regenerate format-specific primitive identities from the installed Lean +environment, into `$IX_IXON_V4_DIR` (default `/tmp`); see `--help`. -/ +lean_exe «ixon-v4-primitives» where + root := `Tests.IxonV4Primitives supportInterpreter := true moreLinkObjs := #[ix_rs_test] @@ -181,6 +184,9 @@ end Tests section Benchmarks +lean_exe «uniform-hard» where + root := `Benchmarks.UniformHard + lean_exe «bench-aiur» where root := `Benchmarks.Aiur @@ -228,6 +234,15 @@ lean_exe «bench-lean4lean» where lean_exe «bench-compile-init» where root := `Benchmarks.CompileInit +lean_exe «lean-sharing-prof» where + root := `Benchmarks.LeanSharingProf + +/-- Corpus measurement for canonical sharing (`docs/sharing-minimum.md`): +expands every stored sharing table in an `.ixe`, checks the production +rebuild and reports subterm, candidate and MSS statistics. -/ +lean_exe «sharing-study» where + root := `Benchmarks.SharingStudy + /- Typed TruthMines corpus records: the package catalog, the frozen admission spec, fail-closed validation (elaboration-time `run_cmd` gate), and workspace projections consumed by the `truthmines` driver and the `truthmines-spec`